npm - @openclaw/diagnostics-otel - Versions diffs - 2026.7.2-beta.7 → 2026.7.34 - Mend

@openclaw/diagnostics-otel 2026.7.2-beta.7 → 2026.7.34

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3739) hide show

package/node_modules/@opentelemetry/sdk-node/node_modules/protobufjs/dist/minimal/protobuf.min.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["lib/prelude.js","../src/index-minimal","../src/reader.js","../src/reader_buffer.js","../src/roots.js","../src/rpc.js","../src/rpc/service.js","../src/util/aspromise.js","../src/util/base64.js","../src/util/eventemitter.js","../src/util/float.js","../src/util/longbits.js","../src/util/minimal.js","../src/util/pool.js","../src/util/utf8.js","../src/writer.js","../src/writer_buffer.js"],"names":["undefined","modules","cache","protobuf","1","require","module","exports","configure","util","LongBits","_configure","Long","Writer","BufferWriter","Reader","BufferReader","build","rpc","roots","utf8","indexOutOfRange","reader","writeLength","RangeError","pos","len","buffer","this","buf","length","view","discardUnknown","create_array","Array","isArray","Uint8Array","Error","create","Buffer","isBuffer","readLongVarint","bits","i","lo","hi","readFixed32_end","end","readFixed64","prototype","raw","start","subarray","uint32","value","tag","int32","sint32","bool","b","fixed32","sfixed32","float","readFloatLE","double","readDoubleLE","uint32s","array","push","int32s","sint32s","bools","getLazyView","count","threshold","DataView","byteOffset","byteLength","fixed32s","dv","k","getUint32","j","sfixed32s","getInt32","floats","getFloat32","doubles","getFloat64","uint64s","uint64","int64s","int64","sint64s","sint64","fixed64s","fixed64","sfixed64s","sfixed64","bytes","string","read","stringVerify","readStrict","skip","recursionLimit","skipType","wireType","depth","fieldNumber","nestedField","BufferReader_","fn","merge","call","zzDecode","Object","constructor","writable","enumerable","configurable","_slice","slice","utf8Slice","toString","Service","rpcImpl","requestDelimited","responseDelimited","TypeError","EventEmitter","Boolean","rpcCall","method","requestCtor","responseCtor","request","callback","self","asPromise","setTimeout","finish","err","response","emit","endedByRPC","off","ctx","params","arguments","offset","index","pending","Promise","resolve","reject","apply","base64","p","Math","floor","b64","s64","encode","t","parts","chunk","String","fromCharCode","join","invalidEncoding","base64Re","decode","c","charCodeAt","base64UrlRe","base64UrlNoPaddingRe","test","_listeners","on","evt","listeners","splice","args","factory","writeFloat_ieee754","writeUint","val","sign","isNaN","round","exponent","log","LN2","pow","readFloat_ieee754","readUint","uint","mantissa","NaN","Infinity","writeFloat_f32_cpy","f32","f8b","writeFloat_f32_rev","readFloat_f32_cpy","readFloat_f32_rev","f64","le","writeDouble_ieee754","off0","off1","readDouble_ieee754","writeDouble_f64_cpy","writeDouble_f64_rev","readDouble_f64_cpy","readDouble_f64_rev","Float32Array","writeFloatLE","writeFloatBE","readFloatBE","bind","writeUintLE","writeUintBE","readUintLE","readUintBE","Float64Array","writeDoubleLE","writeDoubleBE","readDoubleBE","zero","toNumber","zzEncode","zeroHash","fromNumber","from","parseInt","fromString","low","high","unsigned","toLong","fromHash","hash","toHash","mask","part0","part1","part2","Long_","isUnsafeProperty","key","dst","limit","ifNotSet","a","src","keys","hasOwnProperty","newError","name","CustomError","message","properties","defineProperty","get","captureStackTrace","stack","set","pool","isNode","global","process","versions","node","window","globalThis","emptyArray","freeze","emptyObject","isInteger","Number","isFinite","isString","isObject","isset","isSet","obj","prop","utf8Write","e","newBuffer","sizeOrArray","allocUnsafe","rawField","id","data","out","dcodeIO","isLong","key2Re","key32Re","key64Re","longToHash","longFromHash","fromBits","longFromKey","boolFromKey","nestingLimit","makeProp","lcFirst","str","toLowerCase","substring","ProtocolError","oneOfGetter","fieldNames","fieldMap","oneOfSetter","toJSONOptions","longs","enums","json","alloc","size","SIZE","MAX","slab","strictDecoder","looseDecoder","TextDecoder","ignoreBOM","fatal","utf8_read_js","c3","c2","t2","utf8_read_decoder","decoder","source","c1","c4","c5","c6","c7","c8","write","states","sizeVarint32","writeVarint32","writeVarint64","writeFixed32","_reserve","n","need","_delim","copyWithin","lenPos","writeStringAscii","writer","setUint32","setFloat32","setFloat64","fork","reset","pop","ldelim","vlen","shared","finishInto","BufferWriter_","writeStringBuffer","$require","$module","define","amd"],"mappings":"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","file":"protobuf.min.js","sourcesContent":["(function prelude(modules, cache, entries) {\n\n // This is the prelude used to bundle protobuf.js for the browser. Wraps up the CommonJS\n // sources through a conflict-free require shim and is again wrapped within an iife that\n // provides a minification-friendly `undefined` var plus a global \"use strict\" directive\n // so that minification can remove the directives of each module.\n\n function $require(name) {\n var $module = cache[name];\n if (!$module)\n modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);\n return $module.exports;\n }\n\n var protobuf = $require(entries[0]);\n\n // Expose globally\n protobuf.util.global.protobuf = protobuf;\n\n // Be nice to AMD\n if (typeof define === \"function\" && define.amd)\n define([\"long\"], function(Long) {\n if (Long && Long.isLong) {\n protobuf.util.Long = Long;\n protobuf.configure();\n }\n return protobuf;\n });\n\n // Be nice to CommonJS\n if (typeof module === \"object\" && module && module.exports)\n module.exports = protobuf;\n\n})/* end of prelude /","\"use strict\";\n\n/\n Build type, one of `\"full\"`, `\"light\"` or `\"minimal\"`.\n * @name build\n * @type {string}\n * @const\n /\nexports.build = \"minimal\";\n\n// Serialization\nexports.Writer = require(15);\nexports.BufferWriter = require(16);\nexports.Reader = require(2);\nexports.BufferReader = require(3);\n\n// Utility\nexports.util = require(12);\nexports.rpc = require(5);\nexports.roots = require(4);\nexports.configure = configure;\n\n/ istanbul ignore next /\n/\n Reconfigures the library according to the environment.\n * @returns {undefined}\n /\nfunction configure() {\n exports.util.LongBits._configure(exports.util.Long);\n exports.Writer._configure(exports.BufferWriter);\n exports.Reader._configure(exports.BufferReader);\n}\n\n// Set up buffer utility according to the environment\nconfigure();\n","\"use strict\";\nmodule.exports = Reader;\n\nvar util = require(12);\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`.\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 /\n Cached DataView for packed reads.\n * @type {DataView\|null}\n /\n this.view = null;\n\n /\n Whether to discard unknown fields while decoding.\n * @type {boolean}\n /\n this.discardUnknown = Reader.discardUnknown;\n}\n\nfunction create_array(buffer) {\n // TODO: Remove plain array reader support in the next major release.\n if (Array.isArray(buffer))\n buffer = new Uint8Array(buffer);\n if (buffer instanceof Uint8Array)\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\n/\n Returns raw bytes from the backing buffer without advancing the reader.\n * @param {number} start Start offset\n * @param {number} end End offset\n * @returns {Uint8Array} Raw bytes\n /\nReader.prototype.raw = function read_raw(start, end) {\n return this.buf.subarray(start, end);\n};\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() {\n var buf = this.buf,\n pos = this.pos,\n value = (buf[pos] & 127) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 127) << 7) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 127) << 14) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 127) << 21) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 15) << 28) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n\n for (var i = 0; i < 5; ++i) {\n / istanbul ignore if /\n if (pos >= this.len) {\n this.pos = pos;\n throw indexOutOfRange(this);\n }\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n }\n / istanbul ignore next /\n this.pos = pos;\n throw Error(\"invalid varint encoding\");\n};\n\n/\n Reads a field tag.\n * @function\n * @returns {number} Tag read\n /\nReader.prototype.tag = function read_tag() {\n var buf = this.buf,\n pos = this.pos,\n value = (buf[pos] & 127) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 127) << 7) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 127) << 14) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 127) << 21) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value \| (buf[pos] & 15) << 28) >>> 0;\n if (buf[pos] < 128 && (buf[pos] & 112) === 0) {\n this.pos = pos + 1;\n return value;\n }\n\n this.pos = pos + 1;\n throw Error(\"invalid tag encoding\");\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 < 4; ++i) {\n /* istanbul ignore if /\n if (this.pos >= this.len)\n throw indexOutOfRange(this);\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 throw indexOutOfRange(this);\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 var value = false,\n b;\n for (var i = 0; i < 10; ++i) {\n / istanbul ignore if /\n if (this.pos >= this.len)\n throw indexOutOfRange(this);\n b = this.buf[this.pos++];\n if (b & 127)\n value = true;\n if (b < 128)\n return value;\n }\n / istanbul ignore next /\n throw Error(\"invalid varint encoding\");\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 packed repeated field of unsigned 32 bit varints.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n /\nReader.prototype.uint32s = function read_uint32s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.uint32());\n return array;\n};\n\n/\n Reads a packed repeated field of signed 32 bit varints.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n /\nReader.prototype.int32s = function read_int32s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.int32());\n return array;\n};\n\n/\n Reads a packed repeated field of zig-zag encoded signed 32 bit varints.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n /\nReader.prototype.sint32s = function read_sint32s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.sint32());\n return array;\n};\n\n/\n Reads a packed repeated field of booleans.\n * @param {boolean[]} [array] Array to read into; a new one is created if omitted\n * @returns {boolean[]} Array read into\n /\nReader.prototype.bools = function read_bools(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.bool());\n return array;\n};\n\n// The view allocation only pays off when amortized over enough reads\nvar VIEW_THRESHOLD_FLOAT = 8,\n VIEW_THRESHOLD_INT = 128;\n\nfunction getLazyView(reader, count, threshold) {\n var view = reader.view;\n if (view \|\| count < threshold)\n return view;\n var buf = reader.buf;\n return reader.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n}\n\n/\n Reads a packed repeated field of unsigned 32 bit fixed values.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n /\nReader.prototype.fixed32s = function read_fixed32s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n / istanbul ignore if /\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 2, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getUint32(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4);\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 4);\n return array;\n};\n\n/\n Reads a packed repeated field of signed 32 bit fixed values.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n /\nReader.prototype.sfixed32s = function read_sfixed32s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n / istanbul ignore if /\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 2, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getInt32(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4) \| 0;\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 4);\n return array;\n};\n\n/\n Reads a packed repeated field of floats (32 bit).\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n /\nReader.prototype.floats = function read_floats(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n / istanbul ignore if /\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 2, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getFloat32(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 4) array[i++] = util.float.readFloatLE(buf, pos);\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 4);\n return array;\n};\n\n/\n Reads a packed repeated field of doubles (64 bit float).\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n /\nReader.prototype.doubles = function read_doubles(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n / istanbul ignore if /\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 3, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 8) array[i++] = dv.getFloat64(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 8) array[i++] = util.float.readDoubleLE(buf, pos);\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 8);\n return array;\n};\n\n/\n Reads a packed repeated field of unsigned 64 bit varints.\n * @param {Array.<Long\|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long\|number>} Array read into\n /\nReader.prototype.uint64s = function read_uint64s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.uint64());\n return array;\n};\n\n/\n Reads a packed repeated field of signed 64 bit varints.\n * @param {Array.<Long\|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long\|number>} Array read into\n /\nReader.prototype.int64s = function read_int64s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.int64());\n return array;\n};\n\n/\n Reads a packed repeated field of zig-zag encoded signed 64 bit varints.\n * @param {Array.<Long\|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long\|number>} Array read into\n /\nReader.prototype.sint64s = function read_sint64s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.sint64());\n return array;\n};\n\n/\n Reads a packed repeated field of unsigned 64 bit fixed values.\n * @param {Array.<Long\|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long\|number>} Array read into\n /\nReader.prototype.fixed64s = function read_fixed64s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len, i = array.length;\n / istanbul ignore if /\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 3;\n array.length = i + count; // 8 bytes per value, count is known\n for (var j = 0; j < count; ++j)\n array[i++] = this.fixed64();\n if (this.pos !== end) throw indexOutOfRange(this, 8);\n return array;\n};\n\n/\n Reads a packed repeated field of signed 64 bit fixed values.\n * @param {Array.<Long\|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long\|number>} Array read into\n /\nReader.prototype.sfixed64s = function read_sfixed64s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len, i = array.length;\n / istanbul ignore if /\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 3;\n array.length = i + count; // 8 bytes per value, count is known\n for (var j = 0; j < count; ++j)\n array[i++] = this.sfixed64();\n if (this.pos !== end) throw indexOutOfRange(this, 8);\n return array;\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 = end;\n return this.raw(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 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 = end;\n return utf8.read(this.buf, start, end);\n};\n\n/\n Reads a string preceeded by its byte length as a varint, rejecting invalid UTF8.\n * @returns {string} Value read\n /\nReader.prototype.stringVerify = function read_string_verify() {\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 = end;\n return utf8.readStrict(this.buf, start, end);\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 Recursion limit.\n * @type {number}\n /\nReader.recursionLimit = util.recursionLimit;\n\n/\n Whether readers discard unknown fields while decoding.\n * @type {boolean}\n /\nReader.discardUnknown = true;\n\n/\n Skips the next element of the specified wire type.\n * @param {number} wireType Wire type received\n * @param {number} [depth] Depth of recursion to control nested calls; 0 if omitted\n * @param {number} [fieldNumber] Field number for validating group end tags\n * @returns {Reader} `this`\n /\nReader.prototype.skipType = function(wireType, depth, fieldNumber) {\n if (depth === undefined) depth = 0;\n if (depth > Reader.recursionLimit)\n throw Error(\"max depth exceeded\");\n if (fieldNumber === 0)\n throw Error(\"illegal tag: field number 0\");\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 (true) {\n var tag = this.tag();\n var nestedField = tag >>> 3;\n wireType = tag & 7;\n if (!nestedField)\n throw Error(\"illegal tag: field number 0\");\n if (wireType === 4) {\n if (fieldNumber !== undefined && nestedField !== fieldNumber)\n throw Error(\"invalid end group tag\");\n break;\n }\n this.skipType(wireType, depth + 1, nestedField);\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(2);\nBufferReader.prototype = Object.create(Reader.prototype, {\n constructor: {\n value: BufferReader,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\n\nvar util = require(12);\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 Returns raw bytes from the backing buffer without advancing the reader.\n * @name BufferReader#raw\n * @function\n * @param {number} start Start offset\n * @param {number} end End offset\n * @returns {Buffer} Raw bytes\n /\nBufferReader.prototype.raw = function read_raw_buffer(start, end) {\n return this._slice.call(this.buf, start, end);\n};\n\n/\n @override\n /\nBufferReader.prototype.string = function read_string_buffer() {\n var len = this.uint32(), // modifies pos\n start = this.pos,\n end = this.pos + len;\n\n / istanbul ignore if /\n if (end > this.len)\n throw RangeError(\"index out of range: \" + this.pos + \" + \" + len + \" > \" + this.len);\n\n this.pos = end;\n return this.buf.utf8Slice\n ? this.buf.utf8Slice(start, end)\n : this.buf.toString(\"utf-8\", start, end);\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 = Object.create(null);\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\";\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(6);\n","\"use strict\";\nmodule.exports = Service;\n\nvar util = require(12);\n\n// Extends EventEmitter\nService.prototype = Object.create(util.EventEmitter.prototype, {\n constructor: {\n value: Service,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\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 {{\n * (request: TReq\|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;\n * (request: TReq\|Properties<TReq>): Promise<TRes>;\n * readonly name: string;\n * readonly path: string;\n * readonly requestType: string;\n * readonly responseType: string;\n * readonly requestStream: true\|undefined;\n * readonly responseStream: true\|undefined;\n * }}\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\";\nmodule.exports = asPromise;\n\n/\n Callback as used by {@link util.asPromise}.\n * @typedef asPromiseCallback\n * @type {function}\n * @param {Error\|null} error Error, if any\n * @param {...} params Additional arguments\n @returns {undefined}\n /\n\n/\n Returns a promise from a node-style callback function.\n * @memberof util\n * @param {asPromiseCallback} fn Function to call\n * @param {} ctx Function context\n @param {...} params Function arguments\n @returns {Promise<>} Promisified function\n /\nfunction asPromise(fn, ctx/, varargs /) {\n var params = new Array(arguments.length - 1),\n offset = 0,\n index = 2,\n pending = true;\n while (index < arguments.length)\n params[offset++] = arguments[index++];\n return new Promise(function executor(resolve, reject) {\n params[offset] = function callback(err/, varargs /) {\n if (pending) {\n pending = false;\n if (err)\n reject(err);\n else {\n var params = new Array(arguments.length - 1),\n offset = 0;\n while (offset < params.length)\n params[offset++] = arguments[offset];\n resolve.apply(null, params);\n }\n }\n };\n try {\n fn.apply(ctx \|\| null, params);\n } catch (err) {\n if (pending) {\n pending = false;\n reject(err);\n }\n }\n });\n}\n","\"use strict\";\n\n/*\n A minimal base64 implementation for number arrays.\n * @memberof util\n * @namespace\n /\nvar base64 = exports;\n\n/\n Calculates the byte length of a base64 encoded string.\n * @param {string} string Base64 encoded string\n * @returns {number} Byte length\n /\nbase64.length = function length(string) {\n var p = string.length;\n if (!p)\n return 0;\n while (p > 0 && string.charAt(p - 1) === \"=\")\n --p;\n return Math.floor(p 3 / 4);\n};\n\n// Base64 encoding table\nvar b64 = new Array(64);\n\n// Base64 decoding table\nvar s64 = new Array(123);\n\n// 65..90, 97..122, 48..57, 43, 47\nfor (var i = 0; i < 64;)\n s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 \| 43] = i++;\n\ns64[45] = 62; // - -> +\ns64[95] = 63; // _ -> /\n\n/*\n Encodes a buffer to a base64 encoded string.\n * @param {Uint8Array} buffer Source buffer\n * @param {number} start Source start\n * @param {number} end Source end\n * @returns {string} Base64 encoded string\n /\nbase64.encode = function encode(buffer, start, end) {\n var parts = null,\n chunk = [];\n var i = 0, // output index\n j = 0, // goto index\n t; // temporary\n while (start < end) {\n var b = buffer[start++];\n switch (j) {\n case 0:\n chunk[i++] = b64[b >> 2];\n t = (b & 3) << 4;\n j = 1;\n break;\n case 1:\n chunk[i++] = b64[t \| b >> 4];\n t = (b & 15) << 2;\n j = 2;\n break;\n case 2:\n chunk[i++] = b64[t \| b >> 6];\n chunk[i++] = b64[b & 63];\n j = 0;\n break;\n }\n if (i > 8191) {\n (parts \|\| (parts = [])).push(String.fromCharCode.apply(String, chunk));\n i = 0;\n }\n }\n if (j) {\n chunk[i++] = b64[t];\n chunk[i++] = 61;\n if (j === 1)\n chunk[i++] = 61;\n }\n if (parts) {\n if (i)\n parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\n return parts.join(\"\");\n }\n return String.fromCharCode.apply(String, chunk.slice(0, i));\n};\n\nvar invalidEncoding = \"invalid encoding\";\n\n/\n Decodes a base64 encoded string to a buffer.\n * @param {string} string Source string\n * @param {Uint8Array} buffer Destination buffer\n * @param {number} offset Destination offset\n * @returns {number} Number of bytes written\n * @throws {Error} If encoding is invalid\n /\nbase64.decode = function decode(string, buffer, offset) {\n var start = offset;\n var j = 0, // goto index\n t; // temporary\n for (var i = 0; i < string.length;) {\n var c = string.charCodeAt(i++);\n if (c === 61 && j > 1)\n break;\n if ((c = s64[c]) === undefined)\n throw Error(invalidEncoding);\n switch (j) {\n case 0:\n t = c;\n j = 1;\n break;\n case 1:\n buffer[offset++] = t << 2 \| (c & 48) >> 4;\n t = c;\n j = 2;\n break;\n case 2:\n buffer[offset++] = (t & 15) << 4 \| (c & 60) >> 2;\n t = c;\n j = 3;\n break;\n case 3:\n buffer[offset++] = (t & 3) << 6 \| c;\n j = 0;\n break;\n }\n }\n if (j === 1)\n throw Error(invalidEncoding);\n return offset - start;\n};\n\nvar base64Re = /^(?:[A-Za-z0-9+/]{4})(?:[A-Za-z0-9+/]{2}==\|[A-Za-z0-9+/]{3}=)?$/,\n base64UrlRe = /[-_]/,\n base64UrlNoPaddingRe = /^(?:[A-Za-z0-9_-]{4})(?:[A-Za-z0-9_-]{2}(?:==)?\|[A-Za-z0-9_-]{3}=?)?$/;\n\n/\n Tests if the specified string appears to be base64 encoded.\n * @param {string} string String to test\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\n /\nbase64.test = function test(string) {\n return base64Re.test(string)\n \|\| base64UrlRe.test(string) && base64UrlNoPaddingRe.test(string);\n};\n","\"use strict\";\nmodule.exports = EventEmitter;\n\n/\n Constructs a new event emitter instance.\n * @classdesc A minimal event emitter.\n * @memberof util\n * @constructor\n /\nfunction EventEmitter() {\n\n /\n Registered listeners.\n * @type {Object.<string,>}\n @private\n /\n this._listeners = Object.create(null);\n}\n\n/\n Event listener as used by {@link util.EventEmitter}.\n * @typedef EventEmitterListener\n * @type {function}\n * @param {...} args Arguments\n @returns {undefined}\n /\n\n/\n Registers an event listener.\n * @param {string} evt Event name\n * @param {EventEmitterListener} fn Listener\n * @param {} [ctx] Listener context\n @returns {this} `this`\n /\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\n (this._listeners[evt] \|\| (this._listeners[evt] = [])).push({\n fn : fn,\n ctx : ctx \|\| this\n });\n return this;\n};\n\n/\n Removes an event listener or any matching listeners if arguments are omitted.\n * @param {string} [evt] Event name. Removes all listeners if omitted.\n * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\n * @returns {this} `this`\n /\nEventEmitter.prototype.off = function off(evt, fn) {\n if (evt === undefined)\n this._listeners = Object.create(null);\n else {\n if (fn === undefined)\n this._listeners[evt] = [];\n else {\n var listeners = this._listeners[evt];\n if (!listeners)\n return this;\n for (var i = 0; i < listeners.length;)\n if (listeners[i].fn === fn)\n listeners.splice(i, 1);\n else\n ++i;\n }\n }\n return this;\n};\n\n/\n Emits an event by calling its listeners with the specified arguments.\n * @param {string} evt Event name\n * @param {...} args Arguments\n @returns {this} `this`\n /\nEventEmitter.prototype.emit = function emit(evt) {\n var listeners = this._listeners[evt];\n if (listeners) {\n var args = [],\n i = 1;\n for (; i < arguments.length;)\n args.push(arguments[i++]);\n for (i = 0; i < listeners.length;)\n listeners[i].fn.apply(listeners[i++].ctx, args);\n }\n return this;\n};\n","\"use strict\";\n\nmodule.exports = factory(factory);\n\n/\n Reads / writes floats / doubles from / to buffers.\n * @name util.float\n * @namespace\n /\n\n/\n Writes a 32 bit float to a buffer using little endian byte order.\n * @name util.float.writeFloatLE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n /\n\n/\n Writes a 32 bit float to a buffer using big endian byte order.\n * @name util.float.writeFloatBE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n /\n\n/\n Reads a 32 bit float from a buffer using little endian byte order.\n * @name util.float.readFloatLE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n /\n\n/\n Reads a 32 bit float from a buffer using big endian byte order.\n * @name util.float.readFloatBE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n /\n\n/\n Writes a 64 bit double to a buffer using little endian byte order.\n * @name util.float.writeDoubleLE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n /\n\n/\n Writes a 64 bit double to a buffer using big endian byte order.\n * @name util.float.writeDoubleBE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n /\n\n/\n Reads a 64 bit double from a buffer using little endian byte order.\n * @name util.float.readDoubleLE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n /\n\n/\n Reads a 64 bit double from a buffer using big endian byte order.\n * @name util.float.readDoubleBE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n /\n\n// Factory function for the purpose of node-based testing in modified global environments\nfunction factory(exports) {\n\n // float: typed array\n if (typeof Float32Array !== \"undefined\") (function() {\n\n var f32 = new Float32Array([ -0 ]),\n f8b = new Uint8Array(f32.buffer),\n le = f8b[3] === 128;\n\n function writeFloat_f32_cpy(val, buf, pos) {\n f32[0] = val;\n buf[pos ] = f8b[0];\n buf[pos + 1] = f8b[1];\n buf[pos + 2] = f8b[2];\n buf[pos + 3] = f8b[3];\n }\n\n function writeFloat_f32_rev(val, buf, pos) {\n f32[0] = val;\n buf[pos ] = f8b[3];\n buf[pos + 1] = f8b[2];\n buf[pos + 2] = f8b[1];\n buf[pos + 3] = f8b[0];\n }\n\n / istanbul ignore next /\n exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\n / istanbul ignore next /\n exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\n\n function readFloat_f32_cpy(buf, pos) {\n f8b[0] = buf[pos ];\n f8b[1] = buf[pos + 1];\n f8b[2] = buf[pos + 2];\n f8b[3] = buf[pos + 3];\n return f32[0];\n }\n\n function readFloat_f32_rev(buf, pos) {\n f8b[3] = buf[pos ];\n f8b[2] = buf[pos + 1];\n f8b[1] = buf[pos + 2];\n f8b[0] = buf[pos + 3];\n return f32[0];\n }\n\n / istanbul ignore next /\n exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\n / istanbul ignore next /\n exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\n\n // float: ieee754\n })(); else (function() {\n\n function writeFloat_ieee754(writeUint, val, buf, pos) {\n var sign = val < 0 ? 1 : 0;\n if (sign)\n val = -val;\n if (val === 0)\n writeUint(1 / val > 0 ? / positive / 0 : / negative 0 / 2147483648, buf, pos);\n else if (isNaN(val))\n writeUint(2143289344, buf, pos);\n else if (val > 3.4028234663852886e+38) // +-Infinity\n writeUint((sign << 31 \| 2139095040) >>> 0, buf, pos);\n else if (val < 1.1754943508222875e-38) // denormal\n writeUint((sign << 31 \| Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\n else {\n var exponent = Math.floor(Math.log(val) / Math.LN2),\n mantissa = Math.round(val Math.pow(2, -exponent) * 8388608) & 8388607;\n writeUint((sign << 31 \| exponent + 127 << 23 \| mantissa) >>> 0, buf, pos);\n }\n }\n\n exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\n exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\n\n function readFloat_ieee754(readUint, buf, pos) {\n var uint = readUint(buf, pos),\n sign = (uint >> 31) * 2 + 1,\n exponent = uint >>> 23 & 255,\n mantissa = uint & 8388607;\n return exponent === 255\n ? mantissa\n ? NaN\n : sign * Infinity\n : exponent === 0 // denormal\n ? sign * 1.401298464324817e-45 * mantissa\n : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\n }\n\n exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\n exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\n\n })();\n\n // double: typed array\n if (typeof Float64Array !== \"undefined\") (function() {\n\n var f64 = new Float64Array([-0]),\n f8b = new Uint8Array(f64.buffer),\n le = f8b[7] === 128;\n\n function writeDouble_f64_cpy(val, buf, pos) {\n f64[0] = val;\n buf[pos ] = f8b[0];\n buf[pos + 1] = f8b[1];\n buf[pos + 2] = f8b[2];\n buf[pos + 3] = f8b[3];\n buf[pos + 4] = f8b[4];\n buf[pos + 5] = f8b[5];\n buf[pos + 6] = f8b[6];\n buf[pos + 7] = f8b[7];\n }\n\n function writeDouble_f64_rev(val, buf, pos) {\n f64[0] = val;\n buf[pos ] = f8b[7];\n buf[pos + 1] = f8b[6];\n buf[pos + 2] = f8b[5];\n buf[pos + 3] = f8b[4];\n buf[pos + 4] = f8b[3];\n buf[pos + 5] = f8b[2];\n buf[pos + 6] = f8b[1];\n buf[pos + 7] = f8b[0];\n }\n\n /* istanbul ignore next /\n exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\n / istanbul ignore next /\n exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\n\n function readDouble_f64_cpy(buf, pos) {\n f8b[0] = buf[pos ];\n f8b[1] = buf[pos + 1];\n f8b[2] = buf[pos + 2];\n f8b[3] = buf[pos + 3];\n f8b[4] = buf[pos + 4];\n f8b[5] = buf[pos + 5];\n f8b[6] = buf[pos + 6];\n f8b[7] = buf[pos + 7];\n return f64[0];\n }\n\n function readDouble_f64_rev(buf, pos) {\n f8b[7] = buf[pos ];\n f8b[6] = buf[pos + 1];\n f8b[5] = buf[pos + 2];\n f8b[4] = buf[pos + 3];\n f8b[3] = buf[pos + 4];\n f8b[2] = buf[pos + 5];\n f8b[1] = buf[pos + 6];\n f8b[0] = buf[pos + 7];\n return f64[0];\n }\n\n / istanbul ignore next /\n exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\n / istanbul ignore next /\n exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\n\n // double: ieee754\n })(); else (function() {\n\n function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\n var sign = val < 0 ? 1 : 0;\n if (sign)\n val = -val;\n if (val === 0) {\n writeUint(0, buf, pos + off0);\n writeUint(1 / val > 0 ? / positive / 0 : / negative 0 / 2147483648, buf, pos + off1);\n } else if (isNaN(val)) {\n writeUint(0, buf, pos + off0);\n writeUint(2146959360, buf, pos + off1);\n } else if (val > 1.7976931348623157e+308) { // +-Infinity\n writeUint(0, buf, pos + off0);\n writeUint((sign << 31 \| 2146435072) >>> 0, buf, pos + off1);\n } else {\n var mantissa;\n if (val < 2.2250738585072014e-308) { // denormal\n mantissa = val / 5e-324;\n writeUint(mantissa >>> 0, buf, pos + off0);\n writeUint((sign << 31 \| mantissa / 4294967296) >>> 0, buf, pos + off1);\n } else {\n var exponent = Math.floor(Math.log(val) / Math.LN2);\n if (exponent === 1024)\n exponent = 1023;\n mantissa = val Math.pow(2, -exponent);\n writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\n writeUint((sign << 31 \| exponent + 1023 << 20 \| mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\n }\n }\n }\n\n exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\n exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\n\n function readDouble_ieee754(readUint, off0, off1, buf, pos) {\n var lo = readUint(buf, pos + off0),\n hi = readUint(buf, pos + off1);\n var sign = (hi >> 31) * 2 + 1,\n exponent = hi >>> 20 & 2047,\n mantissa = 4294967296 * (hi & 1048575) + lo;\n return exponent === 2047\n ? mantissa\n ? NaN\n : sign * Infinity\n : exponent === 0 // denormal\n ? sign * 5e-324 * mantissa\n : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\n }\n\n exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\n exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\n\n })();\n\n return exports;\n}\n\n// uint helpers\n\nfunction writeUintLE(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\nfunction writeUintBE(val, buf, pos) {\n buf[pos ] = val >>> 24;\n buf[pos + 1] = val >>> 16 & 255;\n buf[pos + 2] = val >>> 8 & 255;\n buf[pos + 3] = val & 255;\n}\n\nfunction readUintLE(buf, pos) {\n return (buf[pos ]\n \| buf[pos + 1] << 8\n \| buf[pos + 2] << 16\n \| buf[pos + 3] << 24) >>> 0;\n}\n\nfunction readUintBE(buf, pos) {\n return (buf[pos ] << 24\n \| buf[pos + 1] << 16\n \| buf[pos + 2] << 8\n \| buf[pos + 3]) >>> 0;\n}\n","\"use strict\";\nmodule.exports = LongBits;\n\nvar Long;\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 (typeof value === \"string\" \|\| value instanceof String) {\n / istanbul ignore else /\n if (Long)\n value = 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 Long\n ? new 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\nLongBits._configure = function(Long_) {\n Long = Long_;\n};\n","\"use strict\";\n/ global globalThis /\nvar util = exports;\n\n// used to return a Promise where callback is omitted\nutil.asPromise = require(7);\n\n// converts to / from base64 encoded strings\nutil.base64 = require(8);\n\n// base class of rpc.Service\nutil.EventEmitter = require(9);\n\n// float handling accross browsers\nutil.float = require(10);\n\n// converts to / from utf8 encoded strings\nutil.utf8 = require(14);\n\n// provides a node-like buffer pool in the browser\nutil.pool = require(13);\n\n// utility to work with the low and high bits of a 64 bit value\nutil.LongBits = require(11);\n\n/\n Tests if the specified key can affect object prototypes.\n * @memberof util\n * @param {string} key Key to test\n * @returns {boolean} `true` if the key is unsafe\n /\nfunction isUnsafeProperty(key) {\n return key === \"__proto__\" \|\| key === \"prototype\" \|\| key === \"constructor\";\n}\n\nutil.isUnsafeProperty = isUnsafeProperty;\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 \|\| typeof globalThis !== \"undefined\" && globalThis\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 && Object.hasOwnProperty.call(obj, prop)) // eslint-disable-line eqeqeq\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.global.Buffer;\n // refuse to use non-node buffers if not explicitly assigned (perf reasons)\n return Buffer.prototype.utf8Write \|\| util.isNode ? Buffer : / istanbul ignore next / null;\n } catch (e) {\n / istanbul ignore next /\n return null;\n }\n})();\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 var Buffer = util.Buffer;\n / istanbul ignore next /\n return typeof sizeOrArray === \"number\"\n ? Buffer\n ? Buffer.allocUnsafe(sizeOrArray)\n : new Uint8Array(sizeOrArray)\n : Buffer\n ? Buffer.from(sizeOrArray)\n : new Uint8Array(sizeOrArray);\n};\n\n/\n Prepends a raw field tag to raw field data.\n * @param {number} id Field id\n * @param {number} wireType Wire type\n * @param {Uint8Array} data Raw field data\n * @returns {Uint8Array\|Buffer} Raw field bytes\n * @ignore\n /\nutil.rawField = function rawField(id, wireType, data) {\n var out = [],\n tag = id << 3 \| wireType;\n tag >>>= 0;\n while (tag > 127) {\n out.push(tag & 127 \| 128);\n tag >>>= 7;\n }\n out.push(tag);\n for (var i = 0; i < data.length; ++i)\n out.push(data[i]);\n return util.newBuffer(out);\n};\n\n/\n Array implementation used in the browser.\n * @type {Constructor<Uint8Array>}\n * @deprecated Use `Uint8Array` instead.\n /\nutil.Array = Uint8Array;\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 \|\| (function() {\n try {\n var Long = require(\"long\");\n return Long && Long.isLong ? Long : null;\n } catch (e) {\n / istanbul ignore next /\n return null;\n }\n })();\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]))$/; // eslint-disable-line no-control-regex\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 Converts a 64 bit key to a long or number if it is an 8 characters long hash string.\n * @param {string} key Map key\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long\|number\|string} Original value\n /\nutil.longFromKey = function longFromKey(key, unsigned) {\n return util.key64Re.test(key) && !util.key32Re.test(key)\n ? util.longFromHash(key, unsigned)\n : key;\n};\n\n/\n Converts a boolean key to a boolean value.\n * @param {string} key Map key\n * @returns {boolean} Boolean value\n /\nutil.boolFromKey = function boolFromKey(key) {\n return key === \"true\" \|\| key === \"1\";\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,>\|boolean)} src Source objects, optionally followed by an `ifNotSet` flag\n @returns {Object.<string,>} Destination object\n /\nfunction merge(dst) { // used by converters\n var ifNotSet = typeof arguments[arguments.length - 1] === \"boolean\",\n limit = ifNotSet ? arguments.length - 1 : arguments.length;\n ifNotSet = ifNotSet && arguments[arguments.length - 1];\n for (var a = 1; a < limit; ++a) {\n var src = arguments[a];\n if (!src)\n continue;\n for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)\n if (!isUnsafeProperty(keys[i]) && (!ifNotSet \|\| !Object.prototype.hasOwnProperty.call(dst, keys[i]) \|\| dst[keys[i]] === undefined))\n dst[keys[i]] = src[keys[i]];\n }\n return dst;\n}\n\nutil.merge = merge;\n\n/*\n Schema declaration nesting limit.\n * @memberof util\n * @type {number}\n /\nutil.nestingLimit = 32; // protoc: MaxMessageDeclarationNestingDepth\n\n/\n Recursion limit.\n * @memberof util\n * @type {number}\n /\nutil.recursionLimit = 100; // protoc: CodedInputStream::default_recursion_limit_\n\n/\n Makes a property safe for assignment as an own property.\n * @memberof util\n * @param {Object.<string,>} obj Object\n @param {string} key Property key\n * @param {boolean} [enumerable=true] Whether the property should be enumerable\n * @returns {undefined}\n /\nutil.makeProp = function makeProp(obj, key, enumerable) {\n if (Object.prototype.hasOwnProperty.call(obj, key))\n return;\n Object.defineProperty(obj, key, {\n enumerable: enumerable === undefined ? true : enumerable,\n configurable: true,\n writable: true\n });\n};\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","\"use strict\";\nmodule.exports = pool;\n\n/\n An allocator as used by {@link util.pool}.\n * @typedef PoolAllocator\n * @type {function}\n * @param {number} size Buffer size\n * @returns {Uint8Array} Buffer\n /\n\n/\n A slicer as used by {@link util.pool}.\n * @typedef PoolSlicer\n * @type {function}\n * @param {number} start Start offset\n * @param {number} end End offset\n * @returns {Uint8Array} Buffer slice\n * @this Uint8Array\n /\n\n/\n A general purpose buffer pool.\n * @memberof util\n * @function\n * @param {PoolAllocator} alloc Allocator\n * @param {PoolSlicer} slice Slicer\n * @param {number} [size=8192] Slab size\n * @returns {PoolAllocator} Pooled allocator\n /\nfunction pool(alloc, slice, size) {\n var SIZE = size \|\| 8192;\n var MAX = SIZE >>> 1;\n var slab = null;\n var offset = SIZE;\n return function pool_alloc(size) {\n if (size < 1 \|\| size > MAX)\n return alloc(size);\n if (offset + size > SIZE) {\n slab = alloc(SIZE);\n offset = 0;\n }\n var buf = slice.call(slab, offset, offset += size);\n if (offset & 7) // align to 32 bit\n offset = (offset \| 7) + 1;\n return buf;\n };\n}\n","\"use strict\";\n\n/\n A minimal UTF8 implementation.\n * @memberof util\n * @namespace\n /\nvar utf8 = exports,\n replacementChar = \"\\ufffd\",\n looseDecoder = new TextDecoder(\"utf-8\", { ignoreBOM: true }),\n strictDecoder;\nvar TEXT_DECODER_MIN_LENGTH = 64;\n\ntry {\n strictDecoder = new TextDecoder(\"utf-8\", { fatal: true, ignoreBOM: true });\n} catch (err) {\n // \"fatal\" option is not supported on Node.js compiled without ICU\n strictDecoder = looseDecoder;\n}\n\n/\n Calculates the UTF8 byte length of a string.\n * @param {string} string String\n * @returns {number} Byte length\n /\nutf8.length = function utf8_length(string) {\n var len = 0,\n c = 0;\n for (var i = 0; i < string.length; ++i) {\n c = string.charCodeAt(i);\n if (c < 128)\n len += 1;\n else if (c < 2048)\n len += 2;\n else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\n ++i;\n len += 4;\n } else\n len += 3;\n }\n return len;\n};\n\nfunction utf8_read_js(buffer, start, end, str) {\n for (var i = start; i < end;) {\n var t = buffer[i++];\n if (t <= 0x7F) {\n str += String.fromCharCode(t);\n } else if (t >= 0xC0 && t < 0xE0) {\n var c2 = (t & 0x1F) << 6 \| buffer[i++] & 0x3F;\n str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;\n } else if (t >= 0xE0 && t < 0xF0) {\n var c3 = (t & 0xF) << 12 \| (buffer[i++] & 0x3F) << 6 \| buffer[i++] & 0x3F;\n str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;\n } else if (t >= 0xF0) {\n var t2 = (t & 7) << 18 \| (buffer[i++] & 0x3F) << 12 \| (buffer[i++] & 0x3F) << 6 \| buffer[i++] & 0x3F;\n if (t2 < 0x10000 \|\| t2 > 0x10FFFF)\n str += replacementChar;\n else {\n t2 -= 0x10000;\n str += String.fromCharCode(0xD800 + (t2 >> 10));\n str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));\n }\n }\n }\n return str;\n}\n\nfunction utf8_read_decoder(decoder, buffer, start, end) {\n var source = start === 0 && end === buffer.length\n ? buffer\n : buffer.subarray(start, end);\n return decoder.decode(source);\n}\n\n/\n Reads UTF8 bytes as a string.\n * @param {Uint8Array} buffer Source buffer\n * @param {number} start Source start\n * @param {number} end Source end\n * @returns {string} String read\n /\nutf8.read = function utf8_read_loose(buffer, start, end) {\n if (end - start < 1)\n return \"\";\n if (end - start >= TEXT_DECODER_MIN_LENGTH)\n return utf8_read_decoder(looseDecoder, buffer, start, end);\n\n var str = \"\",\n i = start,\n c1, c2, c3, c4, c5, c6, c7, c8;\n\n for (; i + 7 < end; i += 8) {\n c1 = buffer[i];\n c2 = buffer[i + 1];\n c3 = buffer[i + 2];\n c4 = buffer[i + 3];\n c5 = buffer[i + 4];\n c6 = buffer[i + 5];\n c7 = buffer[i + 6];\n c8 = buffer[i + 7];\n if ((c1 \| c2 \| c3 \| c4 \| c5 \| c6 \| c7 \| c8) & 0x80)\n return utf8_read_js(buffer, i, end, str);\n str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);\n }\n\n for (; i < end; ++i) {\n c1 = buffer[i];\n if (c1 & 0x80)\n return utf8_read_js(buffer, i, end, str);\n str += String.fromCharCode(c1);\n }\n\n return str;\n};\n\n/\n Reads UTF8 bytes as a string, rejecting invalid UTF8.\n * @param {Uint8Array} buffer Source buffer\n * @param {number} start Source start\n * @param {number} end Source end\n * @returns {string} String read\n /\nutf8.readStrict = function utf8_read_strict(buffer, start, end) {\n if (end - start < 1)\n return \"\";\n if (end - start >= TEXT_DECODER_MIN_LENGTH)\n return utf8_read_decoder(strictDecoder, buffer, start, end);\n\n var str = \"\",\n i = start,\n c1, c2, c3, c4, c5, c6, c7, c8;\n\n for (; i + 7 < end; i += 8) {\n c1 = buffer[i];\n c2 = buffer[i + 1];\n c3 = buffer[i + 2];\n c4 = buffer[i + 3];\n c5 = buffer[i + 4];\n c6 = buffer[i + 5];\n c7 = buffer[i + 6];\n c8 = buffer[i + 7];\n if ((c1 \| c2 \| c3 \| c4 \| c5 \| c6 \| c7 \| c8) & 0x80)\n return str + utf8_read_decoder(strictDecoder, buffer, i, end);\n str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);\n }\n\n for (; i < end; ++i) {\n c1 = buffer[i];\n if (c1 & 0x80)\n return str + utf8_read_decoder(strictDecoder, buffer, i, end);\n str += String.fromCharCode(c1);\n }\n\n return str;\n};\n\n/\n Writes a string as UTF8 bytes.\n * @param {string} string Source string\n * @param {Uint8Array} buffer Destination buffer\n * @param {number} offset Destination offset\n * @returns {number} Bytes written\n /\nutf8.write = function utf8_write(string, buffer, offset) {\n var start = offset,\n c1, // character 1\n c2; // character 2\n for (var i = 0; i < string.length; ++i) {\n c1 = string.charCodeAt(i);\n if (c1 < 128) {\n buffer[offset++] = c1;\n } else if (c1 < 2048) {\n buffer[offset++] = c1 >> 6 \| 192;\n buffer[offset++] = c1 & 63 \| 128;\n } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\n ++i;\n buffer[offset++] = c1 >> 18 \| 240;\n buffer[offset++] = c1 >> 12 & 63 \| 128;\n buffer[offset++] = c1 >> 6 & 63 \| 128;\n buffer[offset++] = c1 & 63 \| 128;\n } else {\n buffer[offset++] = c1 >> 12 \| 224;\n buffer[offset++] = c1 >> 6 & 63 \| 128;\n buffer[offset++] = c1 & 63 \| 128;\n }\n }\n return offset - start;\n};\n","\"use strict\";\nmodule.exports = Writer;\n\nvar util = require(12);\n\nvar BufferWriter; // cyclic\n\nvar LongBits = util.LongBits,\n base64 = util.base64,\n utf8 = util.utf8;\n\n/\n Constructs a new writer instance.\n * @classdesc Wire format writer using `Uint8Array`.\n * @constructor\n /\nfunction Writer() {\n\n /\n Write cursor into {@link Writer#buf}.\n * @type {number}\n /\n this.pos = 0;\n\n /\n Backing buffer.\n * @type {Uint8Array}\n /\n this.buf = this.constructor.alloc(64);\n\n /\n Cached DataView over {@link Writer#buf}.\n * @type {DataView\|null}\n /\n this.view = null;\n\n /\n Stack of forked length-prefix positions.\n * @type {Array<number>\|null}\n /\n this.states = null;\n}\n\n/\n Current write position.\n * @name Writer#len\n * @type {number}\n * @deprecated Use {@link Writer#pos} instead.\n /\nObject.defineProperty(Writer.prototype, \"len\", {\n configurable: true,\n enumerable: true,\n get: function get_len() {\n return this.pos;\n }\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 Uint8Array(size);\n};\n\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\nWriter.alloc = util.pool(Writer.alloc, Uint8Array.prototype.subarray);\n\n/\n Calculates the number of bytes a value occupies as a varint.\n * @param {number} value Value to size (unsigned)\n * @returns {number} Byte length (1..5)\n * @ignore\n /\nfunction sizeVarint32(value) {\n return value < 128 ? 1\n : value < 16384 ? 2\n : value < 2097152 ? 3\n : value < 268435456 ? 4\n : 5;\n}\n\n/\n Ensures that at least `n` more bytes fit into the backing buffer, doubling it if not.\n * @param {number} n Number of additional bytes required\n * @returns {undefined}\n * @private\n /\nWriter.prototype._reserve = function _reserve(n) {\n var need = this.pos + n;\n if (need > this.buf.length) {\n var size = this.buf.length << 1;\n if (size < need)\n size = need;\n var buf = this.constructor.alloc(size);\n buf.set(this.buf.subarray(0, this.pos), 0);\n this.buf = buf;\n this.view = null; // invalidate\n }\n};\n\nfunction writeStringAscii(val, buf, pos) {\n for (var i = 0; i < val.length;)\n buf[pos++] = val.charCodeAt(i++);\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 return pos + 1;\n}\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 value = value >>> 0;\n this._reserve(5);\n var pos = this.pos;\n this.pos = writeVarint32(value, this.buf, pos);\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 if ((value \|= 0) < 0) { // 10 bytes per spec\n this._reserve(10);\n writeVarint64(LongBits.fromNumber(value), this.buf, this.pos);\n this.pos += 10;\n return this;\n }\n return 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 var lo = val.lo,\n hi = val.hi;\n while (hi) {\n buf[pos++] = lo & 127 \| 128;\n lo = (lo >>> 7 \| hi << 25) >>> 0;\n hi >>>= 7;\n }\n while (lo > 127) {\n buf[pos++] = lo & 127 \| 128;\n lo = lo >>> 7;\n }\n buf[pos] = lo;\n return pos + 1;\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 this._reserve(10);\n var pos = this.pos;\n this.pos = writeVarint64(bits, this.buf, pos);\n return this;\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 this._reserve(10);\n var pos = this.pos;\n this.pos = writeVarint64(bits, this.buf, pos);\n return this;\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 this._reserve(1);\n this.buf[this.pos++] = value ? 1 : 0;\n return this;\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 this._reserve(4);\n writeFixed32(value >>> 0, this.buf, this.pos);\n this.pos += 4;\n return this;\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 this._reserve(8);\n writeFixed32(bits.lo, this.buf, this.pos);\n writeFixed32(bits.hi, this.buf, this.pos + 4);\n this.pos += 8;\n return this;\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 this._reserve(4);\n util.float.writeFloatLE(value, this.buf, this.pos);\n this.pos += 4;\n return this;\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 this._reserve(8);\n util.float.writeDoubleLE(value, this.buf, this.pos);\n this.pos += 8;\n return this;\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 this._reserve(1);\n this.buf[this.pos++] = 0;\n return this;\n }\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 this.uint32(len);\n this._reserve(len);\n this.buf.set(value, this.pos);\n this.pos += len;\n return this;\n};\n\n/\n Writes raw bytes without a tag or length prefix.\n * @param {Uint8Array} value Raw bytes\n * @returns {Writer} `this`\n /\nWriter.prototype.raw = function write_raw(value) {\n var len = value.length >>> 0;\n if (!len)\n return this;\n this._reserve(len);\n this.buf.set(value, this.pos);\n this.pos += len;\n return this;\n};\n\n/\n Backfills the length varint.\n * @param {number} pos Position of reserved length byte\n * @param {number} len Length of content after length varint\n * @returns {Writer} `this`\n * @private\n /\nWriter.prototype._delim = function _delim(pos, len) {\n var n = sizeVarint32(len);\n if (n > 1)\n this.buf.copyWithin(pos + n, pos + 1, pos + 1 + len);\n writeVarint32(len, this.buf, pos);\n this.pos = pos + n + len;\n return this;\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 n = value.length;\n if (!n) {\n this._reserve(1);\n this.buf[this.pos++] = 0;\n return this;\n }\n if (n < 0x80) {\n this._reserve(n 3 + 5); // worst case\n var lenPos = this.pos;\n return this._delim(lenPos, utf8.write(value, this.buf, lenPos + 1));\n }\n var len = utf8.length(value);\n this.uint32(len);\n this._reserve(len);\n if (len === value.length)\n writeStringAscii(value, this.buf, this.pos);\n else\n utf8.write(value, this.buf, this.pos);\n this.pos += len;\n return this;\n};\n\n/*\n Writes an array of unsigned 32 bit values as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.uint32s = function write_uint32s(value) {\n var n = value.length;\n this._reserve(n 5 + 5); // worst case: 5 bytes per value + length varint\n var buf = this.buf, lenPos = this.pos, p = lenPos + 1;\n for (var i = 0; i < n; ++i)\n p = writeVarint32(value[i] >>> 0, buf, p);\n return this._delim(lenPos, p - lenPos - 1);\n};\n\n/*\n Writes an array of signed 32 bit values as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.int32s = function write_int32s(value) {\n var n = value.length;\n this._reserve(n 10 + 5); // worst case: 10 bytes per negative value + length varint\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1, val;\n for (var i = 0; i < n; ++i) {\n if ((val = value[i] \| 0) < 0) { // negatives are 10 bytes per spec\n pos = writeVarint64(LongBits.fromNumber(val), buf, pos);\n } else {\n pos = writeVarint32(val, buf, pos);\n }\n }\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/*\n Writes an array of 32 bit values as packed, zig-zag encoded varints.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.sint32s = function write_sint32s(value) {\n var n = value.length;\n this._reserve(n 5 + 5);\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;\n for (var i = 0; i < n; ++i)\n pos = writeVarint32((value[i] << 1 ^ value[i] >> 31) >>> 0, buf, pos);\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/*\n Writes an array of unsigned 64 bit values as a packed repeated field.\n * @param {Array.<Long\|number\|string>} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.uint64s = function write_uint64s(value) {\n var n = value.length;\n this._reserve(n 10 + 5);\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;\n for (var i = 0; i < n; ++i) {\n pos = writeVarint64(LongBits.from(value[i]), buf, pos);\n }\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/*\n Writes an array of signed 64 bit values as a packed repeated field.\n * @function\n * @param {Array.<Long\|number\|string>} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.int64s = Writer.prototype.uint64s;\n\n/\n Writes an array of 64 bit values as packed, zig-zag encoded varints.\n * @param {Array.<Long\|number\|string>} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.sint64s = function write_sint64s(value) {\n var n = value.length;\n this._reserve(n 10 + 5);\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;\n for (var i = 0; i < n; ++i) {\n pos = writeVarint64(LongBits.from(value[i]).zzEncode(), buf, pos);\n }\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/*\n Writes an array of boolish values as a packed repeated field.\n * @param {boolean[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.bools = function write_bools(value) {\n var n = value.length;\n this.uint32(n); // one byte per value\n this._reserve(n);\n var buf = this.buf, p = this.pos;\n for (var i = 0; i < n; ++i)\n buf[p++] = value[i] ? 1 : 0;\n this.pos += n;\n return this;\n};\n\n// The view allocation only pays off when amortized over enough writes\nvar VIEW_THRESHOLD_FLOAT = 16,\n VIEW_THRESHOLD_INT = 128;\n\nfunction getLazyView(writer, count, threshold) {\n var view = writer.view;\n if (view \|\| count < threshold)\n return view;\n var buf = writer.buf;\n return writer.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n}\n\n/\n Writes an array of unsigned 32 bit values as packed, fixed 32 bits.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.fixed32s = function write_fixed32s(value) {\n var n = value.length, bytes = n 4;\n this.uint32(bytes); // length is known exactly\n this._reserve(bytes);\n var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);\n if (dv)\n for (i = 0; i < n; ++i) { dv.setUint32(p, value[i] >>> 0, true); p += 4; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { writeFixed32(value[i] >>> 0, buf, p); p += 4; }\n }\n this.pos += bytes;\n return this;\n};\n\n/*\n Writes an array of signed 32 bit values as packed, fixed 32 bits.\n * @function\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.sfixed32s = Writer.prototype.fixed32s;\n\n/\n Writes an array of unsigned 64 bit values as packed, fixed 64 bits.\n * @param {Array.<Long\|number\|string>} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.fixed64s = function write_fixed64s(value) {\n var n = value.length, bytes = n 8;\n this.uint32(bytes);\n this._reserve(bytes);\n var p = this.pos, i, bits, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);\n if (dv)\n for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); dv.setUint32(p, bits.lo, true); dv.setUint32(p + 4, bits.hi, true); p += 8; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); writeFixed32(bits.lo, buf, p); writeFixed32(bits.hi, buf, p + 4); p += 8; }\n }\n this.pos += bytes;\n return this;\n};\n\n/*\n Writes an array of signed 64 bit values as packed, fixed 64 bits.\n * @function\n * @param {Array.<Long\|number\|string>} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.sfixed64s = Writer.prototype.fixed64s;\n\n/\n Writes an array of floats (32 bit) as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.floats = function write_floats(value) {\n var n = value.length, bytes = n 4;\n this.uint32(bytes);\n this._reserve(bytes);\n var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (i = 0; i < n; ++i) { dv.setFloat32(p, value[i], true); p += 4; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { util.float.writeFloatLE(value[i], buf, p); p += 4; }\n }\n this.pos += bytes;\n return this;\n};\n\n/*\n Writes an array of doubles (64 bit float) as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n /\nWriter.prototype.doubles = function write_doubles(value) {\n var n = value.length, bytes = n 8;\n this.uint32(bytes);\n this._reserve(bytes);\n var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (i = 0; i < n; ++i) { dv.setFloat64(p, value[i], true); p += 8; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { util.float.writeDoubleLE(value[i], buf, p); p += 8; }\n }\n this.pos += bytes;\n return this;\n};\n\n/*\n Forks this writer's state by pushing it to a stack.\n * @returns {Writer} `this`\n /\nWriter.prototype.fork = function fork() {\n this._reserve(1);\n (this.states \|\| (this.states = [])).push(this.pos);\n this.pos += 1;\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 var states = this.states;\n if (states && states.length) {\n this.pos = states.pop();\n } else {\n this.pos = 0;\n }\n return this;\n};\n\n/\n Resets to the last state and prepends the fork state's current write length as a varint.\n * @returns {Writer} `this`\n /\nWriter.prototype.ldelim = function ldelim() {\n var states = this.states,\n len,\n vlen;\n if (states && states.length) {\n var lenPos = states.pop();\n len = this.pos - lenPos - 1;\n vlen = sizeVarint32(len);\n if (vlen > 1) { // grow the reserved single byte and shift content forward\n this._reserve(vlen - 1);\n this.buf.copyWithin(lenPos + vlen, lenPos + 1, lenPos + 1 + len);\n this.pos += vlen - 1;\n writeVarint32(len, this.buf, lenPos);\n } else {\n this.buf[lenPos] = len;\n }\n } else { // not forked: prefix the entire buffer with its length\n // TODO: Compatibility with older generated code.\n // Remove this branch in the next major release.\n len = this.pos;\n vlen = sizeVarint32(len);\n this._reserve(vlen);\n this.buf.copyWithin(vlen, 0, len);\n writeVarint32(len, this.buf, 0);\n this.pos += vlen;\n }\n return this;\n};\n\n/\n Finishes the write operation.\n * Returns a buffer sized to the written data by default.\n * @param {boolean} [shared=false] Whether to return a shared view instead of a unique copy\n * @returns {Uint8Array} Finished buffer\n /\nWriter.prototype.finish = function finish(shared) {\n if (shared)\n return this.buf.subarray(0, this.pos);\n var buf = this.constructor.alloc(this.pos);\n buf.set(this.buf.subarray(0, this.pos), 0);\n return buf;\n};\n\n/\n Finishes the write operation, writing into the provided buffer.\n * The caller must ensure that `buf` has enough space starting at `offset`\n * to hold {@link Writer#pos} bytes.\n * @param {T} buf Target buffer\n * @param {number} [offset=0] Offset to start writing at\n * @returns {T} The provided buffer\n * @template T extends Uint8Array\n /\nWriter.prototype.finishInto = function finishInto(buf, offset) {\n if (offset === undefined)\n offset = 0;\n buf.set(this.buf.subarray(0, this.pos), offset);\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(15);\nBufferWriter.prototype = Object.create(Writer.prototype, {\n constructor: {\n value: BufferWriter,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\n\nvar util = require(12);\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\nvar writeStringBuffer;\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 && util.Buffer.allocUnsafe;\n\n writeStringBuffer = util.Buffer && util.Buffer.prototype.utf8Write\n ? function writeStringBuffer_utf8Write(val, buf, pos) {\n return buf.utf8Write(val, pos);\n }\n : function writeStringBuffer_write(val, buf, pos) {\n return buf.write(val, pos);\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._reserve(len);\n this.buf.set(value, this.pos);\n this.pos += len;\n }\n return this;\n};\n\n/\n @override\n /\nBufferWriter.prototype.string = function write_string_buffer(value) {\n var n = value.length;\n if (!n) {\n this._reserve(1);\n this.buf[this.pos++] = 0;\n return this;\n }\n if (n < 0x80) {\n this._reserve(n 3 + 5); // worst case\n var pos = this.pos,\n buf = this.buf;\n return this._delim(pos,\n n < 40\n ? util.utf8.write(value, buf, pos + 1)\n : writeStringBuffer(value, buf, pos + 1)\n );\n }\n var len = util.Buffer.byteLength(value);\n this.uint32(len);\n this._reserve(len);\n writeStringBuffer(value, this.buf, this.pos);\n this.pos += len;\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"],"sourceRoot":"."}
1	+ {"version":3,"sources":["lib/prelude.js","../node_modules/@protobufjs/aspromise/index.js","../node_modules/@protobufjs/base64/index.js","../node_modules/@protobufjs/eventemitter/index.js","../node_modules/@protobufjs/float/index.js","../node_modules/@protobufjs/inquire/index.js","../node_modules/@protobufjs/pool/index.js","../node_modules/@protobufjs/utf8/index.js","../src/index-minimal","../src/reader.js","../src/reader_buffer.js","../src/roots.js","../src/rpc.js","../src/rpc/service.js","../src/util/longbits.js","../src/util/minimal.js","../src/writer.js","../src/writer_buffer.js"],"names":["undefined","modules","cache","protobuf","1","require","module","exports","fn","ctx","params","Array","arguments","length","offset","index","pending","Promise","resolve","reject","err","apply","base64","string","p","n","Math","ceil","b64","s64","i","encode","buffer","start","end","t","parts","chunk","j","b","push","String","fromCharCode","slice","join","invalidEncoding","decode","c","charCodeAt","Error","test","EventEmitter","this","_listeners","Object","create","prototype","on","evt","off","listeners","splice","emit","args","factory","writeFloat_ieee754","writeUint","val","buf","pos","sign","isNaN","round","exponent","floor","log","LN2","pow","readFloat_ieee754","readUint","uint","mantissa","NaN","Infinity","writeFloat_f32_cpy","f32","f8b","writeFloat_f32_rev","readFloat_f32_cpy","readFloat_f32_rev","f64","le","writeDouble_ieee754","off0","off1","readDouble_ieee754","lo","hi","writeDouble_f64_cpy","writeDouble_f64_rev","readDouble_f64_cpy","readDouble_f64_rev","Float32Array","Uint8Array","writeFloatLE","writeFloatBE","readFloatLE","readFloatBE","bind","writeUintLE","writeUintBE","readUintLE","readUintBE","Float64Array","writeDoubleLE","writeDoubleBE","readDoubleLE","readDoubleBE","moduleName","mod","keys","alloc","size","SIZE","MAX","slab","call","utf8","len","read","str","c3","c2","t2","write","c1","configure","util","_configure","Writer","BufferWriter","Reader","BufferReader","build","rpc","roots","LongBits","indexOutOfRange","reader","writeLength","RangeError","Buffer","isBuffer","create_array","value","isArray","readLongVarint","bits","readFixed32_end","readFixed64","_slice","subarray","uint32","int32","sint32","bool","fixed32","sfixed32","float","double","bytes","nativeBuffer","constructor","skip","recursionLimit","skipType","wireType","depth","BufferReader_","Long","merge","int64","uint64","sint64","zzDecode","fixed64","sfixed64","utf8Slice","min","toString","Service","rpcImpl","requestDelimited","responseDelimited","TypeError","Boolean","rpcCall","method","requestCtor","responseCtor","request","callback","self","asPromise","setTimeout","finish","response","endedByRPC","zero","toNumber","zzEncode","zeroHash","fromNumber","from","isString","parseInt","fromString","low","high","unsigned","toLong","fromHash","hash","toHash","mask","part0","part1","part2","isUnsafeProperty","key","dst","limit","ifNotSet","a","src","newError","name","CustomError","message","properties","defineProperty","get","captureStackTrace","stack","writable","enumerable","configurable","set","inquire","pool","isNode","global","process","versions","node","window","emptyArray","freeze","emptyObject","isInteger","Number","isFinite","isObject","isset","isSet","obj","prop","hasOwnProperty","utf8Write","e","_Buffer_from","_Buffer_allocUnsafe","newBuffer","sizeOrArray","dcodeIO","isLong","key2Re","key32Re","key64Re","longToHash","longFromHash","fromBits","nestingLimit","makeProp","lcFirst","toLowerCase","substring","ProtocolError","oneOfGetter","fieldNames","fieldMap","oneOfSetter","toJSONOptions","longs","enums","json","encoding","allocUnsafe","Op","next","noop","State","writer","head","tail","states","writeByte","VarintOp","writeVarint64","writeFixed32","_push","writeBytes","fork","reset","ldelim","BufferWriter_","writeStringBuffer","writeBytesBuffer","copy","byteLength","$require","$module","define","amd"],"mappings":"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","file":"protobuf.min.js","sourcesContent":["(function prelude(modules, cache, entries) {\n\n // This is the prelude used to bundle protobuf.js for the browser. Wraps up the CommonJS\n // sources through a conflict-free require shim and is again wrapped within an iife that\n // provides a minification-friendly `undefined` var plus a global \"use strict\" directive\n // so that minification can remove the directives of each module.\n\n function $require(name) {\n var $module = cache[name];\n if (!$module)\n modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);\n return $module.exports;\n }\n\n var protobuf = $require(entries[0]);\n\n // Expose globally\n protobuf.util.global.protobuf = protobuf;\n\n // Be nice to AMD\n if (typeof define === \"function\" && define.amd)\n define([\"long\"], function(Long) {\n if (Long && Long.isLong) {\n protobuf.util.Long = Long;\n protobuf.configure();\n }\n return protobuf;\n });\n\n // Be nice to CommonJS\n if (typeof module === \"object\" && module && module.exports)\n module.exports = protobuf;\n\n})/* end of prelude /","\"use strict\";\r\nmodule.exports = asPromise;\r\n\r\n/\r\n Callback as used by {@link util.asPromise}.\r\n * @typedef asPromiseCallback\r\n * @type {function}\r\n * @param {Error\|null} error Error, if any\r\n * @param {...} params Additional arguments\r\n @returns {undefined}\r\n /\r\n\r\n/\r\n Returns a promise from a node-style callback function.\r\n * @memberof util\r\n * @param {asPromiseCallback} fn Function to call\r\n * @param {} ctx Function context\r\n @param {...} params Function arguments\r\n @returns {Promise<>} Promisified function\r\n /\r\nfunction asPromise(fn, ctx/, varargs /) {\r\n var params = new Array(arguments.length - 1),\r\n offset = 0,\r\n index = 2,\r\n pending = true;\r\n while (index < arguments.length)\r\n params[offset++] = arguments[index++];\r\n return new Promise(function executor(resolve, reject) {\r\n params[offset] = function callback(err/, varargs /) {\r\n if (pending) {\r\n pending = false;\r\n if (err)\r\n reject(err);\r\n else {\r\n var params = new Array(arguments.length - 1),\r\n offset = 0;\r\n while (offset < params.length)\r\n params[offset++] = arguments[offset];\r\n resolve.apply(null, params);\r\n }\r\n }\r\n };\r\n try {\r\n fn.apply(ctx \|\| null, params);\r\n } catch (err) {\r\n if (pending) {\r\n pending = false;\r\n reject(err);\r\n }\r\n }\r\n });\r\n}\r\n","\"use strict\";\r\n\r\n/*\r\n A minimal base64 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n /\r\nvar base64 = exports;\r\n\r\n/\r\n Calculates the byte length of a base64 encoded string.\r\n * @param {string} string Base64 encoded string\r\n * @returns {number} Byte length\r\n /\r\nbase64.length = function length(string) {\r\n var p = string.length;\r\n if (!p)\r\n return 0;\r\n var n = 0;\r\n while (--p % 4 > 1 && string.charAt(p) === \"=\")\r\n ++n;\r\n return Math.ceil(string.length 3) / 4 - n;\r\n};\r\n\r\n// Base64 encoding table\r\nvar b64 = new Array(64);\r\n\r\n// Base64 decoding table\r\nvar s64 = new Array(123);\r\n\r\n// 65..90, 97..122, 48..57, 43, 47\r\nfor (var i = 0; i < 64;)\r\n s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 \| 43] = i++;\r\n\r\n/*\r\n Encodes a buffer to a base64 encoded string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} Base64 encoded string\r\n /\r\nbase64.encode = function encode(buffer, start, end) {\r\n var parts = null,\r\n chunk = [];\r\n var i = 0, // output index\r\n j = 0, // goto index\r\n t; // temporary\r\n while (start < end) {\r\n var b = buffer[start++];\r\n switch (j) {\r\n case 0:\r\n chunk[i++] = b64[b >> 2];\r\n t = (b & 3) << 4;\r\n j = 1;\r\n break;\r\n case 1:\r\n chunk[i++] = b64[t \| b >> 4];\r\n t = (b & 15) << 2;\r\n j = 2;\r\n break;\r\n case 2:\r\n chunk[i++] = b64[t \| b >> 6];\r\n chunk[i++] = b64[b & 63];\r\n j = 0;\r\n break;\r\n }\r\n if (i > 8191) {\r\n (parts \|\| (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n i = 0;\r\n }\r\n }\r\n if (j) {\r\n chunk[i++] = b64[t];\r\n chunk[i++] = 61;\r\n if (j === 1)\r\n chunk[i++] = 61;\r\n }\r\n if (parts) {\r\n if (i)\r\n parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n return parts.join(\"\");\r\n }\r\n return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\nvar invalidEncoding = \"invalid encoding\";\r\n\r\n/\r\n Decodes a base64 encoded string to a buffer.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Number of bytes written\r\n * @throws {Error} If encoding is invalid\r\n /\r\nbase64.decode = function decode(string, buffer, offset) {\r\n var start = offset;\r\n var j = 0, // goto index\r\n t; // temporary\r\n for (var i = 0; i < string.length;) {\r\n var c = string.charCodeAt(i++);\r\n if (c === 61 && j > 1)\r\n break;\r\n if ((c = s64[c]) === undefined)\r\n throw Error(invalidEncoding);\r\n switch (j) {\r\n case 0:\r\n t = c;\r\n j = 1;\r\n break;\r\n case 1:\r\n buffer[offset++] = t << 2 \| (c & 48) >> 4;\r\n t = c;\r\n j = 2;\r\n break;\r\n case 2:\r\n buffer[offset++] = (t & 15) << 4 \| (c & 60) >> 2;\r\n t = c;\r\n j = 3;\r\n break;\r\n case 3:\r\n buffer[offset++] = (t & 3) << 6 \| c;\r\n j = 0;\r\n break;\r\n }\r\n }\r\n if (j === 1)\r\n throw Error(invalidEncoding);\r\n return offset - start;\r\n};\r\n\r\n/\r\n Tests if the specified string appears to be base64 encoded.\r\n * @param {string} string String to test\r\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\r\n /\r\nbase64.test = function test(string) {\r\n return /^(?:[A-Za-z0-9+/]{4})(?:[A-Za-z0-9+/]{2}==\|[A-Za-z0-9+/]{3}=)?$/.test(string);\r\n};\r\n","\"use strict\";\r\nmodule.exports = EventEmitter;\r\n\r\n/*\r\n Constructs a new event emitter instance.\r\n * @classdesc A minimal event emitter.\r\n * @memberof util\r\n * @constructor\r\n /\r\nfunction EventEmitter() {\r\n\r\n /\r\n Registered listeners.\r\n * @type {Object.<string,>}\r\n @private\r\n /\r\n this._listeners = Object.create(null);\r\n}\r\n\r\n/\r\n Event listener as used by {@link util.EventEmitter}.\r\n * @typedef EventEmitterListener\r\n * @type {function}\r\n * @param {...} args Arguments\r\n @returns {undefined}\r\n /\r\n\r\n/\r\n Registers an event listener.\r\n * @param {string} evt Event name\r\n * @param {EventEmitterListener} fn Listener\r\n * @param {} [ctx] Listener context\r\n @returns {this} `this`\r\n /\r\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\r\n (this._listeners[evt] \|\| (this._listeners[evt] = [])).push({\r\n fn : fn,\r\n ctx : ctx \|\| this\r\n });\r\n return this;\r\n};\r\n\r\n/\r\n Removes an event listener or any matching listeners if arguments are omitted.\r\n * @param {string} [evt] Event name. Removes all listeners if omitted.\r\n * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\r\n * @returns {this} `this`\r\n /\r\nEventEmitter.prototype.off = function off(evt, fn) {\r\n if (evt === undefined)\r\n this._listeners = Object.create(null);\r\n else {\r\n if (fn === undefined)\r\n this._listeners[evt] = [];\r\n else {\r\n var listeners = this._listeners[evt];\r\n if (!listeners)\r\n return this;\r\n for (var i = 0; i < listeners.length;)\r\n if (listeners[i].fn === fn)\r\n listeners.splice(i, 1);\r\n else\r\n ++i;\r\n }\r\n }\r\n return this;\r\n};\r\n\r\n/\r\n Emits an event by calling its listeners with the specified arguments.\r\n * @param {string} evt Event name\r\n * @param {...} args Arguments\r\n @returns {this} `this`\r\n /\r\nEventEmitter.prototype.emit = function emit(evt) {\r\n var listeners = this._listeners[evt];\r\n if (listeners) {\r\n var args = [],\r\n i = 1;\r\n for (; i < arguments.length;)\r\n args.push(arguments[i++]);\r\n for (i = 0; i < listeners.length;)\r\n listeners[i].fn.apply(listeners[i++].ctx, args);\r\n }\r\n return this;\r\n};\r\n","\"use strict\";\r\n\r\nmodule.exports = factory(factory);\r\n\r\n/\r\n Reads / writes floats / doubles from / to buffers.\r\n * @name util.float\r\n * @namespace\r\n /\r\n\r\n/\r\n Writes a 32 bit float to a buffer using little endian byte order.\r\n * @name util.float.writeFloatLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n /\r\n\r\n/\r\n Writes a 32 bit float to a buffer using big endian byte order.\r\n * @name util.float.writeFloatBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n /\r\n\r\n/\r\n Reads a 32 bit float from a buffer using little endian byte order.\r\n * @name util.float.readFloatLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n /\r\n\r\n/\r\n Reads a 32 bit float from a buffer using big endian byte order.\r\n * @name util.float.readFloatBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n /\r\n\r\n/\r\n Writes a 64 bit double to a buffer using little endian byte order.\r\n * @name util.float.writeDoubleLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n /\r\n\r\n/\r\n Writes a 64 bit double to a buffer using big endian byte order.\r\n * @name util.float.writeDoubleBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n /\r\n\r\n/\r\n Reads a 64 bit double from a buffer using little endian byte order.\r\n * @name util.float.readDoubleLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n /\r\n\r\n/\r\n Reads a 64 bit double from a buffer using big endian byte order.\r\n * @name util.float.readDoubleBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n /\r\n\r\n// Factory function for the purpose of node-based testing in modified global environments\r\nfunction factory(exports) {\r\n\r\n // float: typed array\r\n if (typeof Float32Array !== \"undefined\") (function() {\r\n\r\n var f32 = new Float32Array([ -0 ]),\r\n f8b = new Uint8Array(f32.buffer),\r\n le = f8b[3] === 128;\r\n\r\n function writeFloat_f32_cpy(val, buf, pos) {\r\n f32[0] = val;\r\n buf[pos ] = f8b[0];\r\n buf[pos + 1] = f8b[1];\r\n buf[pos + 2] = f8b[2];\r\n buf[pos + 3] = f8b[3];\r\n }\r\n\r\n function writeFloat_f32_rev(val, buf, pos) {\r\n f32[0] = val;\r\n buf[pos ] = f8b[3];\r\n buf[pos + 1] = f8b[2];\r\n buf[pos + 2] = f8b[1];\r\n buf[pos + 3] = f8b[0];\r\n }\r\n\r\n / istanbul ignore next /\r\n exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r\n / istanbul ignore next /\r\n exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r\n\r\n function readFloat_f32_cpy(buf, pos) {\r\n f8b[0] = buf[pos ];\r\n f8b[1] = buf[pos + 1];\r\n f8b[2] = buf[pos + 2];\r\n f8b[3] = buf[pos + 3];\r\n return f32[0];\r\n }\r\n\r\n function readFloat_f32_rev(buf, pos) {\r\n f8b[3] = buf[pos ];\r\n f8b[2] = buf[pos + 1];\r\n f8b[1] = buf[pos + 2];\r\n f8b[0] = buf[pos + 3];\r\n return f32[0];\r\n }\r\n\r\n / istanbul ignore next /\r\n exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r\n / istanbul ignore next /\r\n exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r\n\r\n // float: ieee754\r\n })(); else (function() {\r\n\r\n function writeFloat_ieee754(writeUint, val, buf, pos) {\r\n var sign = val < 0 ? 1 : 0;\r\n if (sign)\r\n val = -val;\r\n if (val === 0)\r\n writeUint(1 / val > 0 ? / positive / 0 : / negative 0 / 2147483648, buf, pos);\r\n else if (isNaN(val))\r\n writeUint(2143289344, buf, pos);\r\n else if (val > 3.4028234663852886e+38) // +-Infinity\r\n writeUint((sign << 31 \| 2139095040) >>> 0, buf, pos);\r\n else if (val < 1.1754943508222875e-38) // denormal\r\n writeUint((sign << 31 \| Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r\n else {\r\n var exponent = Math.floor(Math.log(val) / Math.LN2),\r\n mantissa = Math.round(val Math.pow(2, -exponent) * 8388608) & 8388607;\r\n writeUint((sign << 31 \| exponent + 127 << 23 \| mantissa) >>> 0, buf, pos);\r\n }\r\n }\r\n\r\n exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r\n exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r\n\r\n function readFloat_ieee754(readUint, buf, pos) {\r\n var uint = readUint(buf, pos),\r\n sign = (uint >> 31) * 2 + 1,\r\n exponent = uint >>> 23 & 255,\r\n mantissa = uint & 8388607;\r\n return exponent === 255\r\n ? mantissa\r\n ? NaN\r\n : sign * Infinity\r\n : exponent === 0 // denormal\r\n ? sign * 1.401298464324817e-45 * mantissa\r\n : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r\n }\r\n\r\n exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r\n exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r\n\r\n })();\r\n\r\n // double: typed array\r\n if (typeof Float64Array !== \"undefined\") (function() {\r\n\r\n var f64 = new Float64Array([-0]),\r\n f8b = new Uint8Array(f64.buffer),\r\n le = f8b[7] === 128;\r\n\r\n function writeDouble_f64_cpy(val, buf, pos) {\r\n f64[0] = val;\r\n buf[pos ] = f8b[0];\r\n buf[pos + 1] = f8b[1];\r\n buf[pos + 2] = f8b[2];\r\n buf[pos + 3] = f8b[3];\r\n buf[pos + 4] = f8b[4];\r\n buf[pos + 5] = f8b[5];\r\n buf[pos + 6] = f8b[6];\r\n buf[pos + 7] = f8b[7];\r\n }\r\n\r\n function writeDouble_f64_rev(val, buf, pos) {\r\n f64[0] = val;\r\n buf[pos ] = f8b[7];\r\n buf[pos + 1] = f8b[6];\r\n buf[pos + 2] = f8b[5];\r\n buf[pos + 3] = f8b[4];\r\n buf[pos + 4] = f8b[3];\r\n buf[pos + 5] = f8b[2];\r\n buf[pos + 6] = f8b[1];\r\n buf[pos + 7] = f8b[0];\r\n }\r\n\r\n /* istanbul ignore next /\r\n exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r\n / istanbul ignore next /\r\n exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r\n\r\n function readDouble_f64_cpy(buf, pos) {\r\n f8b[0] = buf[pos ];\r\n f8b[1] = buf[pos + 1];\r\n f8b[2] = buf[pos + 2];\r\n f8b[3] = buf[pos + 3];\r\n f8b[4] = buf[pos + 4];\r\n f8b[5] = buf[pos + 5];\r\n f8b[6] = buf[pos + 6];\r\n f8b[7] = buf[pos + 7];\r\n return f64[0];\r\n }\r\n\r\n function readDouble_f64_rev(buf, pos) {\r\n f8b[7] = buf[pos ];\r\n f8b[6] = buf[pos + 1];\r\n f8b[5] = buf[pos + 2];\r\n f8b[4] = buf[pos + 3];\r\n f8b[3] = buf[pos + 4];\r\n f8b[2] = buf[pos + 5];\r\n f8b[1] = buf[pos + 6];\r\n f8b[0] = buf[pos + 7];\r\n return f64[0];\r\n }\r\n\r\n / istanbul ignore next /\r\n exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r\n / istanbul ignore next /\r\n exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r\n\r\n // double: ieee754\r\n })(); else (function() {\r\n\r\n function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r\n var sign = val < 0 ? 1 : 0;\r\n if (sign)\r\n val = -val;\r\n if (val === 0) {\r\n writeUint(0, buf, pos + off0);\r\n writeUint(1 / val > 0 ? / positive / 0 : / negative 0 / 2147483648, buf, pos + off1);\r\n } else if (isNaN(val)) {\r\n writeUint(0, buf, pos + off0);\r\n writeUint(2146959360, buf, pos + off1);\r\n } else if (val > 1.7976931348623157e+308) { // +-Infinity\r\n writeUint(0, buf, pos + off0);\r\n writeUint((sign << 31 \| 2146435072) >>> 0, buf, pos + off1);\r\n } else {\r\n var mantissa;\r\n if (val < 2.2250738585072014e-308) { // denormal\r\n mantissa = val / 5e-324;\r\n writeUint(mantissa >>> 0, buf, pos + off0);\r\n writeUint((sign << 31 \| mantissa / 4294967296) >>> 0, buf, pos + off1);\r\n } else {\r\n var exponent = Math.floor(Math.log(val) / Math.LN2);\r\n if (exponent === 1024)\r\n exponent = 1023;\r\n mantissa = val Math.pow(2, -exponent);\r\n writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r\n writeUint((sign << 31 \| exponent + 1023 << 20 \| mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r\n }\r\n }\r\n }\r\n\r\n exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r\n exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r\n\r\n function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r\n var lo = readUint(buf, pos + off0),\r\n hi = readUint(buf, pos + off1);\r\n var sign = (hi >> 31) * 2 + 1,\r\n exponent = hi >>> 20 & 2047,\r\n mantissa = 4294967296 * (hi & 1048575) + lo;\r\n return exponent === 2047\r\n ? mantissa\r\n ? NaN\r\n : sign * Infinity\r\n : exponent === 0 // denormal\r\n ? sign * 5e-324 * mantissa\r\n : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r\n }\r\n\r\n exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r\n exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r\n\r\n })();\r\n\r\n return exports;\r\n}\r\n\r\n// uint helpers\r\n\r\nfunction writeUintLE(val, buf, pos) {\r\n buf[pos ] = val & 255;\r\n buf[pos + 1] = val >>> 8 & 255;\r\n buf[pos + 2] = val >>> 16 & 255;\r\n buf[pos + 3] = val >>> 24;\r\n}\r\n\r\nfunction writeUintBE(val, buf, pos) {\r\n buf[pos ] = val >>> 24;\r\n buf[pos + 1] = val >>> 16 & 255;\r\n buf[pos + 2] = val >>> 8 & 255;\r\n buf[pos + 3] = val & 255;\r\n}\r\n\r\nfunction readUintLE(buf, pos) {\r\n return (buf[pos ]\r\n \| buf[pos + 1] << 8\r\n \| buf[pos + 2] << 16\r\n \| buf[pos + 3] << 24) >>> 0;\r\n}\r\n\r\nfunction readUintBE(buf, pos) {\r\n return (buf[pos ] << 24\r\n \| buf[pos + 1] << 16\r\n \| buf[pos + 2] << 8\r\n \| buf[pos + 3]) >>> 0;\r\n}\r\n","\"use strict\";\r\nmodule.exports = inquire;\r\n\r\n/*\r\n Requires a module only if available.\r\n * @memberof util\r\n * @param {string} moduleName Module to require\r\n * @returns {?Object} Required module if available and not empty, otherwise `null`\r\n * @deprecated Legacy optional require helper. Will be removed in a future release.\r\n /\r\nfunction inquire(moduleName) {\r\n try {\r\n if (typeof require !== \"function\") {\r\n return null;\r\n }\r\n var mod = require(moduleName);\r\n if (mod && (mod.length \|\| Object.keys(mod).length)) return mod;\r\n return null;\r\n } catch (err) {\r\n // ignore\r\n return null;\r\n }\r\n}\r\n\r\n/\r\n// maybe worth a shot to prevent renaming issues:\r\n// see: https://github.com/webpack/webpack/blob/master/lib/dependencies/CommonJsRequireDependencyParserPlugin.js\r\n// triggers on:\r\n// - expression require.cache\r\n// - expression require (???)\r\n// - call require\r\n// - call require:commonjs:item\r\n// - call require:commonjs:context\r\n\r\nObject.defineProperty(Function.prototype, \"__self\", { get: function() { return this; } });\r\nvar r = require.__self;\r\ndelete Function.prototype.__self;\r\n/\r\n","\"use strict\";\r\nmodule.exports = pool;\r\n\r\n/\r\n An allocator as used by {@link util.pool}.\r\n * @typedef PoolAllocator\r\n * @type {function}\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n /\r\n\r\n/\r\n A slicer as used by {@link util.pool}.\r\n * @typedef PoolSlicer\r\n * @type {function}\r\n * @param {number} start Start offset\r\n * @param {number} end End offset\r\n * @returns {Uint8Array} Buffer slice\r\n * @this {Uint8Array}\r\n /\r\n\r\n/\r\n A general purpose buffer pool.\r\n * @memberof util\r\n * @function\r\n * @param {PoolAllocator} alloc Allocator\r\n * @param {PoolSlicer} slice Slicer\r\n * @param {number} [size=8192] Slab size\r\n * @returns {PoolAllocator} Pooled allocator\r\n /\r\nfunction pool(alloc, slice, size) {\r\n var SIZE = size \|\| 8192;\r\n var MAX = SIZE >>> 1;\r\n var slab = null;\r\n var offset = SIZE;\r\n return function pool_alloc(size) {\r\n if (size < 1 \|\| size > MAX)\r\n return alloc(size);\r\n if (offset + size > SIZE) {\r\n slab = alloc(SIZE);\r\n offset = 0;\r\n }\r\n var buf = slice.call(slab, offset, offset += size);\r\n if (offset & 7) // align to 32 bit\r\n offset = (offset \| 7) + 1;\r\n return buf;\r\n };\r\n}\r\n","\"use strict\";\r\n\r\n/\r\n A minimal UTF8 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n /\r\nvar utf8 = exports,\r\n replacementChar = \"\\ufffd\";\r\n\r\n/\r\n Calculates the UTF8 byte length of a string.\r\n * @param {string} string String\r\n * @returns {number} Byte length\r\n /\r\nutf8.length = function utf8_length(string) {\r\n var len = 0,\r\n c = 0;\r\n for (var i = 0; i < string.length; ++i) {\r\n c = string.charCodeAt(i);\r\n if (c < 128)\r\n len += 1;\r\n else if (c < 2048)\r\n len += 2;\r\n else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\r\n ++i;\r\n len += 4;\r\n } else\r\n len += 3;\r\n }\r\n return len;\r\n};\r\n\r\n/\r\n Reads UTF8 bytes as a string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} String read\r\n /\r\nutf8.read = function utf8_read(buffer, start, end) {\r\n if (end - start < 1) {\r\n return \"\";\r\n }\r\n\r\n var str = \"\";\r\n for (var i = start; i < end;) {\r\n var t = buffer[i++];\r\n if (t <= 0x7F) {\r\n str += String.fromCharCode(t);\r\n } else if (t >= 0xC0 && t < 0xE0) {\r\n var c2 = (t & 0x1F) << 6 \| buffer[i++] & 0x3F;\r\n str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;\r\n } else if (t >= 0xE0 && t < 0xF0) {\r\n var c3 = (t & 0xF) << 12 \| (buffer[i++] & 0x3F) << 6 \| buffer[i++] & 0x3F;\r\n str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;\r\n } else if (t >= 0xF0) {\r\n var t2 = (t & 7) << 18 \| (buffer[i++] & 0x3F) << 12 \| (buffer[i++] & 0x3F) << 6 \| buffer[i++] & 0x3F;\r\n if (t2 < 0x10000 \|\| t2 > 0x10FFFF)\r\n str += replacementChar;\r\n else {\r\n t2 -= 0x10000;\r\n str += String.fromCharCode(0xD800 + (t2 >> 10));\r\n str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));\r\n }\r\n }\r\n }\r\n\r\n return str;\r\n};\r\n\r\n/\r\n Writes a string as UTF8 bytes.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Bytes written\r\n /\r\nutf8.write = function utf8_write(string, buffer, offset) {\r\n var start = offset,\r\n c1, // character 1\r\n c2; // character 2\r\n for (var i = 0; i < string.length; ++i) {\r\n c1 = string.charCodeAt(i);\r\n if (c1 < 128) {\r\n buffer[offset++] = c1;\r\n } else if (c1 < 2048) {\r\n buffer[offset++] = c1 >> 6 \| 192;\r\n buffer[offset++] = c1 & 63 \| 128;\r\n } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\r\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\r\n ++i;\r\n buffer[offset++] = c1 >> 18 \| 240;\r\n buffer[offset++] = c1 >> 12 & 63 \| 128;\r\n buffer[offset++] = c1 >> 6 & 63 \| 128;\r\n buffer[offset++] = c1 & 63 \| 128;\r\n } else {\r\n buffer[offset++] = c1 >> 12 \| 224;\r\n buffer[offset++] = c1 >> 6 & 63 \| 128;\r\n buffer[offset++] = c1 & 63 \| 128;\r\n }\r\n }\r\n return offset - start;\r\n};\r\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(16);\nprotobuf.BufferWriter = require(17);\nprotobuf.Reader = require(9);\nprotobuf.BufferReader = require(10);\n\n// Utility\nprotobuf.util = require(15);\nprotobuf.rpc = require(12);\nprotobuf.roots = require(11);\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","\"use strict\";\nmodule.exports = Reader;\n\nvar util = require(15);\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 Recursion limit.\n * @type {number}\n /\nReader.recursionLimit = util.recursionLimit;\n\n/\n Skips the next element of the specified wire type.\n * @param {number} wireType Wire type received\n * @param {number} [depth] Depth of recursion to control nested calls; 0 if omitted\n * @returns {Reader} `this`\n /\nReader.prototype.skipType = function(wireType, depth) {\n if (depth === undefined) depth = 0;\n if (depth > Reader.recursionLimit)\n throw Error(\"maximum nesting depth exceeded\");\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, depth + 1);\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(9);\n(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;\n\nvar util = require(15);\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 = Object.create(null);\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\";\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(13);\n","\"use strict\";\nmodule.exports = Service;\n\nvar util = require(15);\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\";\nmodule.exports = LongBits;\n\nvar util = require(15);\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(1);\n\n// converts to / from base64 encoded strings\nutil.base64 = require(2);\n\n// base class of rpc.Service\nutil.EventEmitter = require(3);\n\n// float handling accross browsers\nutil.float = require(4);\n\n// requires modules optionally and hides the call from bundlers\nutil.inquire = require(5);\n\n// converts to / from utf8 encoded strings\nutil.utf8 = require(7);\n\n// provides a node-like buffer pool in the browser\nutil.pool = require(6);\n\n// utility to work with the low and high bits of a 64 bit value\nutil.LongBits = require(14);\n\n/\n Tests if the specified key can affect object prototypes.\n * @memberof util\n * @param {string} key Key to test\n * @returns {boolean} `true` if the key is unsafe\n /\nfunction isUnsafeProperty(key) {\n return key === \"__proto__\" \|\| key === \"prototype\" \|\| key === \"constructor\";\n}\n\nutil.isUnsafeProperty = isUnsafeProperty;\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 && Object.hasOwnProperty.call(obj, prop)) // eslint-disable-line eqeqeq\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.global.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 \|\| (function() {\n try {\n var Long = require(\"long\");\n return Long && Long.isLong ? Long : null;\n } catch (e) {\n / istanbul ignore next /\n return null;\n }\n })();\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,>\|boolean)} src Source objects, optionally followed by an `ifNotSet` flag\n @returns {Object.<string,>} Destination object\n /\nfunction merge(dst) { // used by converters\n var ifNotSet = typeof arguments[arguments.length - 1] === \"boolean\",\n limit = ifNotSet ? arguments.length - 1 : arguments.length;\n ifNotSet = ifNotSet && arguments[arguments.length - 1];\n for (var a = 1; a < limit; ++a) {\n var src = arguments[a];\n if (!src)\n continue;\n for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)\n if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === undefined \|\| !ifNotSet))\n dst[keys[i]] = src[keys[i]];\n }\n return dst;\n}\n\nutil.merge = merge;\n\n/*\n Schema declaration nesting limit.\n * @memberof util\n * @type {number}\n /\nutil.nestingLimit = 32; // protoc: MaxMessageDeclarationNestingDepth\n\n/\n Recursion limit.\n * @memberof util\n * @type {number}\n /\nutil.recursionLimit = 100; // protoc: CodedInputStream::default_recursion_limit_\n\n/\n Makes a property safe for assignment as an own property.\n * @memberof util\n * @param {Object.<string,>} obj Object\n @param {string} key Property key\n * @returns {undefined}\n /\nutil.makeProp = function makeProp(obj, key) {\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n writable: true\n });\n};\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(15);\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) < 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 var lo = val.lo,\n hi = val.hi;\n while (hi) {\n buf[pos++] = lo & 127 \| 128;\n lo = (lo >>> 7 \| hi << 25) >>> 0;\n hi >>>= 7;\n }\n while (lo > 127) {\n buf[pos++] = lo & 127 \| 128;\n lo = lo >>> 7;\n }\n buf[pos++] = 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(16);\n(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;\n\nvar util = require(15);\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"],"sourceRoot":"."}