protobuf.min.js.map

{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/ieee754.js","node_modules/@protobufjs/base64/index.js","node_modules/@protobufjs/pool/index.js","node_modules/@protobufjs/utf8/index.js","runtime","src/reader.js","src/util/longbits.js","src/util/runtime.js","src/writer.js"],"names":["e","t","n","r","s","o","u","a","require","i","f","Error","code","l","exports","call","length","1","module","read","buffer","offset","isBE","mLen","nBytes","m","eLen","eMax","eBias","nBits","d","NaN","Infinity","Math","pow","write","value","c","rt","abs","isNaN","floor","log","LN2","base64","string","p","charAt","ceil","b64","s64","encode","start","end","j","b","String","fromCharCode","apply","invalidEncoding","decode","charCodeAt","undefined","pool","alloc","slice","size","SIZE","MAX","slab","buf","utf8","len","parts","chunk","push","join","c1","c2","configure","Reader","_configure","protobuf","Writer","BufferWriter","BufferReader","util","roots","define","amd","Long","indexOutOfRange","reader","writeLength","RangeError","pos","this","readLongVarint","bits","LongBits","lo","hi","read_int64_long","toLong","read_int64_number","toNumber","read_uint64_long","read_uint64_number","read_sint64_long","zzDecode","read_sint64_number","readFixed32","readFixed64","read_fixed64_long","read_fixed64_number","read_sfixed64_long","read_sfixed64_number","initBufferReader","readStringBuffer_utf8Slice","utf8Slice","readStringBuffer_toString","toString","ReaderPrototype","int64","uint64","sint64","fixed64","sfixed64","ieee754","ArrayImpl","Uint8Array","Array","create","Buffer","prototype","_slice","subarray","int32","octet","uint32","sint32","bool","fixed32","sfixed32","readFloat","Float32Array","f32","f8b","float","readDouble","Float64Array","f64","double","bytes","constructor","skip","skipType","wireType","reset","finish","remain","BufferReaderPrototype","readStringBuffer","Object","readFloatLE","readDoubleLE","LongBitsPrototype","zero","zzEncode","fromNumber","sign","from","parseInt","fromString","low","high","unsigned","Boolean","fromHash","hash","toHash","mask","part0","part1","part2","isNode","global","process","versions","node","dcodeIO","isInteger","Number","isFinite","isString","isObject","longToHash","longFromHash","fromBits","longNeq","longNe","val","props","target","descriptors","keys","forEach","key","prop","descriptor","ie8","ucKey","substring","toUpperCase","get","set","defineProperty","emptyArray","freeze","emptyObject","Op","fn","next","noop","State","writer","head","tail","states","writeByte","writeVarint32","writeVarint64","writeFixed32","writeFloatBuffer","writeFloatLE","writeDoubleBuffer","writeDoubleLE","writeBytesBuffer","copy","WriterPrototype","op","writeFloat","writeDouble","writeBytes","fork","ldelim","id","allocUnsafe","BufferWriterPrototype","writeStringBuffer","utf8Write","byteLength"],"mappings":"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","file":"protobuf.min.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// Copyright (c) 2008, Fair Oaks Labs, Inc.\r\n// All rights reserved.\r\n//\r\n// Redistribution and use in source and binary forms, with or without\r\n// modification, are permitted provided that the following conditions are met:\r\n//\r\n//  * Redistributions of source code must retain the above copyright notice,\r\n//    this list of conditions and the following disclaimer.\r\n//\r\n//  * Redistributions in binary form must reproduce the above copyright notice,\r\n//    this list of conditions and the following disclaimer in the documentation\r\n//    and/or other materials provided with the distribution.\r\n//\r\n//  * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors\r\n//    may be used to endorse or promote products derived from this software\r\n//    without specific prior written permission.\r\n//\r\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\r\n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r\n// ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\r\n// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r\n// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r\n// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r\n// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r\n// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r\n// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r\n// POSSIBILITY OF SUCH DAMAGE.\r\n//\r\n//\r\n// Modifications to writeIEEE754 to support negative zeroes made by Brian White\r\n\r\n// ref: https://github.com/nodejs/node/blob/87286cc7371886d9856edf424785aaa890ba05a9/lib/buffer_ieee754.js\r\n\r\nexports.read = function readIEEE754(buffer, offset, isBE, mLen, nBytes) {\r\n    var e, m,\r\n        eLen = nBytes * 8 - mLen - 1,\r\n        eMax = (1 << eLen) - 1,\r\n        eBias = eMax >> 1,\r\n        nBits = -7,\r\n        i = isBE ? 0 : (nBytes - 1),\r\n        d = isBE ? 1 : -1,\r\n        s = buffer[offset + i];\r\n\r\n    i += d;\r\n\r\n    e = s & ((1 << (-nBits)) - 1);\r\n    s >>= (-nBits);\r\n    nBits += eLen;\r\n    for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);\r\n\r\n    m = e & ((1 << (-nBits)) - 1);\r\n    e >>= (-nBits);\r\n    nBits += mLen;\r\n    for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);\r\n\r\n    if (e === 0) {\r\n        e = 1 - eBias;\r\n    } else if (e === eMax) {\r\n        return m ? NaN : ((s ? -1 : 1) * Infinity);\r\n    } else {\r\n        m = m + Math.pow(2, mLen);\r\n        e = e - eBias;\r\n    }\r\n    return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\r\n};\r\n\r\nexports.write = function writeIEEE754(buffer, value, offset, isBE, mLen, nBytes) {\r\n    var e, m, c,\r\n        eLen = nBytes * 8 - mLen - 1,\r\n        eMax = (1 << eLen) - 1,\r\n        eBias = eMax >> 1,\r\n        rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),\r\n        i = isBE ? (nBytes - 1) : 0,\r\n        d = isBE ? -1 : 1,\r\n        s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\r\n\r\n    value = Math.abs(value);\r\n\r\n    if (isNaN(value) || value === Infinity) {\r\n        m = isNaN(value) ? 1 : 0;\r\n        e = eMax;\r\n    } else {\r\n        e = Math.floor(Math.log(value) / Math.LN2);\r\n        if (value * (c = Math.pow(2, -e)) < 1) {\r\n            e--;\r\n            c *= 2;\r\n        }\r\n        if (e + eBias >= 1) {\r\n            value += rt / c;\r\n        } else {\r\n            value += rt * Math.pow(2, 1 - eBias);\r\n        }\r\n        if (value * c >= 2) {\r\n            e++;\r\n            c /= 2;\r\n        }\r\n\r\n        if (e + eBias >= eMax) {\r\n            m = 0;\r\n            e = eMax;\r\n        } else if (e + eBias >= 1) {\r\n            m = (value * c - 1) * Math.pow(2, mLen);\r\n            e = e + eBias;\r\n        } else {\r\n            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\r\n            e = 0;\r\n        }\r\n    }\r\n\r\n    for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);\r\n\r\n    e = (e << mLen) | m;\r\n    eLen += mLen;\r\n    for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);\r\n\r\n    buffer[offset + i - d] |= s * 128;\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 = [];\r\n\r\n// Base64 decoding table\r\nvar s64 = [];\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 string = []; // alt: new Array(Math.ceil((end - start) / 3) * 4);\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                string[i++] = b64[b >> 2];\r\n                t = (b & 3) << 4;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                string[i++] = b64[t | b >> 4];\r\n                t = (b & 15) << 2;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                string[i++] = b64[t | b >> 6];\r\n                string[i++] = b64[b & 63];\r\n                j = 0;\r\n                break;\r\n        }\r\n    }\r\n    if (j) {\r\n        string[i++] = b64[t];\r\n        string[i  ] = 61;\r\n        if (j === 1)\r\n            string[i + 1] = 61;\r\n    }\r\n    return String.fromCharCode.apply(String, string);\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","\"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 > 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\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 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(buffer, start, end) {\r\n    var len = end - start;\r\n    if (len < 1)\r\n        return \"\";\r\n    var parts = [],\r\n        chunk = [],\r\n        i = 0, // char offset\r\n        t;     // temporary\r\n    while (start < end) {\r\n        t = buffer[start++];\r\n        if (t < 128)\r\n            chunk[i++] = t;\r\n        else if (t > 191 && t < 224)\r\n            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;\r\n        else if (t > 239 && t < 365) {\r\n            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;\r\n            chunk[i++] = 0xD800 + (t >> 10);\r\n            chunk[i++] = 0xDC00 + (t & 1023);\r\n        } else\r\n            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;\r\n        if (i > 8191) {\r\n            parts.push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\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\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(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","// This file exports just the bare minimum required to work with statically generated code.\r\n// Can be used as a drop-in replacement for the full library as it has the same general structure.\r\nvar protobuf = exports;\r\n\r\nvar Writer = protobuf.Writer = require(9);\r\nprotobuf.BufferWriter = Writer.BufferWriter;\r\nvar Reader = protobuf.Reader = require(6);\r\nprotobuf.BufferReader = Reader.BufferReader;\r\nprotobuf.util = require(8);\r\nprotobuf.roots = {};\r\nprotobuf.configure = configure;\r\n\r\nfunction configure() {\r\n    Reader._configure();\r\n}\r\n\r\n// Be nice to AMD\r\nif (typeof define === \"function\" && define.amd)\r\n    define([\"long\"], function(Long) {\r\n        if (Long) {\r\n            protobuf.util.Long = Long;\r\n            configure();\r\n        }\r\n        return protobuf;\r\n    });\r\n","\"use strict\";\r\nmodule.exports = Reader;\r\n\r\nReader.BufferReader = BufferReader;\r\n\r\nvar util      = require(8),\r\n    ieee754   = require(1);\r\nvar LongBits  = util.LongBits,\r\n    utf8      = util.utf8;\r\nvar ArrayImpl = typeof Uint8Array !== \"undefined\" ? Uint8Array : Array;\r\n\r\nfunction indexOutOfRange(reader, writeLength) {\r\n    return RangeError(\"index out of range: \" + reader.pos + \" + \" + (writeLength || 1) + \" > \" + reader.len);\r\n}\r\n\r\n/**\r\n * Constructs a new reader instance using the specified buffer.\r\n * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.\r\n * @constructor\r\n * @param {Uint8Array} buffer Buffer to read from\r\n */\r\nfunction Reader(buffer) {\r\n    \r\n    /**\r\n     * Read buffer.\r\n     * @type {Uint8Array}\r\n     */\r\n    this.buf = buffer;\r\n\r\n    /**\r\n     * Read buffer position.\r\n     * @type {number}\r\n     */\r\n    this.pos = 0;\r\n\r\n    /**\r\n     * Read buffer length.\r\n     * @type {number}\r\n     */\r\n    this.len = buffer.length;\r\n}\r\n\r\n/**\r\n * Creates a new reader using the specified buffer.\r\n * @param {Uint8Array} buffer Buffer to read from\r\n * @returns {BufferReader|Reader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}\r\n */\r\nReader.create = function create(buffer) {\r\n    return new (util.Buffer ? BufferReader : Reader)(buffer);\r\n};\r\n\r\n/** @alias Reader.prototype */\r\nvar ReaderPrototype = Reader.prototype;\r\n\r\nReaderPrototype._slice = ArrayImpl.prototype.subarray || ArrayImpl.prototype.slice;\r\n\r\n/**\r\n * Reads a varint as a signed 32 bit value.\r\n * @returns {number} Value read\r\n */\r\nReaderPrototype.int32 = function read_int32() {\r\n    var octet = this.buf[this.pos++],\r\n        value = octet & 127;\r\n    if (octet > 127) { octet = this.buf[this.pos++]; value |= (octet & 127) <<  7;\r\n    if (octet > 127) { octet = this.buf[this.pos++]; value |= (octet & 127) << 14;\r\n    if (octet > 127) { octet = this.buf[this.pos++]; value |= (octet & 127) << 21;\r\n    if (octet > 127) { octet = this.buf[this.pos++]; value |= (octet & 127) << 28;\r\n    if (octet > 127)   this.pos += 5; } } } }\r\n    if (this.pos > this.len) {\r\n        this.pos = this.len;\r\n        throw indexOutOfRange(this);\r\n    }\r\n    return value;\r\n};\r\n\r\n/**\r\n * Reads a varint as an unsigned 32 bit value.\r\n * @returns {number} Value read\r\n */\r\nReaderPrototype.uint32 = function read_uint32() {\r\n    return this.int32() >>> 0;\r\n};\r\n\r\n/**\r\n * Reads a zig-zag encoded varint as a signed 32 bit value.\r\n * @returns {number} Value read\r\n */\r\nReaderPrototype.sint32 = function read_sint32() {\r\n    var value = this.int32();\r\n    return value >>> 1 ^ -(value & 1);\r\n};\r\n\r\n/* eslint-disable no-invalid-this */\r\n\r\nfunction readLongVarint() {\r\n    var bits = new LongBits(0, 0),\r\n        i = 0, b = 0;\r\n    if (this.len - this.pos > 4) { // fast route (lo)\r\n        for (i = 0; i < 4; ++i) {\r\n            b = this.buf[this.pos++]; // 1st..4th\r\n            bits.lo = (bits.lo | (b & 127) << i * 7) >>> 0;\r\n            if (b < 128)\r\n                return bits;\r\n        }\r\n        b = this.buf[this.pos++]; // 5th\r\n        bits.lo = (bits.lo | (b & 127) << 28) >>> 0;\r\n        bits.hi = (bits.hi | (b & 127) >>  4) >>> 0;\r\n        if (b < 128)\r\n            return bits;\r\n    } else {\r\n        for (i = 0; i < 4; ++i) {\r\n            if (this.pos >= this.len)\r\n                throw indexOutOfRange(this);\r\n            b = this.buf[this.pos++]; // 1st..4th\r\n            bits.lo = (bits.lo | (b & 127) << i * 7) >>> 0;\r\n            if (b < 128)\r\n                return bits;\r\n        }\r\n        if (this.pos >= this.len)\r\n            throw indexOutOfRange(this);\r\n        b = this.buf[this.pos++]; // 5th\r\n        bits.lo = (bits.lo | (b & 127) << 28) >>> 0;\r\n        bits.hi = (bits.hi | (b & 127) >>  4) >>> 0;\r\n        if (b < 128)\r\n            return bits;\r\n    }\r\n    if (this.len - this.pos > 4) { // fast route (hi)\r\n        for (i = 0; i < 5; ++i) {\r\n            b = this.buf[this.pos++]; // 6th..10th\r\n            bits.hi = (bits.hi | (b & 127) << i * 7 + 3) >>> 0;\r\n            if (b < 128)\r\n                return bits;\r\n        }\r\n    } else {\r\n        for (i = 0; i < 5; ++i) {\r\n            if (this.pos >= this.len)\r\n                throw indexOutOfRange(this);\r\n            b = this.buf[this.pos++]; // 6th..10th\r\n            bits.hi = (bits.hi | (b & 127) << i * 7 + 3) >>> 0;\r\n            if (b < 128)\r\n                return bits;\r\n        }\r\n    }\r\n    throw Error(\"invalid varint encoding\");\r\n}\r\n\r\nfunction read_int64_long() {\r\n    return readLongVarint.call(this).toLong();\r\n}\r\n\r\nfunction read_int64_number() {\r\n    return readLongVarint.call(this).toNumber();\r\n}\r\n\r\nfunction read_uint64_long() {\r\n    return readLongVarint.call(this).toLong(true);\r\n}\r\n\r\nfunction read_uint64_number() {\r\n    return readLongVarint.call(this).toNumber(true);\r\n}\r\n\r\nfunction read_sint64_long() {\r\n    return readLongVarint.call(this).zzDecode().toLong();\r\n}\r\n\r\nfunction read_sint64_number() {\r\n    return readLongVarint.call(this).zzDecode().toNumber();\r\n}\r\n\r\n/* eslint-enable no-invalid-this */\r\n\r\n/**\r\n * Reads a varint as a signed 64 bit value.\r\n * @name Reader#int64\r\n * @function\r\n * @returns {Long|number} Value read\r\n */\r\n\r\n/**\r\n * Reads a varint as an unsigned 64 bit value.\r\n * @name Reader#uint64\r\n * @function\r\n * @returns {Long|number} Value read\r\n */\r\n\r\n/**\r\n * Reads a zig-zag encoded varint as a signed 64 bit value.\r\n * @name Reader#sint64\r\n * @function\r\n * @returns {Long|number} Value read\r\n */\r\n\r\n/**\r\n * Reads a varint as a boolean.\r\n * @returns {boolean} Value read\r\n */\r\nReaderPrototype.bool = function read_bool() {\r\n    return this.int32() !== 0;\r\n};\r\n\r\nfunction readFixed32(buf, end) {\r\n    return buf[end - 4]\r\n         | buf[end - 3] << 8\r\n         | buf[end - 2] << 16\r\n         | buf[end - 1] << 24;\r\n}\r\n\r\n/**\r\n * Reads fixed 32 bits as a number.\r\n * @returns {number} Value read\r\n */\r\nReaderPrototype.fixed32 = function read_fixed32() {\r\n    if (this.pos + 4 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n    return readFixed32(this.buf, this.pos += 4);\r\n};\r\n\r\n/**\r\n * Reads zig-zag encoded fixed 32 bits as a number.\r\n * @returns {number} Value read\r\n */\r\nReaderPrototype.sfixed32 = function read_sfixed32() {\r\n    var value = this.fixed32();\r\n    return value >>> 1 ^ -(value & 1);\r\n};\r\n\r\n/* eslint-disable no-invalid-this */\r\n\r\nfunction readFixed64(/* this: Reader */) {\r\n    if (this.pos + 8 > this.len)\r\n        throw indexOutOfRange(this, 8);\r\n    return new LongBits(readFixed32(this.buf, this.pos += 4), readFixed32(this.buf, this.pos += 4));\r\n}\r\n\r\nfunction read_fixed64_long() {\r\n    return readFixed64.call(this).toLong(true);\r\n}\r\n\r\nfunction read_fixed64_number() {\r\n    return readFixed64.call(this).toNumber(true);\r\n}\r\n\r\nfunction read_sfixed64_long() {\r\n    return readFixed64.call(this).zzDecode().toLong();\r\n}\r\n\r\nfunction read_sfixed64_number() {\r\n    return readFixed64.call(this).zzDecode().toNumber();\r\n}\r\n\r\n/* eslint-enable no-invalid-this */\r\n\r\n/**\r\n * Reads fixed 64 bits.\r\n * @name Reader#fixed64\r\n * @function\r\n * @returns {Long|number} Value read\r\n */\r\n\r\n/**\r\n * Reads zig-zag encoded fixed 64 bits.\r\n * @name Reader#sfixed64\r\n * @function\r\n * @returns {Long|number} Value read\r\n */\r\n\r\nvar readFloat = typeof Float32Array !== \"undefined\"\r\n    ? (function() { // eslint-disable-line wrap-iife\r\n        var f32 = new Float32Array(1),\r\n            f8b = new Uint8Array(f32.buffer);\r\n        f32[0] = -0;\r\n        return f8b[3] // already le?\r\n            ? function readFloat_f32(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            : function readFloat_f32_le(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    : function readFloat_ieee754(buf, pos) {\r\n        return ieee754.read(buf, pos, false, 23, 4);\r\n    };\r\n\r\n/**\r\n * Reads a float (32 bit) as a number.\r\n * @function\r\n * @returns {number} Value read\r\n */\r\nReaderPrototype.float = function read_float() {\r\n    if (this.pos + 4 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n    var value = readFloat(this.buf, this.pos);\r\n    this.pos += 4;\r\n    return value;\r\n};\r\n\r\nvar readDouble = typeof Float64Array !== \"undefined\"\r\n    ? (function() { // eslint-disable-line wrap-iife\r\n        var f64 = new Float64Array(1),\r\n            f8b = new Uint8Array(f64.buffer);\r\n        f64[0] = -0;\r\n        return f8b[7] // already le?\r\n            ? function readDouble_f64(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            : function readDouble_f64_le(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    : function readDouble_ieee754(buf, pos) {\r\n        return ieee754.read(buf, pos, false, 52, 8);\r\n    };\r\n\r\n/**\r\n * Reads a double (64 bit float) as a number.\r\n * @function\r\n * @returns {number} Value read\r\n */\r\nReaderPrototype.double = function read_double() {\r\n    if (this.pos + 8 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n    var value = readDouble(this.buf, this.pos);\r\n    this.pos += 8;\r\n    return value;\r\n};\r\n\r\n/**\r\n * Reads a sequence of bytes preceeded by its length as a varint.\r\n * @returns {Uint8Array} Value read\r\n */\r\nReaderPrototype.bytes = function read_bytes() {\r\n    var length = this.int32() >>> 0,\r\n        start  = this.pos,\r\n        end    = this.pos + length;\r\n    if (end > this.len)\r\n        throw indexOutOfRange(this, length);\r\n    this.pos += length;\r\n    return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1\r\n        ? new this.buf.constructor(0)\r\n        : this._slice.call(this.buf, start, end);\r\n};\r\n\r\n/**\r\n * Reads a string preceeded by its byte length as a varint.\r\n * @returns {string} Value read\r\n */\r\nReaderPrototype.string = function read_string() {\r\n    var bytes = this.bytes();\r\n    return utf8.read(bytes, 0, bytes.length);\r\n};\r\n\r\n/**\r\n * Skips the specified number of bytes if specified, otherwise skips a varint.\r\n * @param {number} [length] Length if known, otherwise a varint is assumed\r\n * @returns {Reader} `this`\r\n */\r\nReaderPrototype.skip = function skip(length) {\r\n    if (length === undefined) {\r\n        do {\r\n            if (this.pos >= this.len)\r\n                throw indexOutOfRange(this);\r\n        } while (this.buf[this.pos++] & 128);\r\n    } else {\r\n        if (this.pos + length > this.len)\r\n            throw indexOutOfRange(this, length);\r\n        this.pos += length;\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Skips the next element of the specified wire type.\r\n * @param {number} wireType Wire type received\r\n * @returns {Reader} `this`\r\n */\r\nReaderPrototype.skipType = function(wireType) {\r\n    switch (wireType) {\r\n        case 0:\r\n            this.skip();\r\n            break;\r\n        case 1:\r\n            this.skip(8);\r\n            break;\r\n        case 2:\r\n            this.skip(this.uint32());\r\n            break;\r\n        case 3:\r\n            do { // eslint-disable-line no-constant-condition\r\n                wireType = this.int32() & 7;\r\n                if (wireType === 4)\r\n                    break;\r\n                this.skipType(wireType);\r\n            } while (true);\r\n            break;\r\n        case 5:\r\n            this.skip(4);\r\n            break;\r\n        default:\r\n            throw Error(\"invalid wire type: \" + wireType);\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Resets this instance and frees all resources.\r\n * @param {Uint8Array} [buffer] New buffer for a new sequence of read operations\r\n * @returns {Reader} `this`\r\n */\r\nReaderPrototype.reset = function reset(buffer) {\r\n    if (buffer) {\r\n        this.buf = buffer;\r\n        this.len = buffer.length;\r\n    } else {\r\n        this.buf = null; // makes it throw\r\n        this.len = 0;\r\n    }\r\n    this.pos = 0;\r\n    return this;\r\n};\r\n\r\n/**\r\n * Finishes the current sequence of read operations, frees all resources and returns the remaining buffer.\r\n * @param {Uint8Array} [buffer] New buffer for a new sequence of read operations\r\n * @returns {Uint8Array} Finished buffer\r\n */\r\nReaderPrototype.finish = function finish(buffer) {\r\n    var remain = this.pos\r\n        ? this._slice.call(this.buf, this.pos)\r\n        : this.buf;\r\n    this.reset(buffer);\r\n    return remain;\r\n};\r\n\r\n// One time function to initialize BufferReader with the now-known buffer implementation's slice method\r\nvar initBufferReader = function() {\r\n    var Buffer = util.Buffer;\r\n    if (!Buffer)\r\n        throw Error(\"Buffer is not supported\");\r\n    BufferReaderPrototype._slice = Buffer.prototype.slice;\r\n    readStringBuffer = Buffer.prototype.utf8Slice // around forever, but not present in browser buffer\r\n        ? readStringBuffer_utf8Slice\r\n        : readStringBuffer_toString;\r\n    initBufferReader = false;\r\n};\r\n\r\n/**\r\n * Constructs a new buffer reader instance.\r\n * @classdesc Wire format reader using node buffers.\r\n * @extends Reader\r\n * @constructor\r\n * @param {Buffer} buffer Buffer to read from\r\n */\r\nfunction BufferReader(buffer) {\r\n    if (initBufferReader)\r\n        initBufferReader();\r\n    Reader.call(this, buffer);\r\n}\r\n\r\n/** @alias BufferReader.prototype */\r\nvar BufferReaderPrototype = BufferReader.prototype = Object.create(Reader.prototype);\r\n\r\nBufferReaderPrototype.constructor = BufferReader;\r\n\r\nif (typeof Float32Array === \"undefined\") // f32 is faster (node 6.9.1)\r\n/**\r\n * @override\r\n */\r\nBufferReaderPrototype.float = function read_float_buffer() {\r\n    if (this.pos + 4 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n    var value = this.buf.readFloatLE(this.pos, true);\r\n    this.pos += 4;\r\n    return value;\r\n};\r\n\r\nif (typeof Float64Array === \"undefined\") // f64 is faster (node 6.9.1)\r\n/**\r\n * @override\r\n */\r\nBufferReaderPrototype.double = function read_double_buffer() {\r\n    if (this.pos + 8 > this.len)\r\n        throw indexOutOfRange(this, 8);\r\n    var value = this.buf.readDoubleLE(this.pos, true);\r\n    this.pos += 8;\r\n    return value;\r\n};\r\n\r\nvar readStringBuffer;\r\n\r\nfunction readStringBuffer_utf8Slice(buf, start, end) {\r\n    return buf.utf8Slice(start, end); // fastest\r\n}\r\n\r\nfunction readStringBuffer_toString(buf, start, end) {\r\n    return buf.toString(\"utf8\", start, end); // 2nd, again assertions\r\n}\r\n\r\n/**\r\n * @override\r\n */\r\nBufferReaderPrototype.string = function read_string_buffer() {\r\n    var length = this.int32() >>> 0,\r\n        start  = this.pos,\r\n        end    = this.pos + length;\r\n    if (end > this.len)\r\n        throw indexOutOfRange(this, length);\r\n    this.pos += length;\r\n    return readStringBuffer(this.buf, start, end);\r\n};\r\n\r\n/**\r\n * @override\r\n */\r\nBufferReaderPrototype.finish = function finish_buffer(buffer) {\r\n    var remain = this.pos ? this.buf.slice(this.pos) : this.buf;\r\n    this.reset(buffer);\r\n    return remain;\r\n};\r\n\r\nfunction configure() {\r\n    if (util.Long) {\r\n        ReaderPrototype.int64 = read_int64_long;\r\n        ReaderPrototype.uint64 = read_uint64_long;\r\n        ReaderPrototype.sint64 = read_sint64_long;\r\n        ReaderPrototype.fixed64 = read_fixed64_long;\r\n        ReaderPrototype.sfixed64 = read_sfixed64_long;\r\n    } else {\r\n        ReaderPrototype.int64 = read_int64_number;\r\n        ReaderPrototype.uint64 = read_uint64_number;\r\n        ReaderPrototype.sint64 = read_sint64_number;\r\n        ReaderPrototype.fixed64 = read_fixed64_number;\r\n        ReaderPrototype.sfixed64 = read_sfixed64_number;\r\n    }\r\n}\r\n\r\nReader._configure = configure;\r\n\r\nconfigure();\r\n","\"use strict\";\r\n\r\nmodule.exports = LongBits;\r\n\r\nvar util = require(8);\r\n\r\n/**\r\n * Any compatible Long instance.\r\n * @typedef Long\r\n * @type {Object}\r\n * @property {number} low Low bits\r\n * @property {number} high High bits\r\n * @property {boolean} unsigned Whether unsigned or not\r\n */\r\n\r\n/**\r\n * Constructs new long bits.\r\n * @classdesc Helper class for working with the low and high bits of a 64 bit value.\r\n * @memberof util\r\n * @constructor\r\n * @param {number} lo Low bits\r\n * @param {number} hi High bits\r\n */\r\nfunction LongBits(lo, hi) { // make sure to always call this with unsigned 32bits for proper optimization\r\n\r\n    /**\r\n     * Low bits.\r\n     * @type {number}\r\n     */\r\n    this.lo = lo;\r\n\r\n    /**\r\n     * High bits.\r\n     * @type {number}\r\n     */\r\n    this.hi = hi;\r\n}\r\n\r\n/** @alias util.LongBits.prototype */\r\nvar LongBitsPrototype = LongBits.prototype;\r\n\r\n/**\r\n * Zero bits.\r\n * @memberof util.LongBits\r\n * @type {util.LongBits}\r\n */\r\nvar zero = LongBits.zero = new LongBits(0, 0);\r\n\r\nzero.toNumber = function() { return 0; };\r\nzero.zzEncode = zero.zzDecode = function() { return this; };\r\nzero.length = function() { return 1; };\r\n\r\n/**\r\n * Constructs new long bits from the specified number.\r\n * @param {number} value Value\r\n * @returns {util.LongBits} Instance\r\n */\r\nLongBits.fromNumber = function fromNumber(value) {\r\n    if (value === 0)\r\n        return zero;\r\n    var sign  = value < 0;\r\n        value = Math.abs(value);\r\n    var lo = value >>> 0,\r\n        hi = (value - lo) / 4294967296 >>> 0;\r\n    if (sign) {\r\n        hi = ~hi >>> 0;\r\n        lo = ~lo >>> 0;\r\n        if (++lo > 4294967295) {\r\n            lo = 0;\r\n            if (++hi > 4294967295)\r\n                hi = 0;\r\n        }\r\n    }\r\n    return new LongBits(lo, hi);\r\n};\r\n\r\n/**\r\n * Constructs new long bits from a number, long or string.\r\n * @param {Long|number|string} value Value\r\n * @returns {util.LongBits} Instance\r\n */\r\nLongBits.from = function from(value) {\r\n    if (typeof value === \"number\")\r\n        return LongBits.fromNumber(value);\r\n    if (typeof value === \"string\") {\r\n        if (util.Long)\r\n            value = util.Long.fromString(value);\r\n        else\r\n            return LongBits.fromNumber(parseInt(value, 10));\r\n    }\r\n    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;\r\n};\r\n\r\n/**\r\n * Converts this long bits to a possibly unsafe JavaScript number.\r\n * @param {boolean} [unsigned=false] Whether unsigned or not\r\n * @returns {number} Possibly unsafe number\r\n */\r\nLongBitsPrototype.toNumber = function toNumber(unsigned) {\r\n    if (!unsigned && this.hi >>> 31) {\r\n        this.lo = ~this.lo + 1 >>> 0;\r\n        this.hi = ~this.hi     >>> 0;\r\n        if (!this.lo)\r\n            this.hi = this.hi + 1 >>> 0;\r\n        return -(this.lo + this.hi * 4294967296);\r\n    }\r\n    return this.lo + this.hi * 4294967296;\r\n};\r\n\r\n/**\r\n * Converts this long bits to a long.\r\n * @param {boolean} [unsigned=false] Whether unsigned or not\r\n * @returns {Long} Long\r\n */\r\nLongBitsPrototype.toLong = function toLong(unsigned) {\r\n    return util.Long\r\n        ? new util.Long(this.lo, this.hi, unsigned)\r\n        : { low: this.lo, high: this.hi, unsigned: Boolean(unsigned) };\r\n};\r\n\r\nvar charCodeAt = String.prototype.charCodeAt;\r\n\r\n/**\r\n * Constructs new long bits from the specified 8 characters long hash.\r\n * @param {string} hash Hash\r\n * @returns {util.LongBits} Bits\r\n */\r\nLongBits.fromHash = function fromHash(hash) {\r\n    return new LongBits(\r\n        ( charCodeAt.call(hash, 0)\r\n        | charCodeAt.call(hash, 1) << 8\r\n        | charCodeAt.call(hash, 2) << 16\r\n        | charCodeAt.call(hash, 3) << 24) >>> 0\r\n    ,\r\n        ( charCodeAt.call(hash, 4)\r\n        | charCodeAt.call(hash, 5) << 8\r\n        | charCodeAt.call(hash, 6) << 16\r\n        | charCodeAt.call(hash, 7) << 24) >>> 0\r\n    );\r\n};\r\n\r\n/**\r\n * Converts this long bits to a 8 characters long hash.\r\n * @returns {string} Hash\r\n */\r\nLongBitsPrototype.toHash = function toHash() {\r\n    return String.fromCharCode(\r\n        this.lo        & 255,\r\n        this.lo >>> 8  & 255,\r\n        this.lo >>> 16 & 255,\r\n        this.lo >>> 24 & 255,\r\n        this.hi        & 255,\r\n        this.hi >>> 8  & 255,\r\n        this.hi >>> 16 & 255,\r\n        this.hi >>> 24 & 255\r\n    );\r\n};\r\n\r\n/**\r\n * Zig-zag encodes this long bits.\r\n * @returns {util.LongBits} `this`\r\n */\r\nLongBitsPrototype.zzEncode = function zzEncode() {\r\n    var mask =   this.hi >> 31;\r\n    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;\r\n    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;\r\n    return this;\r\n};\r\n\r\n/**\r\n * Zig-zag decodes this long bits.\r\n * @returns {util.LongBits} `this`\r\n */\r\nLongBitsPrototype.zzDecode = function zzDecode() {\r\n    var mask = -(this.lo & 1);\r\n    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;\r\n    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;\r\n    return this;\r\n};\r\n\r\n/**\r\n * Calculates the length of this longbits when encoded as a varint.\r\n * @returns {number} Length\r\n */\r\nLongBitsPrototype.length = function length() {\r\n    var part0 =  this.lo,\r\n        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,\r\n        part2 =  this.hi >>> 24;\r\n    if (part2 === 0) {\r\n        if (part1 === 0)\r\n            return part0 < 1 << 14\r\n                ? part0 < 1 << 7 ? 1 : 2\r\n                : part0 < 1 << 21 ? 3 : 4;\r\n        return part1 < 1 << 14\r\n            ? part1 < 1 << 7 ? 5 : 6\r\n            : part1 < 1 << 21 ? 7 : 8;\r\n    }\r\n    return part2 < 1 << 7 ? 9 : 10;\r\n};\r\n","\"use strict\";\r\n\r\nvar util = exports;\r\n\r\nvar LongBits =\r\nutil.LongBits = require(\"./longbits\");\r\nutil.base64   = require(\"@protobufjs/base64\");\r\nutil.utf8     = require(\"@protobufjs/utf8\");\r\nutil.pool     = require(\"@protobufjs/pool\");\r\n\r\n/**\r\n * Whether running within node or not.\r\n * @memberof util\r\n * @type {boolean}\r\n */\r\nvar isNode = util.isNode = Boolean(global.process && global.process.versions && global.process.versions.node);\r\n\r\n/**\r\n * Optional buffer class to use.\r\n * If you assign any compatible buffer implementation to this property, the library will use it.\r\n * @type {*}\r\n */\r\nutil.Buffer = null;\r\n\r\nif (isNode)\r\n    try { util.Buffer = require(\"buffer\").Buffer; } catch (e) {} // eslint-disable-line no-empty\r\n\r\n/**\r\n * Optional Long class to use.\r\n * If you assign any compatible long implementation to this property, the library will use it.\r\n * @type {*}\r\n */\r\nutil.Long = global.dcodeIO && global.dcodeIO.Long || null;\r\n\r\nif (!util.Long && isNode)\r\n    try { util.Long = require(\"long\"); } catch (e) {} // eslint-disable-line no-empty\r\n\r\n/**\r\n * Tests if the specified value is an integer.\r\n * @function\r\n * @param {*} value Value to test\r\n * @returns {boolean} `true` if the value is an integer\r\n */\r\nutil.isInteger = Number.isInteger || function isInteger(value) {\r\n    return typeof value === \"number\" && isFinite(value) && Math.floor(value) === value;\r\n};\r\n\r\n/**\r\n * Tests if the specified value is a string.\r\n * @param {*} value Value to test\r\n * @returns {boolean} `true` if the value is a string\r\n */\r\nutil.isString = function isString(value) {\r\n    return typeof value === \"string\" || value instanceof String;\r\n};\r\n\r\n/**\r\n * Tests if the specified value is a non-null object.\r\n * @param {*} value Value to test\r\n * @returns {boolean} `true` if the value is a non-null object\r\n */\r\nutil.isObject = function isObject(value) {\r\n    return Boolean(value && typeof value === \"object\");\r\n};\r\n\r\n/**\r\n * Converts a number or long to an 8 characters long hash string.\r\n * @param {Long|number} value Value to convert\r\n * @returns {string} Hash\r\n */\r\nutil.longToHash = function longToHash(value) {\r\n    return value\r\n        ? LongBits.from(value).toHash()\r\n        : \"\\0\\0\\0\\0\\0\\0\\0\\0\";\r\n};\r\n\r\n/**\r\n * Converts an 8 characters long hash string to a long or number.\r\n * @param {string} hash Hash\r\n * @param {boolean} [unsigned=false] Whether unsigned or not\r\n * @returns {Long|number} Original value\r\n */\r\nutil.longFromHash = function longFromHash(hash, unsigned) {\r\n    var bits = LongBits.fromHash(hash);\r\n    if (util.Long)\r\n        return util.Long.fromBits(bits.lo, bits.hi, unsigned);\r\n    return bits.toNumber(Boolean(unsigned));\r\n};\r\n\r\n/**\r\n * Tests if two possibly long values are not equal.\r\n * @param {number|Long} a First value\r\n * @param {number|Long} b Second value\r\n * @returns {boolean} `true` if not equal\r\n * @deprecated\r\n * @see Use {@link util.longNe} instead\r\n */\r\nutil.longNeq = function longNeq(a, b) {\r\n    return typeof a === \"number\"\r\n         ? typeof b === \"number\"\r\n            ? a !== b\r\n            : (a = LongBits.fromNumber(a)).lo !== b.low || a.hi !== b.high\r\n         : typeof b === \"number\"\r\n            ? (b = LongBits.fromNumber(b)).lo !== a.low || b.hi !== a.high\r\n            : a.low !== b.low || a.high !== b.high;\r\n};\r\n\r\n/**\r\n * Tests if a possibily long value equals the specified low and high bits.\r\n * @param {number|string|Long} val Value to test\r\n * @param {number} lo Low bits to test against\r\n * @param {number} hi High bits to test against\r\n * @returns {boolean} `true` if not equal\r\n */\r\nutil.longNe = function longNe(val, lo, hi) {\r\n    if (typeof val === 'object') // Long-like, null is invalid and throws\r\n        return val.low !== lo || val.high !== hi;\r\n    var bits = util.LongBits.from(val);\r\n    return bits.lo !== lo || bits.hi !== hi;\r\n};\r\n\r\n/**\r\n * Defines the specified properties on the specified target. Also adds getters and setters for non-ES5 environments.\r\n * @param {Object} target Target object\r\n * @param {Object} descriptors Property descriptors\r\n * @returns {undefined}\r\n */\r\nutil.props = function props(target, descriptors) {\r\n    Object.keys(descriptors).forEach(function(key) {\r\n        util.prop(target, key, descriptors[key]);\r\n    });\r\n};\r\n\r\n/**\r\n * Defines the specified property on the specified target. Also adds getters and setters for non-ES5 environments.\r\n * @param {Object} target Target object\r\n * @param {string} key Property name\r\n * @param {Object} descriptor Property descriptor\r\n * @returns {undefined}\r\n */\r\nutil.prop = function prop(target, key, descriptor) {\r\n    var ie8 = !-[1,];\r\n    var ucKey = key.substring(0, 1).toUpperCase() + key.substring(1);\r\n    if (descriptor.get)\r\n        target[\"get\" + ucKey] = descriptor.get;\r\n    if (descriptor.set)\r\n        target[\"set\" + ucKey] = ie8\r\n            ? function(value) {\r\n                  descriptor.set.call(this, value);\r\n                  this[key] = value;\r\n              }\r\n            : descriptor.set;\r\n    if (ie8) {\r\n        if (descriptor.value !== undefined)\r\n            target[key] = descriptor.value;\r\n    } else\r\n        Object.defineProperty(target, key, descriptor);\r\n};\r\n\r\n/**\r\n * An immuable empty array.\r\n * @memberof util\r\n * @type {Array.<*>}\r\n */\r\nutil.emptyArray = Object.freeze([]);\r\n\r\n/**\r\n * An immutable empty object.\r\n * @type {Object}\r\n */\r\nutil.emptyObject = Object.freeze({});\r\n","\"use strict\";\r\nmodule.exports = Writer;\r\n\r\nWriter.BufferWriter = BufferWriter;\r\n\r\nvar util      = require(8),\r\n    ieee754   = require(1);\r\nvar LongBits  = util.LongBits,\r\n    base64    = util.base64,\r\n    utf8      = util.utf8;\r\nvar ArrayImpl = typeof Uint8Array !== \"undefined\" ? Uint8Array : Array;\r\n\r\n/**\r\n * Constructs a new writer operation instance.\r\n * @classdesc Scheduled writer operation.\r\n * @memberof Writer\r\n * @constructor\r\n * @param {function(*, Uint8Array, number)} fn Function to call\r\n * @param {*} val Value to write\r\n * @param {number} len Value byte length\r\n * @private\r\n * @ignore\r\n */\r\nfunction Op(fn, val, len) {\r\n\r\n    /**\r\n     * Function to call.\r\n     * @type {function(Uint8Array, number, *)}\r\n     */\r\n    this.fn = fn;\r\n\r\n    /**\r\n     * Value to write.\r\n     * @type {*}\r\n     */\r\n    this.val = val;\r\n\r\n    /**\r\n     * Value byte length.\r\n     * @type {number}\r\n     */\r\n    this.len = len;\r\n\r\n    /**\r\n     * Next operation.\r\n     * @type {?Writer.Op}\r\n     */\r\n    this.next = null;\r\n}\r\n\r\nWriter.Op = Op;\r\n\r\nfunction noop() {} // eslint-disable-line no-empty-function\r\n\r\n/**\r\n * Constructs a new writer state instance.\r\n * @classdesc Copied writer state.\r\n * @memberof Writer\r\n * @constructor\r\n * @param {Writer} writer Writer to copy state from\r\n * @private\r\n * @ignore\r\n */\r\nfunction State(writer) {\r\n\r\n    /**\r\n     * Current head.\r\n     * @type {Writer.Op}\r\n     */\r\n    this.head = writer.head;\r\n\r\n    /**\r\n     * Current tail.\r\n     * @type {Writer.Op}\r\n     */\r\n    this.tail = writer.tail;\r\n\r\n    /**\r\n     * Current buffer length.\r\n     * @type {number}\r\n     */\r\n    this.len = writer.len;\r\n\r\n    /**\r\n     * Next state.\r\n     * @type {?State}\r\n     */\r\n    this.next = writer.states;\r\n}\r\n\r\nWriter.State = State;\r\n\r\n/**\r\n * Constructs a new writer instance.\r\n * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.\r\n * @constructor\r\n */\r\nfunction Writer() {\r\n\r\n    /**\r\n     * Current length.\r\n     * @type {number}\r\n     */\r\n    this.len = 0;\r\n\r\n    /**\r\n     * Operations head.\r\n     * @type {Object}\r\n     */\r\n    this.head = new Op(noop, 0, 0);\r\n\r\n    /**\r\n     * Operations tail\r\n     * @type {Object}\r\n     */\r\n    this.tail = this.head;\r\n\r\n    /**\r\n     * Linked forked states.\r\n     * @type {?Object}\r\n     */\r\n    this.states = null;\r\n\r\n    // When a value is written, the writer calculates its byte length and puts it into a linked\r\n    // list of operations to perform when finish() is called. This both allows us to allocate\r\n    // buffers of the exact required size and reduces the amount of work we have to do compared\r\n    // to first calculating over objects and then encoding over objects. In our case, the encoding\r\n    // part is just a linked list walk calling linked operations with already prepared values.\r\n}\r\n\r\n/**\r\n * Creates a new writer.\r\n * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}\r\n */\r\nWriter.create = function create() {\r\n    return new (util.Buffer ? BufferWriter : Writer);\r\n};\r\n\r\n/**\r\n * Allocates a buffer of the specified size.\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n */\r\nWriter.alloc = function alloc(size) {\r\n    return new ArrayImpl(size);\r\n};\r\n\r\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\r\nif (ArrayImpl !== Array)\r\n    Writer.alloc = util.pool(Writer.alloc, ArrayImpl.prototype.subarray || ArrayImpl.prototype.slice);\r\n\r\n/** @alias Writer.prototype */\r\nvar WriterPrototype = Writer.prototype;\r\n\r\n/**\r\n * Pushes a new operation to the queue.\r\n * @param {function(Uint8Array, number, *)} fn Function to call\r\n * @param {number} len Value byte length\r\n * @param {number} val Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.push = function push(fn, len, val) {\r\n    var op = new Op(fn, val, len);\r\n    this.tail.next = op;\r\n    this.tail = op;\r\n    this.len += len;\r\n    return this;\r\n};\r\n\r\nfunction writeByte(val, buf, pos) {\r\n    buf[pos] = val & 255;\r\n}\r\n\r\nfunction writeVarint32(val, buf, pos) {\r\n    while (val > 127) {\r\n        buf[pos++] = val & 127 | 128;\r\n        val >>>= 7;\r\n    }\r\n    buf[pos] = val;\r\n}\r\n\r\n/**\r\n * Writes an unsigned 32 bit value as a varint.\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.uint32 = function write_uint32(value) {\r\n    value = value >>> 0;\r\n    return this.push(writeVarint32,\r\n          value < 128       ? 1\r\n        : value < 16384     ? 2\r\n        : value < 2097152   ? 3\r\n        : value < 268435456 ? 4\r\n        :                     5\r\n    , value);\r\n};\r\n\r\n/**\r\n * Writes a signed 32 bit value as a varint.\r\n * @function\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.int32 = function write_int32(value) {\r\n    return value < 0\r\n        ? this.push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec\r\n        : this.uint32(value);\r\n};\r\n\r\n/**\r\n * Writes a 32 bit value as a varint, zig-zag encoded.\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.sint32 = function write_sint32(value) {\r\n    return this.uint32((value << 1 ^ value >> 31) >>> 0);\r\n};\r\n\r\nfunction writeVarint64(val, buf, pos) {\r\n    while (val.hi) {\r\n        buf[pos++] = val.lo & 127 | 128;\r\n        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;\r\n        val.hi >>>= 7;\r\n    }\r\n    while (val.lo > 127) {\r\n        buf[pos++] = val.lo & 127 | 128;\r\n        val.lo = val.lo >>> 7;\r\n    }\r\n    buf[pos++] = val.lo;\r\n}\r\n\r\n/**\r\n * Writes an unsigned 64 bit value as a varint.\r\n * @param {Long|number|string} value Value to write\r\n * @returns {Writer} `this`\r\n * @throws {TypeError} If `value` is a string and no long library is present.\r\n */\r\nWriterPrototype.uint64 = function write_uint64(value) {\r\n    var bits = LongBits.from(value);\r\n    return this.push(writeVarint64, bits.length(), bits);\r\n};\r\n\r\n/**\r\n * Writes a signed 64 bit value as a varint.\r\n * @function\r\n * @param {Long|number|string} value Value to write\r\n * @returns {Writer} `this`\r\n * @throws {TypeError} If `value` is a string and no long library is present.\r\n */\r\nWriterPrototype.int64 = WriterPrototype.uint64;\r\n\r\n/**\r\n * Writes a signed 64 bit value as a varint, zig-zag encoded.\r\n * @param {Long|number|string} value Value to write\r\n * @returns {Writer} `this`\r\n * @throws {TypeError} If `value` is a string and no long library is present.\r\n */\r\nWriterPrototype.sint64 = function write_sint64(value) {\r\n    var bits = LongBits.from(value).zzEncode();\r\n    return this.push(writeVarint64, bits.length(), bits);\r\n};\r\n\r\n/**\r\n * Writes a boolish value as a varint.\r\n * @param {boolean} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.bool = function write_bool(value) {\r\n    return this.push(writeByte, 1, value ? 1 : 0);\r\n};\r\n\r\nfunction writeFixed32(val, buf, pos) {\r\n    buf[pos++] =  val         & 255;\r\n    buf[pos++] =  val >>> 8   & 255;\r\n    buf[pos++] =  val >>> 16  & 255;\r\n    buf[pos  ] =  val >>> 24;\r\n}\r\n\r\n/**\r\n * Writes a 32 bit value as fixed 32 bits.\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.fixed32 = function write_fixed32(value) {\r\n    return this.push(writeFixed32, 4, value >>> 0);\r\n};\r\n\r\n/**\r\n * Writes a 32 bit value as fixed 32 bits, zig-zag encoded.\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.sfixed32 = function write_sfixed32(value) {\r\n    return this.push(writeFixed32, 4, value << 1 ^ value >> 31);\r\n};\r\n\r\n/**\r\n * Writes a 64 bit value as fixed 64 bits.\r\n * @param {Long|number|string} value Value to write\r\n * @returns {Writer} `this`\r\n * @throws {TypeError} If `value` is a string and no long library is present.\r\n */\r\nWriterPrototype.fixed64 = function write_fixed64(value) {\r\n    var bits = LongBits.from(value);\r\n    return this.push(writeFixed32, 4, bits.lo).push(writeFixed32, 4, bits.hi);\r\n};\r\n\r\n/**\r\n * Writes a 64 bit value as fixed 64 bits, zig-zag encoded.\r\n * @param {Long|number|string} value Value to write\r\n * @returns {Writer} `this`\r\n * @throws {TypeError} If `value` is a string and no long library is present.\r\n */\r\nWriterPrototype.sfixed64 = function write_sfixed64(value) {\r\n    var bits = LongBits.from(value).zzEncode();\r\n    return this.push(writeFixed32, 4, bits.lo).push(writeFixed32, 4, bits.hi);\r\n};\r\n\r\nvar writeFloat = typeof Float32Array !== \"undefined\"\r\n    ? (function() { // eslint-disable-line wrap-iife\r\n        var f32 = new Float32Array(1),\r\n            f8b = new Uint8Array(f32.buffer);\r\n        f32[0] = -0;\r\n        return f8b[3] // already le?\r\n            ? function writeFloat_f32(val, buf, pos) {\r\n                f32[0] = val;\r\n                buf[pos++] = f8b[0];\r\n                buf[pos++] = f8b[1];\r\n                buf[pos++] = f8b[2];\r\n                buf[pos  ] = f8b[3];\r\n            }\r\n            : function writeFloat_f32_le(val, buf, pos) {\r\n                f32[0] = val;\r\n                buf[pos++] = f8b[3];\r\n                buf[pos++] = f8b[2];\r\n                buf[pos++] = f8b[1];\r\n                buf[pos  ] = f8b[0];\r\n            };\r\n    })()\r\n    : function writeFloat_ieee754(val, buf, pos) {\r\n        ieee754.write(buf, val, pos, false, 23, 4);\r\n    };\r\n\r\n/**\r\n * Writes a float (32 bit).\r\n * @function\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.float = function write_float(value) {\r\n    return this.push(writeFloat, 4, value);\r\n};\r\n\r\nvar writeDouble = typeof Float64Array !== \"undefined\"\r\n    ? (function() { // eslint-disable-line wrap-iife\r\n        var f64 = new Float64Array(1),\r\n            f8b = new Uint8Array(f64.buffer);\r\n        f64[0] = -0;\r\n        return f8b[7] // already le?\r\n            ? function writeDouble_f64(val, buf, pos) {\r\n                f64[0] = val;\r\n                buf[pos++] = f8b[0];\r\n                buf[pos++] = f8b[1];\r\n                buf[pos++] = f8b[2];\r\n                buf[pos++] = f8b[3];\r\n                buf[pos++] = f8b[4];\r\n                buf[pos++] = f8b[5];\r\n                buf[pos++] = f8b[6];\r\n                buf[pos  ] = f8b[7];\r\n            }\r\n            : function writeDouble_f64_le(val, buf, pos) {\r\n                f64[0] = val;\r\n                buf[pos++] = f8b[7];\r\n                buf[pos++] = f8b[6];\r\n                buf[pos++] = f8b[5];\r\n                buf[pos++] = f8b[4];\r\n                buf[pos++] = f8b[3];\r\n                buf[pos++] = f8b[2];\r\n                buf[pos++] = f8b[1];\r\n                buf[pos  ] = f8b[0];\r\n            };\r\n    })()\r\n    : function writeDouble_ieee754(val, buf, pos) {\r\n        ieee754.write(buf, val, pos, false, 52, 8);\r\n    };\r\n\r\n/**\r\n * Writes a double (64 bit float).\r\n * @function\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.double = function write_double(value) {\r\n    return this.push(writeDouble, 8, value);\r\n};\r\n\r\nvar writeBytes = ArrayImpl.prototype.set\r\n    ? function writeBytes_set(val, buf, pos) {\r\n        buf.set(val, pos);\r\n    }\r\n    : function writeBytes_for(val, buf, pos) {\r\n        for (var i = 0; i < val.length; ++i)\r\n            buf[pos + i] = val[i];\r\n    };\r\n\r\n/**\r\n * Writes a sequence of bytes.\r\n * @param {Uint8Array|string} value Buffer or base64 encoded string to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.bytes = function write_bytes(value) {\r\n    var len = value.length >>> 0;\r\n    if (typeof value === \"string\" && len) {\r\n        var buf = Writer.alloc(len = base64.length(value));\r\n        base64.decode(value, buf, 0);\r\n        value = buf;\r\n    }\r\n    return len\r\n        ? this.uint32(len).push(writeBytes, len, value)\r\n        : this.push(writeByte, 1, 0);\r\n};\r\n\r\n/**\r\n * Writes a string.\r\n * @param {string} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.string = function write_string(value) {\r\n    var len = utf8.length(value);\r\n    return len\r\n        ? this.uint32(len).push(utf8.write, len, value)\r\n        : this.push(writeByte, 1, 0);\r\n};\r\n\r\n/**\r\n * Forks this writer's state by pushing it to a stack.\r\n * Calling {@link Writer#reset} or {@link Writer#ldelim} resets the writer to the previous state.\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.fork = function fork() {\r\n    this.states = new State(this);\r\n    this.head = this.tail = new Op(noop, 0, 0);\r\n    this.len = 0;\r\n    return this;\r\n};\r\n\r\n/**\r\n * Resets this instance to the last state.\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.reset = function reset() {\r\n    if (this.states) {\r\n        this.head   = this.states.head;\r\n        this.tail   = this.states.tail;\r\n        this.len    = this.states.len;\r\n        this.states = this.states.next;\r\n    } else {\r\n        this.head = this.tail = new Op(noop, 0, 0);\r\n        this.len  = 0;\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.\r\n * @param {number} [id] Id with wire type 2 to prepend as a tag where applicable\r\n * @returns {Writer} `this`\r\n */\r\nWriterPrototype.ldelim = function ldelim(id) {\r\n    var head = this.head,\r\n        tail = this.tail,\r\n        len  = this.len;\r\n    this.reset();\r\n    if (id)\r\n        this.uint32((id << 3 | 2) >>> 0);\r\n    this.uint32(len);\r\n    this.tail.next = head.next; // skip noop\r\n    this.tail = tail;\r\n    this.len += len;\r\n    return this;\r\n};\r\n\r\n/**\r\n * Finishes the write operation.\r\n * @returns {Uint8Array} Finished buffer\r\n */\r\nWriterPrototype.finish = function finish() {\r\n    var head = this.head.next, // skip noop\r\n        buf  = this.constructor.alloc(this.len),\r\n        pos  = 0;\r\n    while (head) {\r\n        head.fn(head.val, buf, pos);\r\n        pos += head.len;\r\n        head = head.next;\r\n    }\r\n    this.head = this.tail = null; // gc\r\n    return buf;\r\n};\r\n\r\n/**\r\n * Constructs a new buffer writer instance.\r\n * @classdesc Wire format writer using node buffers.\r\n * @exports BufferWriter\r\n * @extends Writer\r\n * @constructor\r\n */\r\nfunction BufferWriter() {\r\n    Writer.call(this);\r\n}\r\n\r\n/**\r\n * Allocates a buffer of the specified size.\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n */\r\nBufferWriter.alloc = function alloc_buffer(size) {\r\n    BufferWriter.alloc = util.Buffer.allocUnsafe\r\n        ? util.Buffer.allocUnsafe\r\n        : function allocUnsafeNew(size) { return new util.Buffer(size); };\r\n    return BufferWriter.alloc(size);\r\n};\r\n\r\n/** @alias BufferWriter.prototype */\r\nvar BufferWriterPrototype = BufferWriter.prototype = Object.create(Writer.prototype);\r\nBufferWriterPrototype.constructor = BufferWriter;\r\n\r\nfunction writeFloatBuffer(val, buf, pos) {\r\n    buf.writeFloatLE(val, pos, true);\r\n}\r\n\r\nif (typeof Float32Array === \"undefined\") // f32 is faster (node 6.9.1)\r\n/**\r\n * @override\r\n */\r\nBufferWriterPrototype.float = function write_float_buffer(value) {\r\n    return this.push(writeFloatBuffer, 4, value);\r\n};\r\n\r\nfunction writeDoubleBuffer(val, buf, pos) {\r\n    buf.writeDoubleLE(val, pos, true);\r\n}\r\n\r\nif (typeof Float64Array === \"undefined\") // f64 is faster (node 6.9.1)\r\n/**\r\n * @override\r\n */\r\nBufferWriterPrototype.double = function write_double_buffer(value) {\r\n    return this.push(writeDoubleBuffer, 8, value);\r\n};\r\n\r\nfunction writeBytesBuffer(val, buf, pos) {\r\n    if (val.length)\r\n        val.copy(buf, pos, 0, val.length);\r\n}\r\n\r\n/**\r\n * @override\r\n */\r\nBufferWriterPrototype.bytes = function write_bytes_buffer(value) {\r\n    if (typeof value === \"string\")\r\n        value = util.Buffer.from ? util.Buffer.from(value, \"base64\") : new util.Buffer(value, \"base64\");\r\n    var len = value.length >>> 0;\r\n    return len\r\n        ? this.uint32(len).push(writeBytesBuffer, len, value)\r\n        : this.push(writeByte, 1, 0);\r\n};\r\n\r\nvar writeStringBuffer = (function() { // eslint-disable-line wrap-iife\r\n    return util.Buffer && util.Buffer.prototype.utf8Write // around forever, but not present in browser buffer\r\n        ? function writeString_buffer_utf8Write(val, buf, pos) {\r\n            if (val.length < 40)\r\n                utf8.write(val, buf, pos);\r\n            else\r\n                buf.utf8Write(val, pos);\r\n        }\r\n        : function writeString_buffer_write(val, buf, pos) {\r\n            if (val.length < 40)\r\n                utf8.write(val, buf, pos);\r\n            else\r\n                buf.write(val, pos);\r\n        };\r\n    // Note that the plain JS encoder is faster for short strings, probably because of redundant assertions.\r\n    // For a raw utf8Write, the breaking point is about 20 characters, for write it is around 40 characters.\r\n    // Unfortunately, this does not translate 1:1 to real use cases, hence the common \"good enough\" limit of 40.\r\n})();\r\n\r\n/**\r\n * @override\r\n */\r\nBufferWriterPrototype.string = function write_string_buffer(value) {\r\n    var len = value.length < 40\r\n        ? utf8.length(value)\r\n        : util.Buffer.byteLength(value);\r\n    return len\r\n        ? this.uint32(len).push(writeStringBuffer, len, value)\r\n        : this.push(writeByte, 1, 0);\r\n};\r\n"],"sourceRoot":"."}