{"version":3,"file":"protobufjs-DvDCtrWC.js","sources":["../../node_modules/protobufjs/src/util/longbits.js","../../node_modules/protobufjs/src/util/minimal.js","../../node_modules/protobufjs/src/writer.js","../../node_modules/protobufjs/src/writer_buffer.js","../../node_modules/protobufjs/src/reader.js","../../node_modules/protobufjs/src/reader_buffer.js","../../node_modules/protobufjs/src/rpc/service.js","../../node_modules/protobufjs/src/rpc.js","../../node_modules/protobufjs/src/roots.js","../../node_modules/protobufjs/src/index-minimal.js","../../node_modules/protobufjs/minimal.js"],"sourcesContent":["\"use strict\";\nmodule.exports = LongBits;\n\nvar util = require(\"../util/minimal\");\n\n/**\n * Constructs new long bits.\n * @classdesc Helper class for working with the low and high bits of a 64 bit value.\n * @memberof util\n * @constructor\n * @param {number} lo Low 32 bits, unsigned\n * @param {number} hi High 32 bits, unsigned\n */\nfunction LongBits(lo, hi) {\n\n    // note that the casts below are theoretically unnecessary as of today, but older statically\n    // generated converter code might still call the ctor with signed 32bits. kept for compat.\n\n    /**\n     * Low bits.\n     * @type {number}\n     */\n    this.lo = lo >>> 0;\n\n    /**\n     * High bits.\n     * @type {number}\n     */\n    this.hi = hi >>> 0;\n}\n\n/**\n * Zero bits.\n * @memberof util.LongBits\n * @type {util.LongBits}\n */\nvar zero = LongBits.zero = new LongBits(0, 0);\n\nzero.toNumber = function() { return 0; };\nzero.zzEncode = zero.zzDecode = function() { return this; };\nzero.length = function() { return 1; };\n\n/**\n * Zero hash.\n * @memberof util.LongBits\n * @type {string}\n */\nvar zeroHash = LongBits.zeroHash = \"\\0\\0\\0\\0\\0\\0\\0\\0\";\n\n/**\n * Constructs new long bits from the specified number.\n * @param {number} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.fromNumber = function fromNumber(value) {\n    if (value === 0)\n        return zero;\n    var sign = value < 0;\n    if (sign)\n        value = -value;\n    var lo = value >>> 0,\n        hi = (value - lo) / 4294967296 >>> 0;\n    if (sign) {\n        hi = ~hi >>> 0;\n        lo = ~lo >>> 0;\n        if (++lo > 4294967295) {\n            lo = 0;\n            if (++hi > 4294967295)\n                hi = 0;\n        }\n    }\n    return new LongBits(lo, hi);\n};\n\n/**\n * Constructs new long bits from a number, long or string.\n * @param {Long|number|string} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.from = function from(value) {\n    if (typeof value === \"number\")\n        return LongBits.fromNumber(value);\n    if (util.isString(value)) {\n        /* istanbul ignore else */\n        if (util.Long)\n            value = util.Long.fromString(value);\n        else\n            return LongBits.fromNumber(parseInt(value, 10));\n    }\n    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;\n};\n\n/**\n * Converts this long bits to a possibly unsafe JavaScript number.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {number} Possibly unsafe number\n */\nLongBits.prototype.toNumber = function toNumber(unsigned) {\n    if (!unsigned && this.hi >>> 31) {\n        var lo = ~this.lo + 1 >>> 0,\n            hi = ~this.hi     >>> 0;\n        if (!lo)\n            hi = hi + 1 >>> 0;\n        return -(lo + hi * 4294967296);\n    }\n    return this.lo + this.hi * 4294967296;\n};\n\n/**\n * Converts this long bits to a long.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long} Long\n */\nLongBits.prototype.toLong = function toLong(unsigned) {\n    return util.Long\n        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))\n        /* istanbul ignore next */\n        : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };\n};\n\nvar charCodeAt = String.prototype.charCodeAt;\n\n/**\n * Constructs new long bits from the specified 8 characters long hash.\n * @param {string} hash Hash\n * @returns {util.LongBits} Bits\n */\nLongBits.fromHash = function fromHash(hash) {\n    if (hash === zeroHash)\n        return zero;\n    return new LongBits(\n        ( charCodeAt.call(hash, 0)\n        | charCodeAt.call(hash, 1) << 8\n        | charCodeAt.call(hash, 2) << 16\n        | charCodeAt.call(hash, 3) << 24) >>> 0\n    ,\n        ( charCodeAt.call(hash, 4)\n        | charCodeAt.call(hash, 5) << 8\n        | charCodeAt.call(hash, 6) << 16\n        | charCodeAt.call(hash, 7) << 24) >>> 0\n    );\n};\n\n/**\n * Converts this long bits to a 8 characters long hash.\n * @returns {string} Hash\n */\nLongBits.prototype.toHash = function toHash() {\n    return String.fromCharCode(\n        this.lo        & 255,\n        this.lo >>> 8  & 255,\n        this.lo >>> 16 & 255,\n        this.lo >>> 24      ,\n        this.hi        & 255,\n        this.hi >>> 8  & 255,\n        this.hi >>> 16 & 255,\n        this.hi >>> 24\n    );\n};\n\n/**\n * Zig-zag encodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzEncode = function zzEncode() {\n    var mask =   this.hi >> 31;\n    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;\n    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;\n    return this;\n};\n\n/**\n * Zig-zag decodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzDecode = function zzDecode() {\n    var mask = -(this.lo & 1);\n    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;\n    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;\n    return this;\n};\n\n/**\n * Calculates the length of this longbits when encoded as a varint.\n * @returns {number} Length\n */\nLongBits.prototype.length = function length() {\n    var part0 =  this.lo,\n        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,\n        part2 =  this.hi >>> 24;\n    return part2 === 0\n         ? part1 === 0\n           ? part0 < 16384\n             ? part0 < 128 ? 1 : 2\n             : part0 < 2097152 ? 3 : 4\n           : part1 < 16384\n             ? part1 < 128 ? 5 : 6\n             : part1 < 2097152 ? 7 : 8\n         : part2 < 128 ? 9 : 10;\n};\n","\"use strict\";\nvar util = exports;\n\n// used to return a Promise where callback is omitted\nutil.asPromise = require(\"@protobufjs/aspromise\");\n\n// converts to / from base64 encoded strings\nutil.base64 = require(\"@protobufjs/base64\");\n\n// base class of rpc.Service\nutil.EventEmitter = require(\"@protobufjs/eventemitter\");\n\n// float handling accross browsers\nutil.float = require(\"@protobufjs/float\");\n\n// requires modules optionally and hides the call from bundlers\nutil.inquire = require(\"@protobufjs/inquire\");\n\n// converts to / from utf8 encoded strings\nutil.utf8 = require(\"@protobufjs/utf8\");\n\n// provides a node-like buffer pool in the browser\nutil.pool = require(\"@protobufjs/pool\");\n\n// utility to work with the low and high bits of a 64 bit value\nutil.LongBits = require(\"./longbits\");\n\n/**\n * Whether running within node or not.\n * @memberof util\n * @type {boolean}\n */\nutil.isNode = Boolean(typeof global !== \"undefined\"\n                   && global\n                   && global.process\n                   && global.process.versions\n                   && global.process.versions.node);\n\n/**\n * Global object reference.\n * @memberof util\n * @type {Object}\n */\nutil.global = util.isNode && global\n           || typeof window !== \"undefined\" && window\n           || typeof self   !== \"undefined\" && self\n           || this; // eslint-disable-line no-invalid-this\n\n/**\n * An immuable empty array.\n * @memberof util\n * @type {Array.<*>}\n * @const\n */\nutil.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes\n\n/**\n * An immutable empty object.\n * @type {Object}\n * @const\n */\nutil.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes\n\n/**\n * Tests if the specified value is an integer.\n * @function\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is an integer\n */\nutil.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {\n    return typeof value === \"number\" && isFinite(value) && Math.floor(value) === value;\n};\n\n/**\n * Tests if the specified value is a string.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a string\n */\nutil.isString = function isString(value) {\n    return typeof value === \"string\" || value instanceof String;\n};\n\n/**\n * Tests if the specified value is a non-null object.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a non-null object\n */\nutil.isObject = function isObject(value) {\n    return value && typeof value === \"object\";\n};\n\n/**\n * Checks if a property on a message is considered to be present.\n * This is an alias of {@link util.isSet}.\n * @function\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isset =\n\n/**\n * Checks if a property on a message is considered to be present.\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isSet = function isSet(obj, prop) {\n    var value = obj[prop];\n    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins\n        return typeof value !== \"object\" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;\n    return false;\n};\n\n/**\n * Any compatible Buffer instance.\n * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.\n * @interface Buffer\n * @extends Uint8Array\n */\n\n/**\n * Node's Buffer class if available.\n * @type {Constructor<Buffer>}\n */\nutil.Buffer = (function() {\n    try {\n        var Buffer = util.inquire(\"buffer\").Buffer;\n        // refuse to use non-node buffers if not explicitly assigned (perf reasons):\n        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;\n    } catch (e) {\n        /* istanbul ignore next */\n        return null;\n    }\n})();\n\n// Internal alias of or polyfull for Buffer.from.\nutil._Buffer_from = null;\n\n// Internal alias of or polyfill for Buffer.allocUnsafe.\nutil._Buffer_allocUnsafe = null;\n\n/**\n * Creates a new buffer of whatever type supported by the environment.\n * @param {number|number[]} [sizeOrArray=0] Buffer size or number array\n * @returns {Uint8Array|Buffer} Buffer\n */\nutil.newBuffer = function newBuffer(sizeOrArray) {\n    /* istanbul ignore next */\n    return typeof sizeOrArray === \"number\"\n        ? util.Buffer\n            ? util._Buffer_allocUnsafe(sizeOrArray)\n            : new util.Array(sizeOrArray)\n        : util.Buffer\n            ? util._Buffer_from(sizeOrArray)\n            : typeof Uint8Array === \"undefined\"\n                ? sizeOrArray\n                : new Uint8Array(sizeOrArray);\n};\n\n/**\n * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.\n * @type {Constructor<Uint8Array>}\n */\nutil.Array = typeof Uint8Array !== \"undefined\" ? Uint8Array /* istanbul ignore next */ : Array;\n\n/**\n * Any compatible Long instance.\n * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.\n * @interface Long\n * @property {number} low Low bits\n * @property {number} high High bits\n * @property {boolean} unsigned Whether unsigned or not\n */\n\n/**\n * Long.js's Long class if available.\n * @type {Constructor<Long>}\n */\nutil.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long\n         || /* istanbul ignore next */ util.global.Long\n         || util.inquire(\"long\");\n\n/**\n * Regular expression used to verify 2 bit (`bool`) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key2Re = /^true|false|0|1$/;\n\n/**\n * Regular expression used to verify 32 bit (`int32` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key32Re = /^-?(?:0|[1-9][0-9]*)$/;\n\n/**\n * Regular expression used to verify 64 bit (`int64` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key64Re = /^(?:[\\\\x00-\\\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;\n\n/**\n * Converts a number or long to an 8 characters long hash string.\n * @param {Long|number} value Value to convert\n * @returns {string} Hash\n */\nutil.longToHash = function longToHash(value) {\n    return value\n        ? util.LongBits.from(value).toHash()\n        : util.LongBits.zeroHash;\n};\n\n/**\n * Converts an 8 characters long hash string to a long or number.\n * @param {string} hash Hash\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long|number} Original value\n */\nutil.longFromHash = function longFromHash(hash, unsigned) {\n    var bits = util.LongBits.fromHash(hash);\n    if (util.Long)\n        return util.Long.fromBits(bits.lo, bits.hi, unsigned);\n    return bits.toNumber(Boolean(unsigned));\n};\n\n/**\n * Merges the properties of the source object into the destination object.\n * @memberof util\n * @param {Object.<string,*>} dst Destination object\n * @param {Object.<string,*>} src Source object\n * @param {boolean} [ifNotSet=false] Merges only if the key is not already set\n * @returns {Object.<string,*>} Destination object\n */\nfunction merge(dst, src, ifNotSet) { // used by converters\n    for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)\n        if (dst[keys[i]] === undefined || !ifNotSet)\n            dst[keys[i]] = src[keys[i]];\n    return dst;\n}\n\nutil.merge = merge;\n\n/**\n * Converts the first character of a string to lower case.\n * @param {string} str String to convert\n * @returns {string} Converted string\n */\nutil.lcFirst = function lcFirst(str) {\n    return str.charAt(0).toLowerCase() + str.substring(1);\n};\n\n/**\n * Creates a custom error constructor.\n * @memberof util\n * @param {string} name Error name\n * @returns {Constructor<Error>} Custom error constructor\n */\nfunction newError(name) {\n\n    function CustomError(message, properties) {\n\n        if (!(this instanceof CustomError))\n            return new CustomError(message, properties);\n\n        // Error.call(this, message);\n        // ^ just returns a new error instance because the ctor can be called as a function\n\n        Object.defineProperty(this, \"message\", { get: function() { return message; } });\n\n        /* istanbul ignore next */\n        if (Error.captureStackTrace) // node\n            Error.captureStackTrace(this, CustomError);\n        else\n            Object.defineProperty(this, \"stack\", { value: new Error().stack || \"\" });\n\n        if (properties)\n            merge(this, properties);\n    }\n\n    CustomError.prototype = Object.create(Error.prototype, {\n        constructor: {\n            value: CustomError,\n            writable: true,\n            enumerable: false,\n            configurable: true,\n        },\n        name: {\n            get: function get() { return name; },\n            set: undefined,\n            enumerable: false,\n            // configurable: false would accurately preserve the behavior of\n            // the original, but I'm guessing that was not intentional.\n            // For an actual error subclass, this property would\n            // be configurable.\n            configurable: true,\n        },\n        toString: {\n            value: function value() { return this.name + \": \" + this.message; },\n            writable: true,\n            enumerable: false,\n            configurable: true,\n        },\n    });\n\n    return CustomError;\n}\n\nutil.newError = newError;\n\n/**\n * Constructs a new protocol error.\n * @classdesc Error subclass indicating a protocol specifc error.\n * @memberof util\n * @extends Error\n * @template T extends Message<T>\n * @constructor\n * @param {string} message Error message\n * @param {Object.<string,*>} [properties] Additional properties\n * @example\n * try {\n *     MyMessage.decode(someBuffer); // throws if required fields are missing\n * } catch (e) {\n *     if (e instanceof ProtocolError && e.instance)\n *         console.log(\"decoded so far: \" + JSON.stringify(e.instance));\n * }\n */\nutil.ProtocolError = newError(\"ProtocolError\");\n\n/**\n * So far decoded message instance.\n * @name util.ProtocolError#instance\n * @type {Message<T>}\n */\n\n/**\n * A OneOf getter as returned by {@link util.oneOfGetter}.\n * @typedef OneOfGetter\n * @type {function}\n * @returns {string|undefined} Set field name, if any\n */\n\n/**\n * Builds a getter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfGetter} Unbound getter\n */\nutil.oneOfGetter = function getOneOf(fieldNames) {\n    var fieldMap = {};\n    for (var i = 0; i < fieldNames.length; ++i)\n        fieldMap[fieldNames[i]] = 1;\n\n    /**\n     * @returns {string|undefined} Set field name, if any\n     * @this Object\n     * @ignore\n     */\n    return function() { // eslint-disable-line consistent-return\n        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)\n            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)\n                return keys[i];\n    };\n};\n\n/**\n * A OneOf setter as returned by {@link util.oneOfSetter}.\n * @typedef OneOfSetter\n * @type {function}\n * @param {string|undefined} value Field name\n * @returns {undefined}\n */\n\n/**\n * Builds a setter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfSetter} Unbound setter\n */\nutil.oneOfSetter = function setOneOf(fieldNames) {\n\n    /**\n     * @param {string} name Field name\n     * @returns {undefined}\n     * @this Object\n     * @ignore\n     */\n    return function(name) {\n        for (var i = 0; i < fieldNames.length; ++i)\n            if (fieldNames[i] !== name)\n                delete this[fieldNames[i]];\n    };\n};\n\n/**\n * Default conversion options used for {@link Message#toJSON} implementations.\n *\n * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:\n *\n * - Longs become strings\n * - Enums become string keys\n * - Bytes become base64 encoded strings\n * - (Sub-)Messages become plain objects\n * - Maps become plain objects with all string keys\n * - Repeated fields become arrays\n * - NaN and Infinity for float and double fields become strings\n *\n * @type {IConversionOptions}\n * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json\n */\nutil.toJSONOptions = {\n    longs: String,\n    enums: String,\n    bytes: String,\n    json: true\n};\n\n// Sets up buffer utility according to the environment (called in index-minimal)\nutil._configure = function() {\n    var Buffer = util.Buffer;\n    /* istanbul ignore if */\n    if (!Buffer) {\n        util._Buffer_from = util._Buffer_allocUnsafe = null;\n        return;\n    }\n    // because node 4.x buffers are incompatible & immutable\n    // see: https://github.com/dcodeIO/protobuf.js/pull/665\n    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||\n        /* istanbul ignore next */\n        function Buffer_from(value, encoding) {\n            return new Buffer(value, encoding);\n        };\n    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||\n        /* istanbul ignore next */\n        function Buffer_allocUnsafe(size) {\n            return new Buffer(size);\n        };\n};\n","\"use strict\";\nmodule.exports = Writer;\n\nvar util      = require(\"./util/minimal\");\n\nvar BufferWriter; // cyclic\n\nvar LongBits  = util.LongBits,\n    base64    = util.base64,\n    utf8      = util.utf8;\n\n/**\n * Constructs a new writer operation instance.\n * @classdesc Scheduled writer operation.\n * @constructor\n * @param {function(*, Uint8Array, number)} fn Function to call\n * @param {number} len Value byte length\n * @param {*} val Value to write\n * @ignore\n */\nfunction Op(fn, len, val) {\n\n    /**\n     * Function to call.\n     * @type {function(Uint8Array, number, *)}\n     */\n    this.fn = fn;\n\n    /**\n     * Value byte length.\n     * @type {number}\n     */\n    this.len = len;\n\n    /**\n     * Next operation.\n     * @type {Writer.Op|undefined}\n     */\n    this.next = undefined;\n\n    /**\n     * Value to write.\n     * @type {*}\n     */\n    this.val = val; // type varies\n}\n\n/* istanbul ignore next */\nfunction noop() {} // eslint-disable-line no-empty-function\n\n/**\n * Constructs a new writer state instance.\n * @classdesc Copied writer state.\n * @memberof Writer\n * @constructor\n * @param {Writer} writer Writer to copy state from\n * @ignore\n */\nfunction State(writer) {\n\n    /**\n     * Current head.\n     * @type {Writer.Op}\n     */\n    this.head = writer.head;\n\n    /**\n     * Current tail.\n     * @type {Writer.Op}\n     */\n    this.tail = writer.tail;\n\n    /**\n     * Current buffer length.\n     * @type {number}\n     */\n    this.len = writer.len;\n\n    /**\n     * Next state.\n     * @type {State|null}\n     */\n    this.next = writer.states;\n}\n\n/**\n * Constructs a new writer instance.\n * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.\n * @constructor\n */\nfunction Writer() {\n\n    /**\n     * Current length.\n     * @type {number}\n     */\n    this.len = 0;\n\n    /**\n     * Operations head.\n     * @type {Object}\n     */\n    this.head = new Op(noop, 0, 0);\n\n    /**\n     * Operations tail\n     * @type {Object}\n     */\n    this.tail = this.head;\n\n    /**\n     * Linked forked states.\n     * @type {Object|null}\n     */\n    this.states = null;\n\n    // When a value is written, the writer calculates its byte length and puts it into a linked\n    // list of operations to perform when finish() is called. This both allows us to allocate\n    // buffers of the exact required size and reduces the amount of work we have to do compared\n    // to first calculating over objects and then encoding over objects. In our case, the encoding\n    // part is just a linked list walk calling operations with already prepared values.\n}\n\nvar create = function create() {\n    return util.Buffer\n        ? function create_buffer_setup() {\n            return (Writer.create = function create_buffer() {\n                return new BufferWriter();\n            })();\n        }\n        /* istanbul ignore next */\n        : function create_array() {\n            return new Writer();\n        };\n};\n\n/**\n * Creates a new writer.\n * @function\n * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}\n */\nWriter.create = create();\n\n/**\n * Allocates a buffer of the specified size.\n * @param {number} size Buffer size\n * @returns {Uint8Array} Buffer\n */\nWriter.alloc = function alloc(size) {\n    return new util.Array(size);\n};\n\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\n/* istanbul ignore else */\nif (util.Array !== Array)\n    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);\n\n/**\n * Pushes a new operation to the queue.\n * @param {function(Uint8Array, number, *)} fn Function to call\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @returns {Writer} `this`\n * @private\n */\nWriter.prototype._push = function push(fn, len, val) {\n    this.tail = this.tail.next = new Op(fn, len, val);\n    this.len += len;\n    return this;\n};\n\nfunction writeByte(val, buf, pos) {\n    buf[pos] = val & 255;\n}\n\nfunction writeVarint32(val, buf, pos) {\n    while (val > 127) {\n        buf[pos++] = val & 127 | 128;\n        val >>>= 7;\n    }\n    buf[pos] = val;\n}\n\n/**\n * Constructs a new varint writer operation instance.\n * @classdesc Scheduled varint writer operation.\n * @extends Op\n * @constructor\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @ignore\n */\nfunction VarintOp(len, val) {\n    this.len = len;\n    this.next = undefined;\n    this.val = val;\n}\n\nVarintOp.prototype = Object.create(Op.prototype);\nVarintOp.prototype.fn = writeVarint32;\n\n/**\n * Writes an unsigned 32 bit value as a varint.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.uint32 = function write_uint32(value) {\n    // here, the call to this.push has been inlined and a varint specific Op subclass is used.\n    // uint32 is by far the most frequently used operation and benefits significantly from this.\n    this.len += (this.tail = this.tail.next = new VarintOp(\n        (value = value >>> 0)\n                < 128       ? 1\n        : value < 16384     ? 2\n        : value < 2097152   ? 3\n        : value < 268435456 ? 4\n        :                     5,\n    value)).len;\n    return this;\n};\n\n/**\n * Writes a signed 32 bit value as a varint.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.int32 = function write_int32(value) {\n    return value < 0\n        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec\n        : this.uint32(value);\n};\n\n/**\n * Writes a 32 bit value as a varint, zig-zag encoded.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sint32 = function write_sint32(value) {\n    return this.uint32((value << 1 ^ value >> 31) >>> 0);\n};\n\nfunction writeVarint64(val, buf, pos) {\n    while (val.hi) {\n        buf[pos++] = val.lo & 127 | 128;\n        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;\n        val.hi >>>= 7;\n    }\n    while (val.lo > 127) {\n        buf[pos++] = val.lo & 127 | 128;\n        val.lo = val.lo >>> 7;\n    }\n    buf[pos++] = val.lo;\n}\n\n/**\n * Writes an unsigned 64 bit value as a varint.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.uint64 = function write_uint64(value) {\n    var bits = LongBits.from(value);\n    return this._push(writeVarint64, bits.length(), bits);\n};\n\n/**\n * Writes a signed 64 bit value as a varint.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.int64 = Writer.prototype.uint64;\n\n/**\n * Writes a signed 64 bit value as a varint, zig-zag encoded.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sint64 = function write_sint64(value) {\n    var bits = LongBits.from(value).zzEncode();\n    return this._push(writeVarint64, bits.length(), bits);\n};\n\n/**\n * Writes a boolish value as a varint.\n * @param {boolean} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bool = function write_bool(value) {\n    return this._push(writeByte, 1, value ? 1 : 0);\n};\n\nfunction writeFixed32(val, buf, pos) {\n    buf[pos    ] =  val         & 255;\n    buf[pos + 1] =  val >>> 8   & 255;\n    buf[pos + 2] =  val >>> 16  & 255;\n    buf[pos + 3] =  val >>> 24;\n}\n\n/**\n * Writes an unsigned 32 bit value as fixed 32 bits.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.fixed32 = function write_fixed32(value) {\n    return this._push(writeFixed32, 4, value >>> 0);\n};\n\n/**\n * Writes a signed 32 bit value as fixed 32 bits.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sfixed32 = Writer.prototype.fixed32;\n\n/**\n * Writes an unsigned 64 bit value as fixed 64 bits.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.fixed64 = function write_fixed64(value) {\n    var bits = LongBits.from(value);\n    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);\n};\n\n/**\n * Writes a signed 64 bit value as fixed 64 bits.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sfixed64 = Writer.prototype.fixed64;\n\n/**\n * Writes a float (32 bit).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.float = function write_float(value) {\n    return this._push(util.float.writeFloatLE, 4, value);\n};\n\n/**\n * Writes a double (64 bit float).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.double = function write_double(value) {\n    return this._push(util.float.writeDoubleLE, 8, value);\n};\n\nvar writeBytes = util.Array.prototype.set\n    ? function writeBytes_set(val, buf, pos) {\n        buf.set(val, pos); // also works for plain array values\n    }\n    /* istanbul ignore next */\n    : function writeBytes_for(val, buf, pos) {\n        for (var i = 0; i < val.length; ++i)\n            buf[pos + i] = val[i];\n    };\n\n/**\n * Writes a sequence of bytes.\n * @param {Uint8Array|string} value Buffer or base64 encoded string to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bytes = function write_bytes(value) {\n    var len = value.length >>> 0;\n    if (!len)\n        return this._push(writeByte, 1, 0);\n    if (util.isString(value)) {\n        var buf = Writer.alloc(len = base64.length(value));\n        base64.decode(value, buf, 0);\n        value = buf;\n    }\n    return this.uint32(len)._push(writeBytes, len, value);\n};\n\n/**\n * Writes a string.\n * @param {string} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.string = function write_string(value) {\n    var len = utf8.length(value);\n    return len\n        ? this.uint32(len)._push(utf8.write, len, value)\n        : this._push(writeByte, 1, 0);\n};\n\n/**\n * Forks this writer's state by pushing it to a stack.\n * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.\n * @returns {Writer} `this`\n */\nWriter.prototype.fork = function fork() {\n    this.states = new State(this);\n    this.head = this.tail = new Op(noop, 0, 0);\n    this.len = 0;\n    return this;\n};\n\n/**\n * Resets this instance to the last state.\n * @returns {Writer} `this`\n */\nWriter.prototype.reset = function reset() {\n    if (this.states) {\n        this.head   = this.states.head;\n        this.tail   = this.states.tail;\n        this.len    = this.states.len;\n        this.states = this.states.next;\n    } else {\n        this.head = this.tail = new Op(noop, 0, 0);\n        this.len  = 0;\n    }\n    return this;\n};\n\n/**\n * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.\n * @returns {Writer} `this`\n */\nWriter.prototype.ldelim = function ldelim() {\n    var head = this.head,\n        tail = this.tail,\n        len  = this.len;\n    this.reset().uint32(len);\n    if (len) {\n        this.tail.next = head.next; // skip noop\n        this.tail = tail;\n        this.len += len;\n    }\n    return this;\n};\n\n/**\n * Finishes the write operation.\n * @returns {Uint8Array} Finished buffer\n */\nWriter.prototype.finish = function finish() {\n    var head = this.head.next, // skip noop\n        buf  = this.constructor.alloc(this.len),\n        pos  = 0;\n    while (head) {\n        head.fn(head.val, buf, pos);\n        pos += head.len;\n        head = head.next;\n    }\n    // this.head = this.tail = null;\n    return buf;\n};\n\nWriter._configure = function(BufferWriter_) {\n    BufferWriter = BufferWriter_;\n    Writer.create = create();\n    BufferWriter._configure();\n};\n","\"use strict\";\nmodule.exports = BufferWriter;\n\n// extends Writer\nvar Writer = require(\"./writer\");\n(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;\n\nvar util = require(\"./util/minimal\");\n\n/**\n * Constructs a new buffer writer instance.\n * @classdesc Wire format writer using node buffers.\n * @extends Writer\n * @constructor\n */\nfunction BufferWriter() {\n    Writer.call(this);\n}\n\nBufferWriter._configure = function () {\n    /**\n     * Allocates a buffer of the specified size.\n     * @function\n     * @param {number} size Buffer size\n     * @returns {Buffer} Buffer\n     */\n    BufferWriter.alloc = util._Buffer_allocUnsafe;\n\n    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === \"set\"\n        ? function writeBytesBuffer_set(val, buf, pos) {\n          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)\n          // also works for plain array values\n        }\n        /* istanbul ignore next */\n        : function writeBytesBuffer_copy(val, buf, pos) {\n          if (val.copy) // Buffer values\n            val.copy(buf, pos, 0, val.length);\n          else for (var i = 0; i < val.length;) // plain array values\n            buf[pos++] = val[i++];\n        };\n};\n\n\n/**\n * @override\n */\nBufferWriter.prototype.bytes = function write_bytes_buffer(value) {\n    if (util.isString(value))\n        value = util._Buffer_from(value, \"base64\");\n    var len = value.length >>> 0;\n    this.uint32(len);\n    if (len)\n        this._push(BufferWriter.writeBytesBuffer, len, value);\n    return this;\n};\n\nfunction writeStringBuffer(val, buf, pos) {\n    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)\n        util.utf8.write(val, buf, pos);\n    else if (buf.utf8Write)\n        buf.utf8Write(val, pos);\n    else\n        buf.write(val, pos);\n}\n\n/**\n * @override\n */\nBufferWriter.prototype.string = function write_string_buffer(value) {\n    var len = util.Buffer.byteLength(value);\n    this.uint32(len);\n    if (len)\n        this._push(writeStringBuffer, len, value);\n    return this;\n};\n\n\n/**\n * Finishes the write operation.\n * @name BufferWriter#finish\n * @function\n * @returns {Buffer} Finished buffer\n */\n\nBufferWriter._configure();\n","\"use strict\";\nmodule.exports = Reader;\n\nvar util      = require(\"./util/minimal\");\n\nvar BufferReader; // cyclic\n\nvar LongBits  = util.LongBits,\n    utf8      = util.utf8;\n\n/* istanbul ignore next */\nfunction indexOutOfRange(reader, writeLength) {\n    return RangeError(\"index out of range: \" + reader.pos + \" + \" + (writeLength || 1) + \" > \" + reader.len);\n}\n\n/**\n * Constructs a new reader instance using the specified buffer.\n * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.\n * @constructor\n * @param {Uint8Array} buffer Buffer to read from\n */\nfunction Reader(buffer) {\n\n    /**\n     * Read buffer.\n     * @type {Uint8Array}\n     */\n    this.buf = buffer;\n\n    /**\n     * Read buffer position.\n     * @type {number}\n     */\n    this.pos = 0;\n\n    /**\n     * Read buffer length.\n     * @type {number}\n     */\n    this.len = buffer.length;\n}\n\nvar create_array = typeof Uint8Array !== \"undefined\"\n    ? function create_typed_array(buffer) {\n        if (buffer instanceof Uint8Array || Array.isArray(buffer))\n            return new Reader(buffer);\n        throw Error(\"illegal buffer\");\n    }\n    /* istanbul ignore next */\n    : function create_array(buffer) {\n        if (Array.isArray(buffer))\n            return new Reader(buffer);\n        throw Error(\"illegal buffer\");\n    };\n\nvar create = function create() {\n    return util.Buffer\n        ? function create_buffer_setup(buffer) {\n            return (Reader.create = function create_buffer(buffer) {\n                return util.Buffer.isBuffer(buffer)\n                    ? new BufferReader(buffer)\n                    /* istanbul ignore next */\n                    : create_array(buffer);\n            })(buffer);\n        }\n        /* istanbul ignore next */\n        : create_array;\n};\n\n/**\n * Creates a new reader using the specified buffer.\n * @function\n * @param {Uint8Array|Buffer} buffer Buffer to read from\n * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}\n * @throws {Error} If `buffer` is not a valid buffer\n */\nReader.create = create();\n\nReader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;\n\n/**\n * Reads a varint as an unsigned 32 bit value.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.uint32 = (function read_uint32_setup() {\n    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)\n    return function read_uint32() {\n        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;\n\n        /* istanbul ignore if */\n        if ((this.pos += 5) > this.len) {\n            this.pos = this.len;\n            throw indexOutOfRange(this, 10);\n        }\n        return value;\n    };\n})();\n\n/**\n * Reads a varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.int32 = function read_int32() {\n    return this.uint32() | 0;\n};\n\n/**\n * Reads a zig-zag encoded varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.sint32 = function read_sint32() {\n    var value = this.uint32();\n    return value >>> 1 ^ -(value & 1) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readLongVarint() {\n    // tends to deopt with local vars for octet etc.\n    var bits = new LongBits(0, 0);\n    var i = 0;\n    if (this.len - this.pos > 4) { // fast route (lo)\n        for (; i < 4; ++i) {\n            // 1st..4th\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n        // 5th\n        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;\n        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;\n        if (this.buf[this.pos++] < 128)\n            return bits;\n        i = 0;\n    } else {\n        for (; i < 3; ++i) {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            // 1st..3th\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n        // 4th\n        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;\n        return bits;\n    }\n    if (this.len - this.pos > 4) { // fast route (hi)\n        for (; i < 5; ++i) {\n            // 6th..10th\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n    } else {\n        for (; i < 5; ++i) {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            // 6th..10th\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n    }\n    /* istanbul ignore next */\n    throw Error(\"invalid varint encoding\");\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads a varint as a signed 64 bit value.\n * @name Reader#int64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as an unsigned 64 bit value.\n * @name Reader#uint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a zig-zag encoded varint as a signed 64 bit value.\n * @name Reader#sint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as a boolean.\n * @returns {boolean} Value read\n */\nReader.prototype.bool = function read_bool() {\n    return this.uint32() !== 0;\n};\n\nfunction readFixed32_end(buf, end) { // note that this uses `end`, not `pos`\n    return (buf[end - 4]\n          | buf[end - 3] << 8\n          | buf[end - 2] << 16\n          | buf[end - 1] << 24) >>> 0;\n}\n\n/**\n * Reads fixed 32 bits as an unsigned 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.fixed32 = function read_fixed32() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    return readFixed32_end(this.buf, this.pos += 4);\n};\n\n/**\n * Reads fixed 32 bits as a signed 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.sfixed32 = function read_sfixed32() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    return readFixed32_end(this.buf, this.pos += 4) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readFixed64(/* this: Reader */) {\n\n    /* istanbul ignore if */\n    if (this.pos + 8 > this.len)\n        throw indexOutOfRange(this, 8);\n\n    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads fixed 64 bits.\n * @name Reader#fixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads zig-zag encoded fixed 64 bits.\n * @name Reader#sfixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a float (32 bit) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.float = function read_float() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    var value = util.float.readFloatLE(this.buf, this.pos);\n    this.pos += 4;\n    return value;\n};\n\n/**\n * Reads a double (64 bit float) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.double = function read_double() {\n\n    /* istanbul ignore if */\n    if (this.pos + 8 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    var value = util.float.readDoubleLE(this.buf, this.pos);\n    this.pos += 8;\n    return value;\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @returns {Uint8Array} Value read\n */\nReader.prototype.bytes = function read_bytes() {\n    var length = this.uint32(),\n        start  = this.pos,\n        end    = this.pos + length;\n\n    /* istanbul ignore if */\n    if (end > this.len)\n        throw indexOutOfRange(this, length);\n\n    this.pos += length;\n    if (Array.isArray(this.buf)) // plain array\n        return this.buf.slice(start, end);\n\n    if (start === end) { // fix for IE 10/Win8 and others' subarray returning array of size 1\n        var nativeBuffer = util.Buffer;\n        return nativeBuffer\n            ? nativeBuffer.alloc(0)\n            : new this.buf.constructor(0);\n    }\n    return this._slice.call(this.buf, start, end);\n};\n\n/**\n * Reads a string preceeded by its byte length as a varint.\n * @returns {string} Value read\n */\nReader.prototype.string = function read_string() {\n    var bytes = this.bytes();\n    return utf8.read(bytes, 0, bytes.length);\n};\n\n/**\n * Skips the specified number of bytes if specified, otherwise skips a varint.\n * @param {number} [length] Length if known, otherwise a varint is assumed\n * @returns {Reader} `this`\n */\nReader.prototype.skip = function skip(length) {\n    if (typeof length === \"number\") {\n        /* istanbul ignore if */\n        if (this.pos + length > this.len)\n            throw indexOutOfRange(this, length);\n        this.pos += length;\n    } else {\n        do {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n        } while (this.buf[this.pos++] & 128);\n    }\n    return this;\n};\n\n/**\n * Skips the next element of the specified wire type.\n * @param {number} wireType Wire type received\n * @returns {Reader} `this`\n */\nReader.prototype.skipType = function(wireType) {\n    switch (wireType) {\n        case 0:\n            this.skip();\n            break;\n        case 1:\n            this.skip(8);\n            break;\n        case 2:\n            this.skip(this.uint32());\n            break;\n        case 3:\n            while ((wireType = this.uint32() & 7) !== 4) {\n                this.skipType(wireType);\n            }\n            break;\n        case 5:\n            this.skip(4);\n            break;\n\n        /* istanbul ignore next */\n        default:\n            throw Error(\"invalid wire type \" + wireType + \" at offset \" + this.pos);\n    }\n    return this;\n};\n\nReader._configure = function(BufferReader_) {\n    BufferReader = BufferReader_;\n    Reader.create = create();\n    BufferReader._configure();\n\n    var fn = util.Long ? \"toLong\" : /* istanbul ignore next */ \"toNumber\";\n    util.merge(Reader.prototype, {\n\n        int64: function read_int64() {\n            return readLongVarint.call(this)[fn](false);\n        },\n\n        uint64: function read_uint64() {\n            return readLongVarint.call(this)[fn](true);\n        },\n\n        sint64: function read_sint64() {\n            return readLongVarint.call(this).zzDecode()[fn](false);\n        },\n\n        fixed64: function read_fixed64() {\n            return readFixed64.call(this)[fn](true);\n        },\n\n        sfixed64: function read_sfixed64() {\n            return readFixed64.call(this)[fn](false);\n        }\n\n    });\n};\n","\"use strict\";\nmodule.exports = BufferReader;\n\n// extends Reader\nvar Reader = require(\"./reader\");\n(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;\n\nvar util = require(\"./util/minimal\");\n\n/**\n * Constructs a new buffer reader instance.\n * @classdesc Wire format reader using node buffers.\n * @extends Reader\n * @constructor\n * @param {Buffer} buffer Buffer to read from\n */\nfunction BufferReader(buffer) {\n    Reader.call(this, buffer);\n\n    /**\n     * Read buffer.\n     * @name BufferReader#buf\n     * @type {Buffer}\n     */\n}\n\nBufferReader._configure = function () {\n    /* istanbul ignore else */\n    if (util.Buffer)\n        BufferReader.prototype._slice = util.Buffer.prototype.slice;\n};\n\n\n/**\n * @override\n */\nBufferReader.prototype.string = function read_string_buffer() {\n    var len = this.uint32(); // modifies pos\n    return this.buf.utf8Slice\n        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))\n        : this.buf.toString(\"utf-8\", this.pos, this.pos = Math.min(this.pos + len, this.len));\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @name BufferReader#bytes\n * @function\n * @returns {Buffer} Value read\n */\n\nBufferReader._configure();\n","\"use strict\";\nmodule.exports = Service;\n\nvar util = require(\"../util/minimal\");\n\n// Extends EventEmitter\n(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;\n\n/**\n * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.\n *\n * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.\n * @typedef rpc.ServiceMethodCallback\n * @template TRes extends Message<TRes>\n * @type {function}\n * @param {Error|null} error Error, if any\n * @param {TRes} [response] Response message\n * @returns {undefined}\n */\n\n/**\n * A service method part of a {@link rpc.Service} as created by {@link Service.create}.\n * @typedef rpc.ServiceMethod\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n * @type {function}\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message\n * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`\n */\n\n/**\n * Constructs a new RPC service instance.\n * @classdesc An RPC service as returned by {@link Service#create}.\n * @exports rpc.Service\n * @extends util.EventEmitter\n * @constructor\n * @param {RPCImpl} rpcImpl RPC implementation\n * @param {boolean} [requestDelimited=false] Whether requests are length-delimited\n * @param {boolean} [responseDelimited=false] Whether responses are length-delimited\n */\nfunction Service(rpcImpl, requestDelimited, responseDelimited) {\n\n    if (typeof rpcImpl !== \"function\")\n        throw TypeError(\"rpcImpl must be a function\");\n\n    util.EventEmitter.call(this);\n\n    /**\n     * RPC implementation. Becomes `null` once the service is ended.\n     * @type {RPCImpl|null}\n     */\n    this.rpcImpl = rpcImpl;\n\n    /**\n     * Whether requests are length-delimited.\n     * @type {boolean}\n     */\n    this.requestDelimited = Boolean(requestDelimited);\n\n    /**\n     * Whether responses are length-delimited.\n     * @type {boolean}\n     */\n    this.responseDelimited = Boolean(responseDelimited);\n}\n\n/**\n * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.\n * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method\n * @param {Constructor<TReq>} requestCtor Request constructor\n * @param {Constructor<TRes>} responseCtor Response constructor\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback\n * @returns {undefined}\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n */\nService.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {\n\n    if (!request)\n        throw TypeError(\"request must be specified\");\n\n    var self = this;\n    if (!callback)\n        return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);\n\n    if (!self.rpcImpl) {\n        setTimeout(function() { callback(Error(\"already ended\")); }, 0);\n        return undefined;\n    }\n\n    try {\n        return self.rpcImpl(\n            method,\n            requestCtor[self.requestDelimited ? \"encodeDelimited\" : \"encode\"](request).finish(),\n            function rpcCallback(err, response) {\n\n                if (err) {\n                    self.emit(\"error\", err, method);\n                    return callback(err);\n                }\n\n                if (response === null) {\n                    self.end(/* endedByRPC */ true);\n                    return undefined;\n                }\n\n                if (!(response instanceof responseCtor)) {\n                    try {\n                        response = responseCtor[self.responseDelimited ? \"decodeDelimited\" : \"decode\"](response);\n                    } catch (err) {\n                        self.emit(\"error\", err, method);\n                        return callback(err);\n                    }\n                }\n\n                self.emit(\"data\", response, method);\n                return callback(null, response);\n            }\n        );\n    } catch (err) {\n        self.emit(\"error\", err, method);\n        setTimeout(function() { callback(err); }, 0);\n        return undefined;\n    }\n};\n\n/**\n * Ends this service and emits the `end` event.\n * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.\n * @returns {rpc.Service} `this`\n */\nService.prototype.end = function end(endedByRPC) {\n    if (this.rpcImpl) {\n        if (!endedByRPC) // signal end to rpcImpl\n            this.rpcImpl(null, null, null);\n        this.rpcImpl = null;\n        this.emit(\"end\").off();\n    }\n    return this;\n};\n","\"use strict\";\n\n/**\n * Streaming RPC helpers.\n * @namespace\n */\nvar rpc = exports;\n\n/**\n * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.\n * @typedef RPCImpl\n * @type {function}\n * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called\n * @param {Uint8Array} requestData Request data\n * @param {RPCImplCallback} callback Callback function\n * @returns {undefined}\n * @example\n * function rpcImpl(method, requestData, callback) {\n *     if (protobuf.util.lcFirst(method.name) !== \"myMethod\") // compatible with static code\n *         throw Error(\"no such method\");\n *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {\n *         callback(err, responseData);\n *     });\n * }\n */\n\n/**\n * Node-style callback as used by {@link RPCImpl}.\n * @typedef RPCImplCallback\n * @type {function}\n * @param {Error|null} error Error, if any, otherwise `null`\n * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error\n * @returns {undefined}\n */\n\nrpc.Service = require(\"./rpc/service\");\n","\"use strict\";\nmodule.exports = {};\n\n/**\n * Named roots.\n * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).\n * Can also be used manually to make roots available across modules.\n * @name roots\n * @type {Object.<string,Root>}\n * @example\n * // pbjs -r myroot -o compiled.js ...\n *\n * // in another module:\n * require(\"./compiled.js\");\n *\n * // in any subsequent module:\n * var root = protobuf.roots[\"myroot\"];\n */\n","\"use strict\";\nvar protobuf = exports;\n\n/**\n * Build type, one of `\"full\"`, `\"light\"` or `\"minimal\"`.\n * @name build\n * @type {string}\n * @const\n */\nprotobuf.build = \"minimal\";\n\n// Serialization\nprotobuf.Writer       = require(\"./writer\");\nprotobuf.BufferWriter = require(\"./writer_buffer\");\nprotobuf.Reader       = require(\"./reader\");\nprotobuf.BufferReader = require(\"./reader_buffer\");\n\n// Utility\nprotobuf.util         = require(\"./util/minimal\");\nprotobuf.rpc          = require(\"./rpc\");\nprotobuf.roots        = require(\"./roots\");\nprotobuf.configure    = configure;\n\n/* istanbul ignore next */\n/**\n * Reconfigures the library according to the environment.\n * @returns {undefined}\n */\nfunction configure() {\n    protobuf.util._configure();\n    protobuf.Writer._configure(protobuf.BufferWriter);\n    protobuf.Reader._configure(protobuf.BufferReader);\n}\n\n// Set up buffer utility according to the environment\nconfigure();\n","// minimal library entry point.\n\n\"use strict\";\nmodule.exports = require(\"./src/index-minimal\");\n"],"names":["longbits","LongBits","util","require$$0","lo","hi","zero","zeroHash","value","sign","unsigned","charCodeAt","hash","mask","part0","part1","part2","exports","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","global","this","obj","prop","Buffer","sizeOrArray","bits","merge","dst","src","ifNotSet","keys","i","str","newError","name","CustomError","message","properties","fieldNames","fieldMap","encoding","size","writer","Writer","BufferWriter","base64","utf8","Op","fn","len","val","noop","State","create","writeByte","buf","pos","writeVarint32","VarintOp","writeVarint64","writeFixed32","writeBytes","head","tail","BufferWriter_","writer_buffer","writeStringBuffer","reader","Reader","BufferReader","indexOutOfRange","writeLength","buffer","create_array","readLongVarint","readFixed32_end","end","readFixed64","length","start","nativeBuffer","bytes","wireType","BufferReader_","reader_buffer","service","Service","rpcImpl","requestDelimited","responseDelimited","rpcCall","method","requestCtor","responseCtor","request","callback","self","err","response","endedByRPC","rpc","roots","protobuf","configure","minimal"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10]}