--- /dev/null
+/*!
+ * protobuf.js v6.10.0 (c) 2016, daniel wirtz
+ * compiled wed, 15 jul 2020 23:34:13 utc
+ * licensed under the bsd-3-clause license
+ * see: https://github.com/dcodeio/protobuf.js for details
+ */
+(function(undefined){"use strict";(function prelude(modules, cache, entries) {
+
+ // This is the prelude used to bundle protobuf.js for the browser. Wraps up the CommonJS
+ // sources through a conflict-free require shim and is again wrapped within an iife that
+ // provides a minification-friendly `undefined` var plus a global "use strict" directive
+ // so that minification can remove the directives of each module.
+
+ function $require(name) {
+ var $module = cache[name];
+ if (!$module)
+ modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);
+ return $module.exports;
+ }
+
+ var protobuf = $require(entries[0]);
+
+ // Expose globally
+ protobuf.util.global.protobuf = protobuf;
+
+ // Be nice to AMD
+ if (typeof define === "function" && define.amd)
+ define(["long"], function(Long) {
+ if (Long && Long.isLong) {
+ protobuf.util.Long = Long;
+ protobuf.configure();
+ }
+ return protobuf;
+ });
+
+ // Be nice to CommonJS
+ if (typeof module === "object" && module && module.exports)
+ module.exports = protobuf;
+
+})/* end of prelude */({1:[function(require,module,exports){
+"use strict";\r
+module.exports = asPromise;\r
+\r
+/**\r
+ * Callback as used by {@link util.asPromise}.\r
+ * @typedef asPromiseCallback\r
+ * @type {function}\r
+ * @param {Error|null} error Error, if any\r
+ * @param {...*} params Additional arguments\r
+ * @returns {undefined}\r
+ */\r
+\r
+/**\r
+ * Returns a promise from a node-style callback function.\r
+ * @memberof util\r
+ * @param {asPromiseCallback} fn Function to call\r
+ * @param {*} ctx Function context\r
+ * @param {...*} params Function arguments\r
+ * @returns {Promise<*>} Promisified function\r
+ */\r
+function asPromise(fn, ctx/*, varargs */) {\r
+ var params = new Array(arguments.length - 1),\r
+ offset = 0,\r
+ index = 2,\r
+ pending = true;\r
+ while (index < arguments.length)\r
+ params[offset++] = arguments[index++];\r
+ return new Promise(function executor(resolve, reject) {\r
+ params[offset] = function callback(err/*, varargs */) {\r
+ if (pending) {\r
+ pending = false;\r
+ if (err)\r
+ reject(err);\r
+ else {\r
+ var params = new Array(arguments.length - 1),\r
+ offset = 0;\r
+ while (offset < params.length)\r
+ params[offset++] = arguments[offset];\r
+ resolve.apply(null, params);\r
+ }\r
+ }\r
+ };\r
+ try {\r
+ fn.apply(ctx || null, params);\r
+ } catch (err) {\r
+ if (pending) {\r
+ pending = false;\r
+ reject(err);\r
+ }\r
+ }\r
+ });\r
+}\r
+
+},{}],2:[function(require,module,exports){
+"use strict";\r
+\r
+/**\r
+ * A minimal base64 implementation for number arrays.\r
+ * @memberof util\r
+ * @namespace\r
+ */\r
+var base64 = exports;\r
+\r
+/**\r
+ * Calculates the byte length of a base64 encoded string.\r
+ * @param {string} string Base64 encoded string\r
+ * @returns {number} Byte length\r
+ */\r
+base64.length = function length(string) {\r
+ var p = string.length;\r
+ if (!p)\r
+ return 0;\r
+ var n = 0;\r
+ while (--p % 4 > 1 && string.charAt(p) === "=")\r
+ ++n;\r
+ return Math.ceil(string.length * 3) / 4 - n;\r
+};\r
+\r
+// Base64 encoding table\r
+var b64 = new Array(64);\r
+\r
+// Base64 decoding table\r
+var s64 = new Array(123);\r
+\r
+// 65..90, 97..122, 48..57, 43, 47\r
+for (var i = 0; i < 64;)\r
+ s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;\r
+\r
+/**\r
+ * Encodes a buffer to a base64 encoded string.\r
+ * @param {Uint8Array} buffer Source buffer\r
+ * @param {number} start Source start\r
+ * @param {number} end Source end\r
+ * @returns {string} Base64 encoded string\r
+ */\r
+base64.encode = function encode(buffer, start, end) {\r
+ var parts = null,\r
+ chunk = [];\r
+ var i = 0, // output index\r
+ j = 0, // goto index\r
+ t; // temporary\r
+ while (start < end) {\r
+ var b = buffer[start++];\r
+ switch (j) {\r
+ case 0:\r
+ chunk[i++] = b64[b >> 2];\r
+ t = (b & 3) << 4;\r
+ j = 1;\r
+ break;\r
+ case 1:\r
+ chunk[i++] = b64[t | b >> 4];\r
+ t = (b & 15) << 2;\r
+ j = 2;\r
+ break;\r
+ case 2:\r
+ chunk[i++] = b64[t | b >> 6];\r
+ chunk[i++] = b64[b & 63];\r
+ j = 0;\r
+ break;\r
+ }\r
+ if (i > 8191) {\r
+ (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r
+ i = 0;\r
+ }\r
+ }\r
+ if (j) {\r
+ chunk[i++] = b64[t];\r
+ chunk[i++] = 61;\r
+ if (j === 1)\r
+ chunk[i++] = 61;\r
+ }\r
+ if (parts) {\r
+ if (i)\r
+ parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r
+ return parts.join("");\r
+ }\r
+ return String.fromCharCode.apply(String, chunk.slice(0, i));\r
+};\r
+\r
+var invalidEncoding = "invalid encoding";\r
+\r
+/**\r
+ * Decodes a base64 encoded string to a buffer.\r
+ * @param {string} string Source string\r
+ * @param {Uint8Array} buffer Destination buffer\r
+ * @param {number} offset Destination offset\r
+ * @returns {number} Number of bytes written\r
+ * @throws {Error} If encoding is invalid\r
+ */\r
+base64.decode = function decode(string, buffer, offset) {\r
+ var start = offset;\r
+ var j = 0, // goto index\r
+ t; // temporary\r
+ for (var i = 0; i < string.length;) {\r
+ var c = string.charCodeAt(i++);\r
+ if (c === 61 && j > 1)\r
+ break;\r
+ if ((c = s64[c]) === undefined)\r
+ throw Error(invalidEncoding);\r
+ switch (j) {\r
+ case 0:\r
+ t = c;\r
+ j = 1;\r
+ break;\r
+ case 1:\r
+ buffer[offset++] = t << 2 | (c & 48) >> 4;\r
+ t = c;\r
+ j = 2;\r
+ break;\r
+ case 2:\r
+ buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;\r
+ t = c;\r
+ j = 3;\r
+ break;\r
+ case 3:\r
+ buffer[offset++] = (t & 3) << 6 | c;\r
+ j = 0;\r
+ break;\r
+ }\r
+ }\r
+ if (j === 1)\r
+ throw Error(invalidEncoding);\r
+ return offset - start;\r
+};\r
+\r
+/**\r
+ * Tests if the specified string appears to be base64 encoded.\r
+ * @param {string} string String to test\r
+ * @returns {boolean} `true` if probably base64 encoded, otherwise false\r
+ */\r
+base64.test = function test(string) {\r
+ return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);\r
+};\r
+
+},{}],3:[function(require,module,exports){
+"use strict";\r
+module.exports = EventEmitter;\r
+\r
+/**\r
+ * Constructs a new event emitter instance.\r
+ * @classdesc A minimal event emitter.\r
+ * @memberof util\r
+ * @constructor\r
+ */\r
+function EventEmitter() {\r
+\r
+ /**\r
+ * Registered listeners.\r
+ * @type {Object.<string,*>}\r
+ * @private\r
+ */\r
+ this._listeners = {};\r
+}\r
+\r
+/**\r
+ * Registers an event listener.\r
+ * @param {string} evt Event name\r
+ * @param {function} fn Listener\r
+ * @param {*} [ctx] Listener context\r
+ * @returns {util.EventEmitter} `this`\r
+ */\r
+EventEmitter.prototype.on = function on(evt, fn, ctx) {\r
+ (this._listeners[evt] || (this._listeners[evt] = [])).push({\r
+ fn : fn,\r
+ ctx : ctx || this\r
+ });\r
+ return this;\r
+};\r
+\r
+/**\r
+ * Removes an event listener or any matching listeners if arguments are omitted.\r
+ * @param {string} [evt] Event name. Removes all listeners if omitted.\r
+ * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\r
+ * @returns {util.EventEmitter} `this`\r
+ */\r
+EventEmitter.prototype.off = function off(evt, fn) {\r
+ if (evt === undefined)\r
+ this._listeners = {};\r
+ else {\r
+ if (fn === undefined)\r
+ this._listeners[evt] = [];\r
+ else {\r
+ var listeners = this._listeners[evt];\r
+ for (var i = 0; i < listeners.length;)\r
+ if (listeners[i].fn === fn)\r
+ listeners.splice(i, 1);\r
+ else\r
+ ++i;\r
+ }\r
+ }\r
+ return this;\r
+};\r
+\r
+/**\r
+ * Emits an event by calling its listeners with the specified arguments.\r
+ * @param {string} evt Event name\r
+ * @param {...*} args Arguments\r
+ * @returns {util.EventEmitter} `this`\r
+ */\r
+EventEmitter.prototype.emit = function emit(evt) {\r
+ var listeners = this._listeners[evt];\r
+ if (listeners) {\r
+ var args = [],\r
+ i = 1;\r
+ for (; i < arguments.length;)\r
+ args.push(arguments[i++]);\r
+ for (i = 0; i < listeners.length;)\r
+ listeners[i].fn.apply(listeners[i++].ctx, args);\r
+ }\r
+ return this;\r
+};\r
+
+},{}],4:[function(require,module,exports){
+"use strict";\r
+\r
+module.exports = factory(factory);\r
+\r
+/**\r
+ * Reads / writes floats / doubles from / to buffers.\r
+ * @name util.float\r
+ * @namespace\r
+ */\r
+\r
+/**\r
+ * Writes a 32 bit float to a buffer using little endian byte order.\r
+ * @name util.float.writeFloatLE\r
+ * @function\r
+ * @param {number} val Value to write\r
+ * @param {Uint8Array} buf Target buffer\r
+ * @param {number} pos Target buffer offset\r
+ * @returns {undefined}\r
+ */\r
+\r
+/**\r
+ * Writes a 32 bit float to a buffer using big endian byte order.\r
+ * @name util.float.writeFloatBE\r
+ * @function\r
+ * @param {number} val Value to write\r
+ * @param {Uint8Array} buf Target buffer\r
+ * @param {number} pos Target buffer offset\r
+ * @returns {undefined}\r
+ */\r
+\r
+/**\r
+ * Reads a 32 bit float from a buffer using little endian byte order.\r
+ * @name util.float.readFloatLE\r
+ * @function\r
+ * @param {Uint8Array} buf Source buffer\r
+ * @param {number} pos Source buffer offset\r
+ * @returns {number} Value read\r
+ */\r
+\r
+/**\r
+ * Reads a 32 bit float from a buffer using big endian byte order.\r
+ * @name util.float.readFloatBE\r
+ * @function\r
+ * @param {Uint8Array} buf Source buffer\r
+ * @param {number} pos Source buffer offset\r
+ * @returns {number} Value read\r
+ */\r
+\r
+/**\r
+ * Writes a 64 bit double to a buffer using little endian byte order.\r
+ * @name util.float.writeDoubleLE\r
+ * @function\r
+ * @param {number} val Value to write\r
+ * @param {Uint8Array} buf Target buffer\r
+ * @param {number} pos Target buffer offset\r
+ * @returns {undefined}\r
+ */\r
+\r
+/**\r
+ * Writes a 64 bit double to a buffer using big endian byte order.\r
+ * @name util.float.writeDoubleBE\r
+ * @function\r
+ * @param {number} val Value to write\r
+ * @param {Uint8Array} buf Target buffer\r
+ * @param {number} pos Target buffer offset\r
+ * @returns {undefined}\r
+ */\r
+\r
+/**\r
+ * Reads a 64 bit double from a buffer using little endian byte order.\r
+ * @name util.float.readDoubleLE\r
+ * @function\r
+ * @param {Uint8Array} buf Source buffer\r
+ * @param {number} pos Source buffer offset\r
+ * @returns {number} Value read\r
+ */\r
+\r
+/**\r
+ * Reads a 64 bit double from a buffer using big endian byte order.\r
+ * @name util.float.readDoubleBE\r
+ * @function\r
+ * @param {Uint8Array} buf Source buffer\r
+ * @param {number} pos Source buffer offset\r
+ * @returns {number} Value read\r
+ */\r
+\r
+// Factory function for the purpose of node-based testing in modified global environments\r
+function factory(exports) {\r
+\r
+ // float: typed array\r
+ if (typeof Float32Array !== "undefined") (function() {\r
+\r
+ var f32 = new Float32Array([ -0 ]),\r
+ f8b = new Uint8Array(f32.buffer),\r
+ le = f8b[3] === 128;\r
+\r
+ function writeFloat_f32_cpy(val, buf, pos) {\r
+ f32[0] = val;\r
+ buf[pos ] = f8b[0];\r
+ buf[pos + 1] = f8b[1];\r
+ buf[pos + 2] = f8b[2];\r
+ buf[pos + 3] = f8b[3];\r
+ }\r
+\r
+ function writeFloat_f32_rev(val, buf, pos) {\r
+ f32[0] = val;\r
+ buf[pos ] = f8b[3];\r
+ buf[pos + 1] = f8b[2];\r
+ buf[pos + 2] = f8b[1];\r
+ buf[pos + 3] = f8b[0];\r
+ }\r
+\r
+ /* istanbul ignore next */\r
+ exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r
+ /* istanbul ignore next */\r
+ exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r
+\r
+ function readFloat_f32_cpy(buf, pos) {\r
+ f8b[0] = buf[pos ];\r
+ f8b[1] = buf[pos + 1];\r
+ f8b[2] = buf[pos + 2];\r
+ f8b[3] = buf[pos + 3];\r
+ return f32[0];\r
+ }\r
+\r
+ function readFloat_f32_rev(buf, pos) {\r
+ f8b[3] = buf[pos ];\r
+ f8b[2] = buf[pos + 1];\r
+ f8b[1] = buf[pos + 2];\r
+ f8b[0] = buf[pos + 3];\r
+ return f32[0];\r
+ }\r
+\r
+ /* istanbul ignore next */\r
+ exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r
+ /* istanbul ignore next */\r
+ exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r
+\r
+ // float: ieee754\r
+ })(); else (function() {\r
+\r
+ function writeFloat_ieee754(writeUint, val, buf, pos) {\r
+ var sign = val < 0 ? 1 : 0;\r
+ if (sign)\r
+ val = -val;\r
+ if (val === 0)\r
+ writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\r
+ else if (isNaN(val))\r
+ writeUint(2143289344, buf, pos);\r
+ else if (val > 3.4028234663852886e+38) // +-Infinity\r
+ writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\r
+ else if (val < 1.1754943508222875e-38) // denormal\r
+ writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r
+ else {\r
+ var exponent = Math.floor(Math.log(val) / Math.LN2),\r
+ mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\r
+ writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\r
+ }\r
+ }\r
+\r
+ exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r
+ exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r
+\r
+ function readFloat_ieee754(readUint, buf, pos) {\r
+ var uint = readUint(buf, pos),\r
+ sign = (uint >> 31) * 2 + 1,\r
+ exponent = uint >>> 23 & 255,\r
+ mantissa = uint & 8388607;\r
+ return exponent === 255\r
+ ? mantissa\r
+ ? NaN\r
+ : sign * Infinity\r
+ : exponent === 0 // denormal\r
+ ? sign * 1.401298464324817e-45 * mantissa\r
+ : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r
+ }\r
+\r
+ exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r
+ exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r
+\r
+ })();\r
+\r
+ // double: typed array\r
+ if (typeof Float64Array !== "undefined") (function() {\r
+\r
+ var f64 = new Float64Array([-0]),\r
+ f8b = new Uint8Array(f64.buffer),\r
+ le = f8b[7] === 128;\r
+\r
+ function writeDouble_f64_cpy(val, buf, pos) {\r
+ f64[0] = val;\r
+ buf[pos ] = f8b[0];\r
+ buf[pos + 1] = f8b[1];\r
+ buf[pos + 2] = f8b[2];\r
+ buf[pos + 3] = f8b[3];\r
+ buf[pos + 4] = f8b[4];\r
+ buf[pos + 5] = f8b[5];\r
+ buf[pos + 6] = f8b[6];\r
+ buf[pos + 7] = f8b[7];\r
+ }\r
+\r
+ function writeDouble_f64_rev(val, buf, pos) {\r
+ f64[0] = val;\r
+ buf[pos ] = f8b[7];\r
+ buf[pos + 1] = f8b[6];\r
+ buf[pos + 2] = f8b[5];\r
+ buf[pos + 3] = f8b[4];\r
+ buf[pos + 4] = f8b[3];\r
+ buf[pos + 5] = f8b[2];\r
+ buf[pos + 6] = f8b[1];\r
+ buf[pos + 7] = f8b[0];\r
+ }\r
+\r
+ /* istanbul ignore next */\r
+ exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r
+ /* istanbul ignore next */\r
+ exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r
+\r
+ function readDouble_f64_cpy(buf, pos) {\r
+ f8b[0] = buf[pos ];\r
+ f8b[1] = buf[pos + 1];\r
+ f8b[2] = buf[pos + 2];\r
+ f8b[3] = buf[pos + 3];\r
+ f8b[4] = buf[pos + 4];\r
+ f8b[5] = buf[pos + 5];\r
+ f8b[6] = buf[pos + 6];\r
+ f8b[7] = buf[pos + 7];\r
+ return f64[0];\r
+ }\r
+\r
+ function readDouble_f64_rev(buf, pos) {\r
+ f8b[7] = buf[pos ];\r
+ f8b[6] = buf[pos + 1];\r
+ f8b[5] = buf[pos + 2];\r
+ f8b[4] = buf[pos + 3];\r
+ f8b[3] = buf[pos + 4];\r
+ f8b[2] = buf[pos + 5];\r
+ f8b[1] = buf[pos + 6];\r
+ f8b[0] = buf[pos + 7];\r
+ return f64[0];\r
+ }\r
+\r
+ /* istanbul ignore next */\r
+ exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r
+ /* istanbul ignore next */\r
+ exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r
+\r
+ // double: ieee754\r
+ })(); else (function() {\r
+\r
+ function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r
+ var sign = val < 0 ? 1 : 0;\r
+ if (sign)\r
+ val = -val;\r
+ if (val === 0) {\r
+ writeUint(0, buf, pos + off0);\r
+ writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\r
+ } else if (isNaN(val)) {\r
+ writeUint(0, buf, pos + off0);\r
+ writeUint(2146959360, buf, pos + off1);\r
+ } else if (val > 1.7976931348623157e+308) { // +-Infinity\r
+ writeUint(0, buf, pos + off0);\r
+ writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\r
+ } else {\r
+ var mantissa;\r
+ if (val < 2.2250738585072014e-308) { // denormal\r
+ mantissa = val / 5e-324;\r
+ writeUint(mantissa >>> 0, buf, pos + off0);\r
+ writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\r
+ } else {\r
+ var exponent = Math.floor(Math.log(val) / Math.LN2);\r
+ if (exponent === 1024)\r
+ exponent = 1023;\r
+ mantissa = val * Math.pow(2, -exponent);\r
+ writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r
+ writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r
+ }\r
+ }\r
+ }\r
+\r
+ exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r
+ exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r
+\r
+ function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r
+ var lo = readUint(buf, pos + off0),\r
+ hi = readUint(buf, pos + off1);\r
+ var sign = (hi >> 31) * 2 + 1,\r
+ exponent = hi >>> 20 & 2047,\r
+ mantissa = 4294967296 * (hi & 1048575) + lo;\r
+ return exponent === 2047\r
+ ? mantissa\r
+ ? NaN\r
+ : sign * Infinity\r
+ : exponent === 0 // denormal\r
+ ? sign * 5e-324 * mantissa\r
+ : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r
+ }\r
+\r
+ exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r
+ exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r
+\r
+ })();\r
+\r
+ return exports;\r
+}\r
+\r
+// uint helpers\r
+\r
+function writeUintLE(val, buf, pos) {\r
+ buf[pos ] = val & 255;\r
+ buf[pos + 1] = val >>> 8 & 255;\r
+ buf[pos + 2] = val >>> 16 & 255;\r
+ buf[pos + 3] = val >>> 24;\r
+}\r
+\r
+function writeUintBE(val, buf, pos) {\r
+ buf[pos ] = val >>> 24;\r
+ buf[pos + 1] = val >>> 16 & 255;\r
+ buf[pos + 2] = val >>> 8 & 255;\r
+ buf[pos + 3] = val & 255;\r
+}\r
+\r
+function readUintLE(buf, pos) {\r
+ return (buf[pos ]\r
+ | buf[pos + 1] << 8\r
+ | buf[pos + 2] << 16\r
+ | buf[pos + 3] << 24) >>> 0;\r
+}\r
+\r
+function readUintBE(buf, pos) {\r
+ return (buf[pos ] << 24\r
+ | buf[pos + 1] << 16\r
+ | buf[pos + 2] << 8\r
+ | buf[pos + 3]) >>> 0;\r
+}\r
+
+},{}],5:[function(require,module,exports){
+"use strict";\r
+module.exports = inquire;\r
+\r
+/**\r
+ * Requires a module only if available.\r
+ * @memberof util\r
+ * @param {string} moduleName Module to require\r
+ * @returns {?Object} Required module if available and not empty, otherwise `null`\r
+ */\r
+function inquire(moduleName) {\r
+ try {\r
+ var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval\r
+ if (mod && (mod.length || Object.keys(mod).length))\r
+ return mod;\r
+ } catch (e) {} // eslint-disable-line no-empty\r
+ return null;\r
+}\r
+
+},{}],6:[function(require,module,exports){
+"use strict";\r
+module.exports = pool;\r
+\r
+/**\r
+ * An allocator as used by {@link util.pool}.\r
+ * @typedef PoolAllocator\r
+ * @type {function}\r
+ * @param {number} size Buffer size\r
+ * @returns {Uint8Array} Buffer\r
+ */\r
+\r
+/**\r
+ * A slicer as used by {@link util.pool}.\r
+ * @typedef PoolSlicer\r
+ * @type {function}\r
+ * @param {number} start Start offset\r
+ * @param {number} end End offset\r
+ * @returns {Uint8Array} Buffer slice\r
+ * @this {Uint8Array}\r
+ */\r
+\r
+/**\r
+ * A general purpose buffer pool.\r
+ * @memberof util\r
+ * @function\r
+ * @param {PoolAllocator} alloc Allocator\r
+ * @param {PoolSlicer} slice Slicer\r
+ * @param {number} [size=8192] Slab size\r
+ * @returns {PoolAllocator} Pooled allocator\r
+ */\r
+function pool(alloc, slice, size) {\r
+ var SIZE = size || 8192;\r
+ var MAX = SIZE >>> 1;\r
+ var slab = null;\r
+ var offset = SIZE;\r
+ return function pool_alloc(size) {\r
+ if (size < 1 || size > MAX)\r
+ return alloc(size);\r
+ if (offset + size > SIZE) {\r
+ slab = alloc(SIZE);\r
+ offset = 0;\r
+ }\r
+ var buf = slice.call(slab, offset, offset += size);\r
+ if (offset & 7) // align to 32 bit\r
+ offset = (offset | 7) + 1;\r
+ return buf;\r
+ };\r
+}\r
+
+},{}],7:[function(require,module,exports){
+"use strict";\r
+\r
+/**\r
+ * A minimal UTF8 implementation for number arrays.\r
+ * @memberof util\r
+ * @namespace\r
+ */\r
+var utf8 = exports;\r
+\r
+/**\r
+ * Calculates the UTF8 byte length of a string.\r
+ * @param {string} string String\r
+ * @returns {number} Byte length\r
+ */\r
+utf8.length = function utf8_length(string) {\r
+ var len = 0,\r
+ c = 0;\r
+ for (var i = 0; i < string.length; ++i) {\r
+ c = string.charCodeAt(i);\r
+ if (c < 128)\r
+ len += 1;\r
+ else if (c < 2048)\r
+ len += 2;\r
+ else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\r
+ ++i;\r
+ len += 4;\r
+ } else\r
+ len += 3;\r
+ }\r
+ return len;\r
+};\r
+\r
+/**\r
+ * Reads UTF8 bytes as a string.\r
+ * @param {Uint8Array} buffer Source buffer\r
+ * @param {number} start Source start\r
+ * @param {number} end Source end\r
+ * @returns {string} String read\r
+ */\r
+utf8.read = function utf8_read(buffer, start, end) {\r
+ var len = end - start;\r
+ if (len < 1)\r
+ return "";\r
+ var parts = null,\r
+ chunk = [],\r
+ i = 0, // char offset\r
+ t; // temporary\r
+ while (start < end) {\r
+ t = buffer[start++];\r
+ if (t < 128)\r
+ chunk[i++] = t;\r
+ else if (t > 191 && t < 224)\r
+ chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;\r
+ else if (t > 239 && t < 365) {\r
+ t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;\r
+ chunk[i++] = 0xD800 + (t >> 10);\r
+ chunk[i++] = 0xDC00 + (t & 1023);\r
+ } else\r
+ chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;\r
+ if (i > 8191) {\r
+ (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r
+ i = 0;\r
+ }\r
+ }\r
+ if (parts) {\r
+ if (i)\r
+ parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r
+ return parts.join("");\r
+ }\r
+ return String.fromCharCode.apply(String, chunk.slice(0, i));\r
+};\r
+\r
+/**\r
+ * Writes a string as UTF8 bytes.\r
+ * @param {string} string Source string\r
+ * @param {Uint8Array} buffer Destination buffer\r
+ * @param {number} offset Destination offset\r
+ * @returns {number} Bytes written\r
+ */\r
+utf8.write = function utf8_write(string, buffer, offset) {\r
+ var start = offset,\r
+ c1, // character 1\r
+ c2; // character 2\r
+ for (var i = 0; i < string.length; ++i) {\r
+ c1 = string.charCodeAt(i);\r
+ if (c1 < 128) {\r
+ buffer[offset++] = c1;\r
+ } else if (c1 < 2048) {\r
+ buffer[offset++] = c1 >> 6 | 192;\r
+ buffer[offset++] = c1 & 63 | 128;\r
+ } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\r
+ c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\r
+ ++i;\r
+ buffer[offset++] = c1 >> 18 | 240;\r
+ buffer[offset++] = c1 >> 12 & 63 | 128;\r
+ buffer[offset++] = c1 >> 6 & 63 | 128;\r
+ buffer[offset++] = c1 & 63 | 128;\r
+ } else {\r
+ buffer[offset++] = c1 >> 12 | 224;\r
+ buffer[offset++] = c1 >> 6 & 63 | 128;\r
+ buffer[offset++] = c1 & 63 | 128;\r
+ }\r
+ }\r
+ return offset - start;\r
+};\r
+
+},{}],8:[function(require,module,exports){
+"use strict";
+var protobuf = exports;
+
+/**
+ * Build type, one of `"full"`, `"light"` or `"minimal"`.
+ * @name build
+ * @type {string}
+ * @const
+ */
+protobuf.build = "minimal";
+
+// Serialization
+protobuf.Writer = require(16);
+protobuf.BufferWriter = require(17);
+protobuf.Reader = require(9);
+protobuf.BufferReader = require(10);
+
+// Utility
+protobuf.util = require(15);
+protobuf.rpc = require(12);
+protobuf.roots = require(11);
+protobuf.configure = configure;
+
+/* istanbul ignore next */
+/**
+ * Reconfigures the library according to the environment.
+ * @returns {undefined}
+ */
+function configure() {
+ protobuf.util._configure();
+ protobuf.Writer._configure(protobuf.BufferWriter);
+ protobuf.Reader._configure(protobuf.BufferReader);
+}
+
+// Set up buffer utility according to the environment
+configure();
+
+},{"10":10,"11":11,"12":12,"15":15,"16":16,"17":17,"9":9}],9:[function(require,module,exports){
+"use strict";
+module.exports = Reader;
+
+var util = require(15);
+
+var BufferReader; // cyclic
+
+var LongBits = util.LongBits,
+ utf8 = util.utf8;
+
+/* istanbul ignore next */
+function indexOutOfRange(reader, writeLength) {
+ return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+}
+
+/**
+ * Constructs a new reader instance using the specified buffer.
+ * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
+ * @constructor
+ * @param {Uint8Array} buffer Buffer to read from
+ */
+function Reader(buffer) {
+
+ /**
+ * Read buffer.
+ * @type {Uint8Array}
+ */
+ this.buf = buffer;
+
+ /**
+ * Read buffer position.
+ * @type {number}
+ */
+ this.pos = 0;
+
+ /**
+ * Read buffer length.
+ * @type {number}
+ */
+ this.len = buffer.length;
+}
+
+var create_array = typeof Uint8Array !== "undefined"
+ ? function create_typed_array(buffer) {
+ if (buffer instanceof Uint8Array || Array.isArray(buffer))
+ return new Reader(buffer);
+ throw Error("illegal buffer");
+ }
+ /* istanbul ignore next */
+ : function create_array(buffer) {
+ if (Array.isArray(buffer))
+ return new Reader(buffer);
+ throw Error("illegal buffer");
+ };
+
+var create = function create() {
+ return util.Buffer
+ ? function create_buffer_setup(buffer) {
+ return (Reader.create = function create_buffer(buffer) {
+ return util.Buffer.isBuffer(buffer)
+ ? new BufferReader(buffer)
+ /* istanbul ignore next */
+ : create_array(buffer);
+ })(buffer);
+ }
+ /* istanbul ignore next */
+ : create_array;
+};
+
+/**
+ * Creates a new reader using the specified buffer.
+ * @function
+ * @param {Uint8Array|Buffer} buffer Buffer to read from
+ * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
+ * @throws {Error} If `buffer` is not a valid buffer
+ */
+Reader.create = create();
+
+Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;
+
+/**
+ * Reads a varint as an unsigned 32 bit value.
+ * @function
+ * @returns {number} Value read
+ */
+Reader.prototype.uint32 = (function read_uint32_setup() {
+ var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
+ return function read_uint32() {
+ value = ( this.buf[this.pos] & 127 ) >>> 0; if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 127) << 7) >>> 0; if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;
+ value = (value | (this.buf[this.pos] & 15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;
+
+ /* istanbul ignore if */
+ if ((this.pos += 5) > this.len) {
+ this.pos = this.len;
+ throw indexOutOfRange(this, 10);
+ }
+ return value;
+ };
+})();
+
+/**
+ * Reads a varint as a signed 32 bit value.
+ * @returns {number} Value read
+ */
+Reader.prototype.int32 = function read_int32() {
+ return this.uint32() | 0;
+};
+
+/**
+ * Reads a zig-zag encoded varint as a signed 32 bit value.
+ * @returns {number} Value read
+ */
+Reader.prototype.sint32 = function read_sint32() {
+ var value = this.uint32();
+ return value >>> 1 ^ -(value & 1) | 0;
+};
+
+/* eslint-disable no-invalid-this */
+
+function readLongVarint() {
+ // tends to deopt with local vars for octet etc.
+ var bits = new LongBits(0, 0);
+ var i = 0;
+ if (this.len - this.pos > 4) { // fast route (lo)
+ for (; i < 4; ++i) {
+ // 1st..4th
+ bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+ if (this.buf[this.pos++] < 128)
+ return bits;
+ }
+ // 5th
+ bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+ bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+ if (this.buf[this.pos++] < 128)
+ return bits;
+ i = 0;
+ } else {
+ for (; i < 3; ++i) {
+ /* istanbul ignore if */
+ if (this.pos >= this.len)
+ throw indexOutOfRange(this);
+ // 1st..3th
+ bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+ if (this.buf[this.pos++] < 128)
+ return bits;
+ }
+ // 4th
+ bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+ return bits;
+ }
+ if (this.len - this.pos > 4) { // fast route (hi)
+ for (; i < 5; ++i) {
+ // 6th..10th
+ bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+ if (this.buf[this.pos++] < 128)
+ return bits;
+ }
+ } else {
+ for (; i < 5; ++i) {
+ /* istanbul ignore if */
+ if (this.pos >= this.len)
+ throw indexOutOfRange(this);
+ // 6th..10th
+ bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+ if (this.buf[this.pos++] < 128)
+ return bits;
+ }
+ }
+ /* istanbul ignore next */
+ throw Error("invalid varint encoding");
+}
+
+/* eslint-enable no-invalid-this */
+
+/**
+ * Reads a varint as a signed 64 bit value.
+ * @name Reader#int64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a varint as an unsigned 64 bit value.
+ * @name Reader#uint64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a zig-zag encoded varint as a signed 64 bit value.
+ * @name Reader#sint64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a varint as a boolean.
+ * @returns {boolean} Value read
+ */
+Reader.prototype.bool = function read_bool() {
+ return this.uint32() !== 0;
+};
+
+function readFixed32_end(buf, end) { // note that this uses `end`, not `pos`
+ return (buf[end - 4]
+ | buf[end - 3] << 8
+ | buf[end - 2] << 16
+ | buf[end - 1] << 24) >>> 0;
+}
+
+/**
+ * Reads fixed 32 bits as an unsigned 32 bit integer.
+ * @returns {number} Value read
+ */
+Reader.prototype.fixed32 = function read_fixed32() {
+
+ /* istanbul ignore if */
+ if (this.pos + 4 > this.len)
+ throw indexOutOfRange(this, 4);
+
+ return readFixed32_end(this.buf, this.pos += 4);
+};
+
+/**
+ * Reads fixed 32 bits as a signed 32 bit integer.
+ * @returns {number} Value read
+ */
+Reader.prototype.sfixed32 = function read_sfixed32() {
+
+ /* istanbul ignore if */
+ if (this.pos + 4 > this.len)
+ throw indexOutOfRange(this, 4);
+
+ return readFixed32_end(this.buf, this.pos += 4) | 0;
+};
+
+/* eslint-disable no-invalid-this */
+
+function readFixed64(/* this: Reader */) {
+
+ /* istanbul ignore if */
+ if (this.pos + 8 > this.len)
+ throw indexOutOfRange(this, 8);
+
+ return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
+}
+
+/* eslint-enable no-invalid-this */
+
+/**
+ * Reads fixed 64 bits.
+ * @name Reader#fixed64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads zig-zag encoded fixed 64 bits.
+ * @name Reader#sfixed64
+ * @function
+ * @returns {Long} Value read
+ */
+
+/**
+ * Reads a float (32 bit) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+Reader.prototype.float = function read_float() {
+
+ /* istanbul ignore if */
+ if (this.pos + 4 > this.len)
+ throw indexOutOfRange(this, 4);
+
+ var value = util.float.readFloatLE(this.buf, this.pos);
+ this.pos += 4;
+ return value;
+};
+
+/**
+ * Reads a double (64 bit float) as a number.
+ * @function
+ * @returns {number} Value read
+ */
+Reader.prototype.double = function read_double() {
+
+ /* istanbul ignore if */
+ if (this.pos + 8 > this.len)
+ throw indexOutOfRange(this, 4);
+
+ var value = util.float.readDoubleLE(this.buf, this.pos);
+ this.pos += 8;
+ return value;
+};
+
+/**
+ * Reads a sequence of bytes preceeded by its length as a varint.
+ * @returns {Uint8Array} Value read
+ */
+Reader.prototype.bytes = function read_bytes() {
+ var length = this.uint32(),
+ start = this.pos,
+ end = this.pos + length;
+
+ /* istanbul ignore if */
+ if (end > this.len)
+ throw indexOutOfRange(this, length);
+
+ this.pos += length;
+ if (Array.isArray(this.buf)) // plain array
+ return this.buf.slice(start, end);
+ return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
+ ? new this.buf.constructor(0)
+ : this._slice.call(this.buf, start, end);
+};
+
+/**
+ * Reads a string preceeded by its byte length as a varint.
+ * @returns {string} Value read
+ */
+Reader.prototype.string = function read_string() {
+ var bytes = this.bytes();
+ return utf8.read(bytes, 0, bytes.length);
+};
+
+/**
+ * Skips the specified number of bytes if specified, otherwise skips a varint.
+ * @param {number} [length] Length if known, otherwise a varint is assumed
+ * @returns {Reader} `this`
+ */
+Reader.prototype.skip = function skip(length) {
+ if (typeof length === "number") {
+ /* istanbul ignore if */
+ if (this.pos + length > this.len)
+ throw indexOutOfRange(this, length);
+ this.pos += length;
+ } else {
+ do {
+ /* istanbul ignore if */
+ if (this.pos >= this.len)
+ throw indexOutOfRange(this);
+ } while (this.buf[this.pos++] & 128);
+ }
+ return this;
+};
+
+/**
+ * Skips the next element of the specified wire type.
+ * @param {number} wireType Wire type received
+ * @returns {Reader} `this`
+ */
+Reader.prototype.skipType = function(wireType) {
+ switch (wireType) {
+ case 0:
+ this.skip();
+ break;
+ case 1:
+ this.skip(8);
+ break;
+ case 2:
+ this.skip(this.uint32());
+ break;
+ case 3:
+ while ((wireType = this.uint32() & 7) !== 4) {
+ this.skipType(wireType);
+ }
+ break;
+ case 5:
+ this.skip(4);
+ break;
+
+ /* istanbul ignore next */
+ default:
+ throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+ }
+ return this;
+};
+
+Reader._configure = function(BufferReader_) {
+ BufferReader = BufferReader_;
+ Reader.create = create();
+ BufferReader._configure();
+
+ var fn = util.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
+ util.merge(Reader.prototype, {
+
+ int64: function read_int64() {
+ return readLongVarint.call(this)[fn](false);
+ },
+
+ uint64: function read_uint64() {
+ return readLongVarint.call(this)[fn](true);
+ },
+
+ sint64: function read_sint64() {
+ return readLongVarint.call(this).zzDecode()[fn](false);
+ },
+
+ fixed64: function read_fixed64() {
+ return readFixed64.call(this)[fn](true);
+ },
+
+ sfixed64: function read_sfixed64() {
+ return readFixed64.call(this)[fn](false);
+ }
+
+ });
+};
+
+},{"15":15}],10:[function(require,module,exports){
+"use strict";
+module.exports = BufferReader;
+
+// extends Reader
+var Reader = require(9);
+(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+
+var util = require(15);
+
+/**
+ * Constructs a new buffer reader instance.
+ * @classdesc Wire format reader using node buffers.
+ * @extends Reader
+ * @constructor
+ * @param {Buffer} buffer Buffer to read from
+ */
+function BufferReader(buffer) {
+ Reader.call(this, buffer);
+
+ /**
+ * Read buffer.
+ * @name BufferReader#buf
+ * @type {Buffer}
+ */
+}
+
+BufferReader._configure = function () {
+ /* istanbul ignore else */
+ if (util.Buffer)
+ BufferReader.prototype._slice = util.Buffer.prototype.slice;
+};
+
+
+/**
+ * @override
+ */
+BufferReader.prototype.string = function read_string_buffer() {
+ var len = this.uint32(); // modifies pos
+ return this.buf.utf8Slice
+ ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))
+ : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
+};
+
+/**
+ * Reads a sequence of bytes preceeded by its length as a varint.
+ * @name BufferReader#bytes
+ * @function
+ * @returns {Buffer} Value read
+ */
+
+BufferReader._configure();
+
+},{"15":15,"9":9}],11:[function(require,module,exports){
+"use strict";
+module.exports = {};
+
+/**
+ * Named roots.
+ * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
+ * Can also be used manually to make roots available accross modules.
+ * @name roots
+ * @type {Object.<string,Root>}
+ * @example
+ * // pbjs -r myroot -o compiled.js ...
+ *
+ * // in another module:
+ * require("./compiled.js");
+ *
+ * // in any subsequent module:
+ * var root = protobuf.roots["myroot"];
+ */
+
+},{}],12:[function(require,module,exports){
+"use strict";
+
+/**
+ * Streaming RPC helpers.
+ * @namespace
+ */
+var rpc = exports;
+
+/**
+ * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
+ * @typedef RPCImpl
+ * @type {function}
+ * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called
+ * @param {Uint8Array} requestData Request data
+ * @param {RPCImplCallback} callback Callback function
+ * @returns {undefined}
+ * @example
+ * function rpcImpl(method, requestData, callback) {
+ * if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
+ * throw Error("no such method");
+ * asynchronouslyObtainAResponse(requestData, function(err, responseData) {
+ * callback(err, responseData);
+ * });
+ * }
+ */
+
+/**
+ * Node-style callback as used by {@link RPCImpl}.
+ * @typedef RPCImplCallback
+ * @type {function}
+ * @param {Error|null} error Error, if any, otherwise `null`
+ * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
+ * @returns {undefined}
+ */
+
+rpc.Service = require(13);
+
+},{"13":13}],13:[function(require,module,exports){
+"use strict";
+module.exports = Service;
+
+var util = require(15);
+
+// Extends EventEmitter
+(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+
+/**
+ * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
+ *
+ * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
+ * @typedef rpc.ServiceMethodCallback
+ * @template TRes extends Message<TRes>
+ * @type {function}
+ * @param {Error|null} error Error, if any
+ * @param {TRes} [response] Response message
+ * @returns {undefined}
+ */
+
+/**
+ * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
+ * @typedef rpc.ServiceMethod
+ * @template TReq extends Message<TReq>
+ * @template TRes extends Message<TRes>
+ * @type {function}
+ * @param {TReq|Properties<TReq>} request Request message or plain object
+ * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
+ * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
+ */
+
+/**
+ * Constructs a new RPC service instance.
+ * @classdesc An RPC service as returned by {@link Service#create}.
+ * @exports rpc.Service
+ * @extends util.EventEmitter
+ * @constructor
+ * @param {RPCImpl} rpcImpl RPC implementation
+ * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+ * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+ */
+function Service(rpcImpl, requestDelimited, responseDelimited) {
+
+ if (typeof rpcImpl !== "function")
+ throw TypeError("rpcImpl must be a function");
+
+ util.EventEmitter.call(this);
+
+ /**
+ * RPC implementation. Becomes `null` once the service is ended.
+ * @type {RPCImpl|null}
+ */
+ this.rpcImpl = rpcImpl;
+
+ /**
+ * Whether requests are length-delimited.
+ * @type {boolean}
+ */
+ this.requestDelimited = Boolean(requestDelimited);
+
+ /**
+ * Whether responses are length-delimited.
+ * @type {boolean}
+ */
+ this.responseDelimited = Boolean(responseDelimited);
+}
+
+/**
+ * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
+ * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method
+ * @param {Constructor<TReq>} requestCtor Request constructor
+ * @param {Constructor<TRes>} responseCtor Response constructor
+ * @param {TReq|Properties<TReq>} request Request message or plain object
+ * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback
+ * @returns {undefined}
+ * @template TReq extends Message<TReq>
+ * @template TRes extends Message<TRes>
+ */
+Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
+
+ if (!request)
+ throw TypeError("request must be specified");
+
+ var self = this;
+ if (!callback)
+ return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
+
+ if (!self.rpcImpl) {
+ setTimeout(function() { callback(Error("already ended")); }, 0);
+ return undefined;
+ }
+
+ try {
+ return self.rpcImpl(
+ method,
+ requestCtor[self.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
+ function rpcCallback(err, response) {
+
+ if (err) {
+ self.emit("error", err, method);
+ return callback(err);
+ }
+
+ if (response === null) {
+ self.end(/* endedByRPC */ true);
+ return undefined;
+ }
+
+ if (!(response instanceof responseCtor)) {
+ try {
+ response = responseCtor[self.responseDelimited ? "decodeDelimited" : "decode"](response);
+ } catch (err) {
+ self.emit("error", err, method);
+ return callback(err);
+ }
+ }
+
+ self.emit("data", response, method);
+ return callback(null, response);
+ }
+ );
+ } catch (err) {
+ self.emit("error", err, method);
+ setTimeout(function() { callback(err); }, 0);
+ return undefined;
+ }
+};
+
+/**
+ * Ends this service and emits the `end` event.
+ * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
+ * @returns {rpc.Service} `this`
+ */
+Service.prototype.end = function end(endedByRPC) {
+ if (this.rpcImpl) {
+ if (!endedByRPC) // signal end to rpcImpl
+ this.rpcImpl(null, null, null);
+ this.rpcImpl = null;
+ this.emit("end").off();
+ }
+ return this;
+};
+
+},{"15":15}],14:[function(require,module,exports){
+"use strict";
+module.exports = LongBits;
+
+var util = require(15);
+
+/**
+ * Constructs new long bits.
+ * @classdesc Helper class for working with the low and high bits of a 64 bit value.
+ * @memberof util
+ * @constructor
+ * @param {number} lo Low 32 bits, unsigned
+ * @param {number} hi High 32 bits, unsigned
+ */
+function LongBits(lo, hi) {
+
+ // note that the casts below are theoretically unnecessary as of today, but older statically
+ // generated converter code might still call the ctor with signed 32bits. kept for compat.
+
+ /**
+ * Low bits.
+ * @type {number}
+ */
+ this.lo = lo >>> 0;
+
+ /**
+ * High bits.
+ * @type {number}
+ */
+ this.hi = hi >>> 0;
+}
+
+/**
+ * Zero bits.
+ * @memberof util.LongBits
+ * @type {util.LongBits}
+ */
+var zero = LongBits.zero = new LongBits(0, 0);
+
+zero.toNumber = function() { return 0; };
+zero.zzEncode = zero.zzDecode = function() { return this; };
+zero.length = function() { return 1; };
+
+/**
+ * Zero hash.
+ * @memberof util.LongBits
+ * @type {string}
+ */
+var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
+
+/**
+ * Constructs new long bits from the specified number.
+ * @param {number} value Value
+ * @returns {util.LongBits} Instance
+ */
+LongBits.fromNumber = function fromNumber(value) {
+ if (value === 0)
+ return zero;
+ var sign = value < 0;
+ if (sign)
+ value = -value;
+ var lo = value >>> 0,
+ hi = (value - lo) / 4294967296 >>> 0;
+ if (sign) {
+ hi = ~hi >>> 0;
+ lo = ~lo >>> 0;
+ if (++lo > 4294967295) {
+ lo = 0;
+ if (++hi > 4294967295)
+ hi = 0;
+ }
+ }
+ return new LongBits(lo, hi);
+};
+
+/**
+ * Constructs new long bits from a number, long or string.
+ * @param {Long|number|string} value Value
+ * @returns {util.LongBits} Instance
+ */
+LongBits.from = function from(value) {
+ if (typeof value === "number")
+ return LongBits.fromNumber(value);
+ if (util.isString(value)) {
+ /* istanbul ignore else */
+ if (util.Long)
+ value = util.Long.fromString(value);
+ else
+ return LongBits.fromNumber(parseInt(value, 10));
+ }
+ return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+};
+
+/**
+ * Converts this long bits to a possibly unsafe JavaScript number.
+ * @param {boolean} [unsigned=false] Whether unsigned or not
+ * @returns {number} Possibly unsafe number
+ */
+LongBits.prototype.toNumber = function toNumber(unsigned) {
+ if (!unsigned && this.hi >>> 31) {
+ var lo = ~this.lo + 1 >>> 0,
+ hi = ~this.hi >>> 0;
+ if (!lo)
+ hi = hi + 1 >>> 0;
+ return -(lo + hi * 4294967296);
+ }
+ return this.lo + this.hi * 4294967296;
+};
+
+/**
+ * Converts this long bits to a long.
+ * @param {boolean} [unsigned=false] Whether unsigned or not
+ * @returns {Long} Long
+ */
+LongBits.prototype.toLong = function toLong(unsigned) {
+ return util.Long
+ ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
+ /* istanbul ignore next */
+ : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
+};
+
+var charCodeAt = String.prototype.charCodeAt;
+
+/**
+ * Constructs new long bits from the specified 8 characters long hash.
+ * @param {string} hash Hash
+ * @returns {util.LongBits} Bits
+ */
+LongBits.fromHash = function fromHash(hash) {
+ if (hash === zeroHash)
+ return zero;
+ return new LongBits(
+ ( charCodeAt.call(hash, 0)
+ | charCodeAt.call(hash, 1) << 8
+ | charCodeAt.call(hash, 2) << 16
+ | charCodeAt.call(hash, 3) << 24) >>> 0
+ ,
+ ( charCodeAt.call(hash, 4)
+ | charCodeAt.call(hash, 5) << 8
+ | charCodeAt.call(hash, 6) << 16
+ | charCodeAt.call(hash, 7) << 24) >>> 0
+ );
+};
+
+/**
+ * Converts this long bits to a 8 characters long hash.
+ * @returns {string} Hash
+ */
+LongBits.prototype.toHash = function toHash() {
+ return String.fromCharCode(
+ this.lo & 255,
+ this.lo >>> 8 & 255,
+ this.lo >>> 16 & 255,
+ this.lo >>> 24 ,
+ this.hi & 255,
+ this.hi >>> 8 & 255,
+ this.hi >>> 16 & 255,
+ this.hi >>> 24
+ );
+};
+
+/**
+ * Zig-zag encodes this long bits.
+ * @returns {util.LongBits} `this`
+ */
+LongBits.prototype.zzEncode = function zzEncode() {
+ var mask = this.hi >> 31;
+ this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+ this.lo = ( this.lo << 1 ^ mask) >>> 0;
+ return this;
+};
+
+/**
+ * Zig-zag decodes this long bits.
+ * @returns {util.LongBits} `this`
+ */
+LongBits.prototype.zzDecode = function zzDecode() {
+ var mask = -(this.lo & 1);
+ this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+ this.hi = ( this.hi >>> 1 ^ mask) >>> 0;
+ return this;
+};
+
+/**
+ * Calculates the length of this longbits when encoded as a varint.
+ * @returns {number} Length
+ */
+LongBits.prototype.length = function length() {
+ var part0 = this.lo,
+ part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,
+ part2 = this.hi >>> 24;
+ return part2 === 0
+ ? part1 === 0
+ ? part0 < 16384
+ ? part0 < 128 ? 1 : 2
+ : part0 < 2097152 ? 3 : 4
+ : part1 < 16384
+ ? part1 < 128 ? 5 : 6
+ : part1 < 2097152 ? 7 : 8
+ : part2 < 128 ? 9 : 10;
+};
+
+},{"15":15}],15:[function(require,module,exports){
+"use strict";
+var util = exports;
+
+// used to return a Promise where callback is omitted
+util.asPromise = require(1);
+
+// converts to / from base64 encoded strings
+util.base64 = require(2);
+
+// base class of rpc.Service
+util.EventEmitter = require(3);
+
+// float handling accross browsers
+util.float = require(4);
+
+// requires modules optionally and hides the call from bundlers
+util.inquire = require(5);
+
+// converts to / from utf8 encoded strings
+util.utf8 = require(7);
+
+// provides a node-like buffer pool in the browser
+util.pool = require(6);
+
+// utility to work with the low and high bits of a 64 bit value
+util.LongBits = require(14);
+
+/**
+ * Whether running within node or not.
+ * @memberof util
+ * @type {boolean}
+ */
+util.isNode = Boolean(typeof global !== "undefined"
+ && global
+ && global.process
+ && global.process.versions
+ && global.process.versions.node);
+
+/**
+ * Global object reference.
+ * @memberof util
+ * @type {Object}
+ */
+util.global = util.isNode && global
+ || typeof window !== "undefined" && window
+ || typeof self !== "undefined" && self
+ || this; // eslint-disable-line no-invalid-this
+
+/**
+ * An immuable empty array.
+ * @memberof util
+ * @type {Array.<*>}
+ * @const
+ */
+util.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes
+
+/**
+ * An immutable empty object.
+ * @type {Object}
+ * @const
+ */
+util.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes
+
+/**
+ * Tests if the specified value is an integer.
+ * @function
+ * @param {*} value Value to test
+ * @returns {boolean} `true` if the value is an integer
+ */
+util.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {
+ return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+};
+
+/**
+ * Tests if the specified value is a string.
+ * @param {*} value Value to test
+ * @returns {boolean} `true` if the value is a string
+ */
+util.isString = function isString(value) {
+ return typeof value === "string" || value instanceof String;
+};
+
+/**
+ * Tests if the specified value is a non-null object.
+ * @param {*} value Value to test
+ * @returns {boolean} `true` if the value is a non-null object
+ */
+util.isObject = function isObject(value) {
+ return value && typeof value === "object";
+};
+
+/**
+ * Checks if a property on a message is considered to be present.
+ * This is an alias of {@link util.isSet}.
+ * @function
+ * @param {Object} obj Plain object or message instance
+ * @param {string} prop Property name
+ * @returns {boolean} `true` if considered to be present, otherwise `false`
+ */
+util.isset =
+
+/**
+ * Checks if a property on a message is considered to be present.
+ * @param {Object} obj Plain object or message instance
+ * @param {string} prop Property name
+ * @returns {boolean} `true` if considered to be present, otherwise `false`
+ */
+util.isSet = function isSet(obj, prop) {
+ var value = obj[prop];
+ if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins
+ return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
+ return false;
+};
+
+/**
+ * Any compatible Buffer instance.
+ * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
+ * @interface Buffer
+ * @extends Uint8Array
+ */
+
+/**
+ * Node's Buffer class if available.
+ * @type {Constructor<Buffer>}
+ */
+util.Buffer = (function() {
+ try {
+ var Buffer = util.inquire("buffer").Buffer;
+ // refuse to use non-node buffers if not explicitly assigned (perf reasons):
+ return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
+ } catch (e) {
+ /* istanbul ignore next */
+ return null;
+ }
+})();
+
+// Internal alias of or polyfull for Buffer.from.
+util._Buffer_from = null;
+
+// Internal alias of or polyfill for Buffer.allocUnsafe.
+util._Buffer_allocUnsafe = null;
+
+/**
+ * Creates a new buffer of whatever type supported by the environment.
+ * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
+ * @returns {Uint8Array|Buffer} Buffer
+ */
+util.newBuffer = function newBuffer(sizeOrArray) {
+ /* istanbul ignore next */
+ return typeof sizeOrArray === "number"
+ ? util.Buffer
+ ? util._Buffer_allocUnsafe(sizeOrArray)
+ : new util.Array(sizeOrArray)
+ : util.Buffer
+ ? util._Buffer_from(sizeOrArray)
+ : typeof Uint8Array === "undefined"
+ ? sizeOrArray
+ : new Uint8Array(sizeOrArray);
+};
+
+/**
+ * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
+ * @type {Constructor<Uint8Array>}
+ */
+util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
+
+/**
+ * Any compatible Long instance.
+ * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
+ * @interface Long
+ * @property {number} low Low bits
+ * @property {number} high High bits
+ * @property {boolean} unsigned Whether unsigned or not
+ */
+
+/**
+ * Long.js's Long class if available.
+ * @type {Constructor<Long>}
+ */
+util.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long
+ || /* istanbul ignore next */ util.global.Long
+ || util.inquire("long");
+
+/**
+ * Regular expression used to verify 2 bit (`bool`) map keys.
+ * @type {RegExp}
+ * @const
+ */
+util.key2Re = /^true|false|0|1$/;
+
+/**
+ * Regular expression used to verify 32 bit (`int32` etc.) map keys.
+ * @type {RegExp}
+ * @const
+ */
+util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
+
+/**
+ * Regular expression used to verify 64 bit (`int64` etc.) map keys.
+ * @type {RegExp}
+ * @const
+ */
+util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
+
+/**
+ * Converts a number or long to an 8 characters long hash string.
+ * @param {Long|number} value Value to convert
+ * @returns {string} Hash
+ */
+util.longToHash = function longToHash(value) {
+ return value
+ ? util.LongBits.from(value).toHash()
+ : util.LongBits.zeroHash;
+};
+
+/**
+ * Converts an 8 characters long hash string to a long or number.
+ * @param {string} hash Hash
+ * @param {boolean} [unsigned=false] Whether unsigned or not
+ * @returns {Long|number} Original value
+ */
+util.longFromHash = function longFromHash(hash, unsigned) {
+ var bits = util.LongBits.fromHash(hash);
+ if (util.Long)
+ return util.Long.fromBits(bits.lo, bits.hi, unsigned);
+ return bits.toNumber(Boolean(unsigned));
+};
+
+/**
+ * Merges the properties of the source object into the destination object.
+ * @memberof util
+ * @param {Object.<string,*>} dst Destination object
+ * @param {Object.<string,*>} src Source object
+ * @param {boolean} [ifNotSet=false] Merges only if the key is not already set
+ * @returns {Object.<string,*>} Destination object
+ */
+function merge(dst, src, ifNotSet) { // used by converters
+ for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
+ if (dst[keys[i]] === undefined || !ifNotSet)
+ dst[keys[i]] = src[keys[i]];
+ return dst;
+}
+
+util.merge = merge;
+
+/**
+ * Converts the first character of a string to lower case.
+ * @param {string} str String to convert
+ * @returns {string} Converted string
+ */
+util.lcFirst = function lcFirst(str) {
+ return str.charAt(0).toLowerCase() + str.substring(1);
+};
+
+/**
+ * Creates a custom error constructor.
+ * @memberof util
+ * @param {string} name Error name
+ * @returns {Constructor<Error>} Custom error constructor
+ */
+function newError(name) {
+
+ function CustomError(message, properties) {
+
+ if (!(this instanceof CustomError))
+ return new CustomError(message, properties);
+
+ // Error.call(this, message);
+ // ^ just returns a new error instance because the ctor can be called as a function
+
+ Object.defineProperty(this, "message", { get: function() { return message; } });
+
+ /* istanbul ignore next */
+ if (Error.captureStackTrace) // node
+ Error.captureStackTrace(this, CustomError);
+ else
+ Object.defineProperty(this, "stack", { value: new Error().stack || "" });
+
+ if (properties)
+ merge(this, properties);
+ }
+
+ (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;
+
+ Object.defineProperty(CustomError.prototype, "name", { get: function() { return name; } });
+
+ CustomError.prototype.toString = function toString() {
+ return this.name + ": " + this.message;
+ };
+
+ return CustomError;
+}
+
+util.newError = newError;
+
+/**
+ * Constructs a new protocol error.
+ * @classdesc Error subclass indicating a protocol specifc error.
+ * @memberof util
+ * @extends Error
+ * @template T extends Message<T>
+ * @constructor
+ * @param {string} message Error message
+ * @param {Object.<string,*>} [properties] Additional properties
+ * @example
+ * try {
+ * MyMessage.decode(someBuffer); // throws if required fields are missing
+ * } catch (e) {
+ * if (e instanceof ProtocolError && e.instance)
+ * console.log("decoded so far: " + JSON.stringify(e.instance));
+ * }
+ */
+util.ProtocolError = newError("ProtocolError");
+
+/**
+ * So far decoded message instance.
+ * @name util.ProtocolError#instance
+ * @type {Message<T>}
+ */
+
+/**
+ * A OneOf getter as returned by {@link util.oneOfGetter}.
+ * @typedef OneOfGetter
+ * @type {function}
+ * @returns {string|undefined} Set field name, if any
+ */
+
+/**
+ * Builds a getter for a oneof's present field name.
+ * @param {string[]} fieldNames Field names
+ * @returns {OneOfGetter} Unbound getter
+ */
+util.oneOfGetter = function getOneOf(fieldNames) {
+ var fieldMap = {};
+ for (var i = 0; i < fieldNames.length; ++i)
+ fieldMap[fieldNames[i]] = 1;
+
+ /**
+ * @returns {string|undefined} Set field name, if any
+ * @this Object
+ * @ignore
+ */
+ return function() { // eslint-disable-line consistent-return
+ for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)
+ if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)
+ return keys[i];
+ };
+};
+
+/**
+ * A OneOf setter as returned by {@link util.oneOfSetter}.
+ * @typedef OneOfSetter
+ * @type {function}
+ * @param {string|undefined} value Field name
+ * @returns {undefined}
+ */
+
+/**
+ * Builds a setter for a oneof's present field name.
+ * @param {string[]} fieldNames Field names
+ * @returns {OneOfSetter} Unbound setter
+ */
+util.oneOfSetter = function setOneOf(fieldNames) {
+
+ /**
+ * @param {string} name Field name
+ * @returns {undefined}
+ * @this Object
+ * @ignore
+ */
+ return function(name) {
+ for (var i = 0; i < fieldNames.length; ++i)
+ if (fieldNames[i] !== name)
+ delete this[fieldNames[i]];
+ };
+};
+
+/**
+ * Default conversion options used for {@link Message#toJSON} implementations.
+ *
+ * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
+ *
+ * - Longs become strings
+ * - Enums become string keys
+ * - Bytes become base64 encoded strings
+ * - (Sub-)Messages become plain objects
+ * - Maps become plain objects with all string keys
+ * - Repeated fields become arrays
+ * - NaN and Infinity for float and double fields become strings
+ *
+ * @type {IConversionOptions}
+ * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
+ */
+util.toJSONOptions = {
+ longs: String,
+ enums: String,
+ bytes: String,
+ json: true
+};
+
+// Sets up buffer utility according to the environment (called in index-minimal)
+util._configure = function() {
+ var Buffer = util.Buffer;
+ /* istanbul ignore if */
+ if (!Buffer) {
+ util._Buffer_from = util._Buffer_allocUnsafe = null;
+ return;
+ }
+ // because node 4.x buffers are incompatible & immutable
+ // see: https://github.com/dcodeIO/protobuf.js/pull/665
+ util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
+ /* istanbul ignore next */
+ function Buffer_from(value, encoding) {
+ return new Buffer(value, encoding);
+ };
+ util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
+ /* istanbul ignore next */
+ function Buffer_allocUnsafe(size) {
+ return new Buffer(size);
+ };
+};
+
+},{"1":1,"14":14,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7}],16:[function(require,module,exports){
+"use strict";
+module.exports = Writer;
+
+var util = require(15);
+
+var BufferWriter; // cyclic
+
+var LongBits = util.LongBits,
+ base64 = util.base64,
+ utf8 = util.utf8;
+
+/**
+ * Constructs a new writer operation instance.
+ * @classdesc Scheduled writer operation.
+ * @constructor
+ * @param {function(*, Uint8Array, number)} fn Function to call
+ * @param {number} len Value byte length
+ * @param {*} val Value to write
+ * @ignore
+ */
+function Op(fn, len, val) {
+
+ /**
+ * Function to call.
+ * @type {function(Uint8Array, number, *)}
+ */
+ this.fn = fn;
+
+ /**
+ * Value byte length.
+ * @type {number}
+ */
+ this.len = len;
+
+ /**
+ * Next operation.
+ * @type {Writer.Op|undefined}
+ */
+ this.next = undefined;
+
+ /**
+ * Value to write.
+ * @type {*}
+ */
+ this.val = val; // type varies
+}
+
+/* istanbul ignore next */
+function noop() {} // eslint-disable-line no-empty-function
+
+/**
+ * Constructs a new writer state instance.
+ * @classdesc Copied writer state.
+ * @memberof Writer
+ * @constructor
+ * @param {Writer} writer Writer to copy state from
+ * @ignore
+ */
+function State(writer) {
+
+ /**
+ * Current head.
+ * @type {Writer.Op}
+ */
+ this.head = writer.head;
+
+ /**
+ * Current tail.
+ * @type {Writer.Op}
+ */
+ this.tail = writer.tail;
+
+ /**
+ * Current buffer length.
+ * @type {number}
+ */
+ this.len = writer.len;
+
+ /**
+ * Next state.
+ * @type {State|null}
+ */
+ this.next = writer.states;
+}
+
+/**
+ * Constructs a new writer instance.
+ * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
+ * @constructor
+ */
+function Writer() {
+
+ /**
+ * Current length.
+ * @type {number}
+ */
+ this.len = 0;
+
+ /**
+ * Operations head.
+ * @type {Object}
+ */
+ this.head = new Op(noop, 0, 0);
+
+ /**
+ * Operations tail
+ * @type {Object}
+ */
+ this.tail = this.head;
+
+ /**
+ * Linked forked states.
+ * @type {Object|null}
+ */
+ this.states = null;
+
+ // When a value is written, the writer calculates its byte length and puts it into a linked
+ // list of operations to perform when finish() is called. This both allows us to allocate
+ // buffers of the exact required size and reduces the amount of work we have to do compared
+ // to first calculating over objects and then encoding over objects. In our case, the encoding
+ // part is just a linked list walk calling operations with already prepared values.
+}
+
+var create = function create() {
+ return util.Buffer
+ ? function create_buffer_setup() {
+ return (Writer.create = function create_buffer() {
+ return new BufferWriter();
+ })();
+ }
+ /* istanbul ignore next */
+ : function create_array() {
+ return new Writer();
+ };
+};
+
+/**
+ * Creates a new writer.
+ * @function
+ * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
+ */
+Writer.create = create();
+
+/**
+ * Allocates a buffer of the specified size.
+ * @param {number} size Buffer size
+ * @returns {Uint8Array} Buffer
+ */
+Writer.alloc = function alloc(size) {
+ return new util.Array(size);
+};
+
+// Use Uint8Array buffer pool in the browser, just like node does with buffers
+/* istanbul ignore else */
+if (util.Array !== Array)
+ Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
+
+/**
+ * Pushes a new operation to the queue.
+ * @param {function(Uint8Array, number, *)} fn Function to call
+ * @param {number} len Value byte length
+ * @param {number} val Value to write
+ * @returns {Writer} `this`
+ * @private
+ */
+Writer.prototype._push = function push(fn, len, val) {
+ this.tail = this.tail.next = new Op(fn, len, val);
+ this.len += len;
+ return this;
+};
+
+function writeByte(val, buf, pos) {
+ buf[pos] = val & 255;
+}
+
+function writeVarint32(val, buf, pos) {
+ while (val > 127) {
+ buf[pos++] = val & 127 | 128;
+ val >>>= 7;
+ }
+ buf[pos] = val;
+}
+
+/**
+ * Constructs a new varint writer operation instance.
+ * @classdesc Scheduled varint writer operation.
+ * @extends Op
+ * @constructor
+ * @param {number} len Value byte length
+ * @param {number} val Value to write
+ * @ignore
+ */
+function VarintOp(len, val) {
+ this.len = len;
+ this.next = undefined;
+ this.val = val;
+}
+
+VarintOp.prototype = Object.create(Op.prototype);
+VarintOp.prototype.fn = writeVarint32;
+
+/**
+ * Writes an unsigned 32 bit value as a varint.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.uint32 = function write_uint32(value) {
+ // here, the call to this.push has been inlined and a varint specific Op subclass is used.
+ // uint32 is by far the most frequently used operation and benefits significantly from this.
+ this.len += (this.tail = this.tail.next = new VarintOp(
+ (value = value >>> 0)
+ < 128 ? 1
+ : value < 16384 ? 2
+ : value < 2097152 ? 3
+ : value < 268435456 ? 4
+ : 5,
+ value)).len;
+ return this;
+};
+
+/**
+ * Writes a signed 32 bit value as a varint.
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.int32 = function write_int32(value) {
+ return value < 0
+ ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
+ : this.uint32(value);
+};
+
+/**
+ * Writes a 32 bit value as a varint, zig-zag encoded.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.sint32 = function write_sint32(value) {
+ return this.uint32((value << 1 ^ value >> 31) >>> 0);
+};
+
+function writeVarint64(val, buf, pos) {
+ while (val.hi) {
+ buf[pos++] = val.lo & 127 | 128;
+ val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+ val.hi >>>= 7;
+ }
+ while (val.lo > 127) {
+ buf[pos++] = val.lo & 127 | 128;
+ val.lo = val.lo >>> 7;
+ }
+ buf[pos++] = val.lo;
+}
+
+/**
+ * Writes an unsigned 64 bit value as a varint.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer.prototype.uint64 = function write_uint64(value) {
+ var bits = LongBits.from(value);
+ return this._push(writeVarint64, bits.length(), bits);
+};
+
+/**
+ * Writes a signed 64 bit value as a varint.
+ * @function
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer.prototype.int64 = Writer.prototype.uint64;
+
+/**
+ * Writes a signed 64 bit value as a varint, zig-zag encoded.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer.prototype.sint64 = function write_sint64(value) {
+ var bits = LongBits.from(value).zzEncode();
+ return this._push(writeVarint64, bits.length(), bits);
+};
+
+/**
+ * Writes a boolish value as a varint.
+ * @param {boolean} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.bool = function write_bool(value) {
+ return this._push(writeByte, 1, value ? 1 : 0);
+};
+
+function writeFixed32(val, buf, pos) {
+ buf[pos ] = val & 255;
+ buf[pos + 1] = val >>> 8 & 255;
+ buf[pos + 2] = val >>> 16 & 255;
+ buf[pos + 3] = val >>> 24;
+}
+
+/**
+ * Writes an unsigned 32 bit value as fixed 32 bits.
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.fixed32 = function write_fixed32(value) {
+ return this._push(writeFixed32, 4, value >>> 0);
+};
+
+/**
+ * Writes a signed 32 bit value as fixed 32 bits.
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.sfixed32 = Writer.prototype.fixed32;
+
+/**
+ * Writes an unsigned 64 bit value as fixed 64 bits.
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer.prototype.fixed64 = function write_fixed64(value) {
+ var bits = LongBits.from(value);
+ return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+};
+
+/**
+ * Writes a signed 64 bit value as fixed 64 bits.
+ * @function
+ * @param {Long|number|string} value Value to write
+ * @returns {Writer} `this`
+ * @throws {TypeError} If `value` is a string and no long library is present.
+ */
+Writer.prototype.sfixed64 = Writer.prototype.fixed64;
+
+/**
+ * Writes a float (32 bit).
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.float = function write_float(value) {
+ return this._push(util.float.writeFloatLE, 4, value);
+};
+
+/**
+ * Writes a double (64 bit float).
+ * @function
+ * @param {number} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.double = function write_double(value) {
+ return this._push(util.float.writeDoubleLE, 8, value);
+};
+
+var writeBytes = util.Array.prototype.set
+ ? function writeBytes_set(val, buf, pos) {
+ buf.set(val, pos); // also works for plain array values
+ }
+ /* istanbul ignore next */
+ : function writeBytes_for(val, buf, pos) {
+ for (var i = 0; i < val.length; ++i)
+ buf[pos + i] = val[i];
+ };
+
+/**
+ * Writes a sequence of bytes.
+ * @param {Uint8Array|string} value Buffer or base64 encoded string to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.bytes = function write_bytes(value) {
+ var len = value.length >>> 0;
+ if (!len)
+ return this._push(writeByte, 1, 0);
+ if (util.isString(value)) {
+ var buf = Writer.alloc(len = base64.length(value));
+ base64.decode(value, buf, 0);
+ value = buf;
+ }
+ return this.uint32(len)._push(writeBytes, len, value);
+};
+
+/**
+ * Writes a string.
+ * @param {string} value Value to write
+ * @returns {Writer} `this`
+ */
+Writer.prototype.string = function write_string(value) {
+ var len = utf8.length(value);
+ return len
+ ? this.uint32(len)._push(utf8.write, len, value)
+ : this._push(writeByte, 1, 0);
+};
+
+/**
+ * Forks this writer's state by pushing it to a stack.
+ * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
+ * @returns {Writer} `this`
+ */
+Writer.prototype.fork = function fork() {
+ this.states = new State(this);
+ this.head = this.tail = new Op(noop, 0, 0);
+ this.len = 0;
+ return this;
+};
+
+/**
+ * Resets this instance to the last state.
+ * @returns {Writer} `this`
+ */
+Writer.prototype.reset = function reset() {
+ if (this.states) {
+ this.head = this.states.head;
+ this.tail = this.states.tail;
+ this.len = this.states.len;
+ this.states = this.states.next;
+ } else {
+ this.head = this.tail = new Op(noop, 0, 0);
+ this.len = 0;
+ }
+ return this;
+};
+
+/**
+ * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+ * @returns {Writer} `this`
+ */
+Writer.prototype.ldelim = function ldelim() {
+ var head = this.head,
+ tail = this.tail,
+ len = this.len;
+ this.reset().uint32(len);
+ if (len) {
+ this.tail.next = head.next; // skip noop
+ this.tail = tail;
+ this.len += len;
+ }
+ return this;
+};
+
+/**
+ * Finishes the write operation.
+ * @returns {Uint8Array} Finished buffer
+ */
+Writer.prototype.finish = function finish() {
+ var head = this.head.next, // skip noop
+ buf = this.constructor.alloc(this.len),
+ pos = 0;
+ while (head) {
+ head.fn(head.val, buf, pos);
+ pos += head.len;
+ head = head.next;
+ }
+ // this.head = this.tail = null;
+ return buf;
+};
+
+Writer._configure = function(BufferWriter_) {
+ BufferWriter = BufferWriter_;
+ Writer.create = create();
+ BufferWriter._configure();
+};
+
+},{"15":15}],17:[function(require,module,exports){
+"use strict";
+module.exports = BufferWriter;
+
+// extends Writer
+var Writer = require(16);
+(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
+
+var util = require(15);
+
+/**
+ * Constructs a new buffer writer instance.
+ * @classdesc Wire format writer using node buffers.
+ * @extends Writer
+ * @constructor
+ */
+function BufferWriter() {
+ Writer.call(this);
+}
+
+BufferWriter._configure = function () {
+ /**
+ * Allocates a buffer of the specified size.
+ * @function
+ * @param {number} size Buffer size
+ * @returns {Buffer} Buffer
+ */
+ BufferWriter.alloc = util._Buffer_allocUnsafe;
+
+ BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set"
+ ? function writeBytesBuffer_set(val, buf, pos) {
+ buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
+ // also works for plain array values
+ }
+ /* istanbul ignore next */
+ : function writeBytesBuffer_copy(val, buf, pos) {
+ if (val.copy) // Buffer values
+ val.copy(buf, pos, 0, val.length);
+ else for (var i = 0; i < val.length;) // plain array values
+ buf[pos++] = val[i++];
+ };
+};
+
+
+/**
+ * @override
+ */
+BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
+ if (util.isString(value))
+ value = util._Buffer_from(value, "base64");
+ var len = value.length >>> 0;
+ this.uint32(len);
+ if (len)
+ this._push(BufferWriter.writeBytesBuffer, len, value);
+ return this;
+};
+
+function writeStringBuffer(val, buf, pos) {
+ if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
+ util.utf8.write(val, buf, pos);
+ else if (buf.utf8Write)
+ buf.utf8Write(val, pos);
+ else
+ buf.write(val, pos);
+}
+
+/**
+ * @override
+ */
+BufferWriter.prototype.string = function write_string_buffer(value) {
+ var len = util.Buffer.byteLength(value);
+ this.uint32(len);
+ if (len)
+ this._push(writeStringBuffer, len, value);
+ return this;
+};
+
+
+/**
+ * Finishes the write operation.
+ * @name BufferWriter#finish
+ * @function
+ * @returns {Buffer} Finished buffer
+ */
+
+BufferWriter._configure();
+
+},{"15":15,"16":16}]},{},[8])
+
+})();
+//# sourceMappingURL=protobuf.js.map
git://repos.xcallymotion.com / motion2.git / blobdiff