{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/browser/arrayBufferReader.js","lib/browser/fileReader.js","lib/browser/zlib.js","lib/buffer.js","lib/nodejs/fsReader.js","lib/nodejs/zlib.js","lib/pbfParser.js","lib/proto/index.js","node_modules/@protobufjs/aspromise/index.js","node_modules/@protobufjs/base64/index.js","node_modules/@protobufjs/eventemitter/index.js","node_modules/@protobufjs/float/index.js","node_modules/@protobufjs/inquire/index.js","node_modules/@protobufjs/pool/index.js","node_modules/@protobufjs/utf8/index.js","node_modules/protobufjs/minimal.js","node_modules/protobufjs/src/index-minimal.js","node_modules/protobufjs/src/reader.js","node_modules/protobufjs/src/reader_buffer.js","node_modules/protobufjs/src/roots.js","node_modules/protobufjs/src/rpc.js","node_modules/protobufjs/src/rpc/service.js","node_modules/protobufjs/src/util/longbits.js","node_modules/protobufjs/src/util/minimal.js","node_modules/protobufjs/src/writer.js","node_modules/protobufjs/src/writer_buffer.js","node_modules/setimmediate/setImmediate.js","node_modules/zlibjs/bin/inflate.min.js"],"names":["readBlobHeaderSize","fd","position","size","callback","DataView","getInt32","readPBFElement","pbfDecode","buffer","Uint8Array","set","setImmediate","buf","readPBFElementFromBuffer","getFileSize","byteLength","get","url","xhr","XMLHttpRequest","open","responseType","onerror","evt","Error","this","status","statusText","onload","response","send","opts","filePath","close","require","module","exports","file","read","err","headerSize","reader","slice","FileReader","e","error","code","result","webkitSlice","readAsArrayBuffer","inflateBlob","blob","Zlib","Inflate","zlibData","bufferSize","rawSize","decompress","bytesReadFail","expectedBytes","readBytes","Buffer","fs","bytesRead","readInt32BE","fstat","fdStatus","zlib","inflate","parse","pause","paused","resume","resumeCallback","documentEndReached","createPathParser","parser","fail","visitNextBlock","fileBlock","nextFileBlockIndex","fileBlocks","length","endDocument","readBlock","block","visitBlock","getReader","createFileParser","arrayBufferReader","fileReader","BLOCK_VISITORS_BY_TYPE","blobHeader","type","visitOSMHeaderBlock","visitOSMDataBlock","i","primitivegroup","visitPrimitiveGroup","pg","node","nodesView","way","waysView","relation","relationsView","readBlobHeaderContent","proto","OSMPBF","BlobHeader","decode","readFileBlock","BLOB_HEADER_SIZE_SIZE","blobHeaderSize","datasize","readFileBlocks","fileSize","readNextFileBlock","push","getStringTableEntry","s","str","cache","protobuf","util","utf8","extendStringTable","st","getEntry","createNodesView","pb","nodeDeltaData","deltaData","id","lat","toNumber","latOffset","granularity","lon","lonOffset","tags","tagsList","dense","denseinfo","version","timestamp","changeset","uid","user","stringtable","userIndex","nodes","keyId","keysVals","valId","key","val","deltaDataList","userSid","dateGranularity","createTagsObject","entity","len","keyI","valI","keys","vals","addInfo","info","createWaysView","ways","toString","nodeRefs","nodeIds","lastRefId","refs","createRelationsView","relations","members","memberObj","MemberType","Relation","memids","ref","role","rolesSid","types","NODE","WAY","RELATION","x","extendPrimitiveGroup","decodePrimitiveBlock","data","PrimitiveBlock","findFileBlocksByBlobType","blobType","blocks","readBlob","Blob","OSM_BLOB_DECODER_BY_TYPE","self","OSMHeader","OSMData","HeaderBlock","createParser","$protobuf","$Reader","Reader","$Writer","Writer","$util","$root","roots","properties","Object","prototype","raw","newBuffer","lzmaData","OBSOLETEBzip2Data","create","encode","message","writer","hasOwnProperty","uint32","bytes","int32","encodeDelimited","ldelim","end","undefined","pos","tag","skipType","decodeDelimited","verify","isString","isInteger","fromObject","object","base64","toObject","options","defaults","String","Array","call","toJSON","constructor","toJSONOptions","indexdata","string","ProtocolError","instance","requiredFeatures","optionalFeatures","bbox","emptyArray","writingprogram","source","osmosisReplicationTimestamp","Long","fromBits","osmosisReplicationSequenceNumber","osmosisReplicationBaseUrl","HeaderBBox","fork","int64","isArray","low","high","TypeError","fromValue","unsigned","parseInt","LongBits","arrays","long","longs","Number","j","left","right","top","bottom","sint64","StringTable","PrimitiveGroup","changesets","Node","DenseNodes","Way","ChangeSet","Info","visible","bool","Boolean","DenseInfo","sint32","end2","enums","valuesById","values","asPromise","fn","ctx","params","arguments","offset","index","pending","Promise","resolve","reject","apply","p","n","charAt","Math","ceil","b64","s64","start","t","parts","chunk","b","fromCharCode","join","invalidEncoding","c","charCodeAt","test","EventEmitter","_listeners","on","off","listeners","splice","emit","args","factory","Float32Array","writeFloat_f32_cpy","f32","f8b","writeFloat_f32_rev","readFloat_f32_cpy","readFloat_f32_rev","le","writeFloatLE","writeFloatBE","readFloatLE","readFloatBE","writeFloat_ieee754","writeUint","sign","isNaN","round","exponent","floor","log","LN2","mantissa","pow","readFloat_ieee754","readUint","uint","NaN","Infinity","bind","writeUintLE","writeUintBE","readUintLE","readUintBE","Float64Array","writeDouble_f64_cpy","f64","writeDouble_f64_rev","readDouble_f64_cpy","readDouble_f64_rev","writeDoubleLE","writeDoubleBE","readDoubleLE","readDoubleBE","writeDouble_ieee754","off0","off1","readDouble_ieee754","lo","hi","inquire","moduleName","mod","eval","replace","pool","alloc","SIZE","MAX","slab","write","c1","c2","configure","_configure","BufferReader","build","BufferWriter","rpc","indexOutOfRange","writeLength","RangeError","readLongVarint","bits","readFixed32_end","readFixed64","create_array","isBuffer","_slice","subarray","value","fixed32","sfixed32","float","double","skip","wireType","BufferReader_","merge","uint64","zzDecode","fixed64","sfixed64","utf8Slice","min","Service","rpcImpl","requestDelimited","responseDelimited","rpcCall","method","requestCtor","responseCtor","request","setTimeout","finish","endedByRPC","zero","zzEncode","zeroHash","fromNumber","from","fromString","toLong","fromHash","hash","toHash","mask","part0","part1","part2","dst","src","ifNotSet","newError","name","CustomError","defineProperty","captureStackTrace","stack","global","window","freeze","emptyObject","isNode","process","versions","isFinite","isObject","isset","isSet","obj","prop","utf8Write","_Buffer_from","_Buffer_allocUnsafe","sizeOrArray","dcodeIO","key2Re","key32Re","key64Re","longToHash","longFromHash","lcFirst","toLowerCase","substring","oneOfGetter","fieldNames","fieldMap","oneOfSetter","json","encoding","allocUnsafe","Op","next","noop","State","head","tail","states","writeByte","writeVarint32","VarintOp","writeVarint64","writeFixed32","_push","writeBytes","reset","BufferWriter_","writeStringBuffer","writeBytesBuffer","copy","addFromSetImmediateArguments","tasksByHandle","nextHandle","partiallyApplied","handler","Function","runIfPresent","handle","currentlyRunningATask","task","clearImmediate","doc","document","attachTo","getPrototypeOf","nextTick","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","random","onGlobalMessage","event","indexOf","addEventListener","attachEvent","MessageChannel","channel","port1","port2","createElement","html","documentElement","script","onreadystatechange","removeChild","appendChild","q","d","a","split","m","execScript","shift","f","g","h","k","l","r","K","POSITIVE_INFINITY","Uint32Array","u","input","v","bufferType","resize","w","A","z","y","T","B","D","U","V","Uint16Array","O","P","C","E","F","G","H","I","J","L","M","N","R","S","Q","o","X","Y","Z","$","W","ADAPTIVE","BLOCK"],"mappings":"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","file":"bundle.js","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","var buf = require('../buffer.js');\nrequire(\"setimmediate\");\n\nfunction readBlobHeaderSize(fd, position, size, callback){\n    var headerSize = new DataView(fd).getInt32(position, false);\n    return callback(null, headerSize);\n}\n\nfunction readPBFElement(fd, position, size, pbfDecode, callback){\n    //var buffer = new Uint8Array(fd, position, size);\n    var buffer = new Uint8Array(size);\n    buffer.set(new Uint8Array(fd, position, size));\n\n    // async call to avoid flooding the call stack when reading an already\n    // loaded ArrayBuffer in the Browser (#30)\n    setImmediate(function(){\n        buf.readPBFElementFromBuffer(buffer, pbfDecode, callback);\n    });\n}\n\nfunction getFileSize(fd, callback){\n    return callback(null, fd.byteLength);\n}\n\nfunction get(url, callback) {\n    var xhr = new XMLHttpRequest();\n    xhr.open('GET', url, true);\n    xhr.responseType = 'arraybuffer';\n    xhr.onerror = function(evt) {\n        callback(new Error(this.status + ': ' + this.statusText));\n    };\n    xhr.onload = function(evt) {\n        callback(null, this.response);\n    };\n    xhr.send();\n}\n\nfunction open(opts, callback){\n    if (opts.filePath) {\n        get(opts.filePath, callback);\n    } else if (opts.buffer) {\n        callback(null, opts.buffer);\n    } else {\n        callback(new Error('Use either the \"filePath\" option to pass an URL'\n            + ' or the \"buffer\" option to pass an ArrayBuffer.'));\n    }\n}\n\nfunction close(fd, callback){\n    if (callback) {\n        callback(null);\n    }\n}\n\nmodule.exports = {\n    readBlobHeaderSize: readBlobHeaderSize,\n    readPBFElement: readPBFElement,\n    getFileSize: getFileSize,\n    open: open,\n    close: close\n};\n","var buf = require('../buffer.js');\n\nfunction readBlobHeaderSize(file, position, size, callback){\n    read(file, position, size, function(err, buffer){\n        if (err) {\n            return callback(err);\n        }\n\n        var headerSize = new DataView(buffer).getInt32(0, false);\n        return callback(null, headerSize);\n    });\n}\n\nfunction readPBFElement(file, position, size, pbfDecode, callback){\n    read(file, position, size, function(err, buffer){\n        if(err){\n            return callback(err);\n        }\n\n        buf.readPBFElementFromBuffer(buffer, pbfDecode, callback);\n    });\n}\n\nfunction getFileSize(file, callback){\n    return callback(null, file.size);\n}\n\nfunction read(file, position, size, callback){\n    var reader, slice;\n\n    reader = new FileReader();\n\n    reader.onerror = function(e){\n        return callback(new Error('Error reading file (' + reader.error.code + ')'));\n    };\n    reader.onload = function(e){\n        return callback(null, reader.result);\n    };\n\n    // Safari still prefixed according to MDN (as of 11/2014)\n    // https://developer.mozilla.org/en-US/docs/Web/API/Blob.slice#Browser_compatibility\n    if(file.webkitSlice){\n        slice = file.webkitSlice(position, position + size);\n    } else {\n        slice = file.slice(position, position + size);\n    }\n\n    reader.readAsArrayBuffer(slice);\n}\n\nfunction open(opts, callback){\n    return callback(null, opts.file);\n}\n\nfunction close(file, callback){\n    if(callback){\n        return callback(null);\n    }\n}\n\nmodule.exports = {\n    readBlobHeaderSize: readBlobHeaderSize,\n    readPBFElement: readPBFElement,\n    getFileSize: getFileSize,\n    open: open,\n    close: close\n};\n","// don't use npm 'zlibjs' module, would require shims for the Node.js wrappers\nvar Zlib = require('../../node_modules/zlibjs/bin/inflate.min.js').Zlib;\n\nfunction inflateBlob(blob, callback){\n    var infl = new Zlib.Inflate(new Uint8Array(blob.zlibData), {\n        bufferSize: blob.rawSize\n    });\n    return callback(null, infl.decompress());\n}\n\nmodule.exports = {\n    inflateBlob: inflateBlob\n};\n","function readPBFElementFromBuffer(buffer, pbfDecode, callback){\n    return callback(null, pbfDecode(buffer));\n}\n\nmodule.exports = {\n    readPBFElementFromBuffer: readPBFElementFromBuffer\n};\n","var fs = require('fs');\nvar buf = require('../buffer.js');\n\nfunction bytesReadFail(callback, expectedBytes, readBytes){\n    return callback(new Error('Expected ' + expectedBytes + ' bytes but got ' + readBytes));\n}\n\nfunction readBlobHeaderSize(fd, position, size, callback){\n    var buffer;\n\n    buffer = new Buffer(size);\n\n    fs.read(fd, buffer, 0, size, position, function(err, bytesRead, buffer){\n        if(bytesRead !== size){\n            return bytesReadFail(callback, size, bytesRead);\n        }\n\n        return callback(null, buffer.readInt32BE(0));\n    });\n}\n\nfunction readPBFElement(fd, position, size, pbfDecode, callback){\n    var buffer;\n\n    if(size > 32 * 1024 * 1024){\n        return callback(new Error('PBF element too big: ' + size + ' bytes'));\n    }\n\n    buffer = new Buffer(size);\n\n    fs.read(fd, buffer, 0, size, position, function(err, bytesRead, buffer){\n        if(bytesRead !== size){\n            return bytesReadFail(callback, size, bytesRead);\n        }\n\n        return buf.readPBFElementFromBuffer(buffer, pbfDecode, callback);\n    });\n}\n\nfunction getFileSize(fd, callback){\n    fs.fstat(fd, function(err, fdStatus){\n        return callback(err, fdStatus.size);\n    });\n}\n\nfunction open(opts, callback){\n    fs.open(opts.filePath, 'r', callback);\n}\n\nfunction close(fd, callback){\n    return fs.close(fd, callback || function(){});\n}\n\nmodule.exports = {\n    readBlobHeaderSize: readBlobHeaderSize,\n    readPBFElement: readPBFElement,\n    getFileSize: getFileSize,\n    open: open,\n    close: close\n};\n","var zlib = require('zlib');\n\nfunction inflateBlob(blob, callback){\n    zlib.inflate(blob.zlibData, callback);\n}\n\nmodule.exports = {\n    inflateBlob: inflateBlob\n};\n","/*\n * The following little overview extends the osm pbf file structure description\n * from http://wiki.openstreetmap.org/wiki/PBF_Format:\n *\n * - [1] file\n *   - [n] file blocks\n *     - [1] blob header\n *     - [1] blob\n */\n\nvar protobuf = require('protobufjs/minimal');\nvar proto = require('./proto');\nvar buf = require('./buffer.js');\n\nvar zlib, reader, arrayBufferReader, fileReader;\n\n// check if running in Browser or Node.js (use self not window because of Web Workers)\nif (typeof self !== 'undefined') {\n    zlib = require('./browser/zlib.js');\n    arrayBufferReader = require('./browser/arrayBufferReader.js');\n    fileReader = require('./browser/fileReader.js');\n} else {\n    zlib = require('./nodejs/zlib.js');\n    reader = require('./nodejs/fsReader.js');\n}\n\nfunction parse(opts){\n    var paused, resumeCallback, documentEndReached;\n\n    documentEndReached = false;\n    paused = false;\n    resumeCallback = null;\n\n    createPathParser({\n        filePath: opts.filePath,\n        buffer: opts.buffer,\n        file: opts.file,\n        callback: function(err, parser){\n            var nextFileBlockIndex;\n\n            function fail(err){\n                if( parser ){\n                    parser.close();\n                }\n\n                return opts.error(err);\n            }\n\n            if(err){\n                return fail(err);\n            }\n\n            nextFileBlockIndex = 0;\n\n            function visitNextBlock(){\n                var fileBlock;\n\n                if(documentEndReached || paused){\n                    return;\n                }\n\n                if(nextFileBlockIndex >= parser.fileBlocks.length){\n                    documentEndReached = true;\n\n                    parser.close();\n\n                    opts.endDocument();\n\n                    return;\n                }\n\n                fileBlock = parser.fileBlocks[nextFileBlockIndex];\n\n                parser.readBlock(fileBlock, function(err, block){\n                    if(err){\n                        return fail(err);\n                    }\n\n                    visitBlock(fileBlock, block, opts);\n\n                    nextFileBlockIndex += 1;\n\n                    visitNextBlock();\n                });\n            }\n\n            resumeCallback = visitNextBlock;\n\n            visitNextBlock();\n        }\n    });\n\n    function pause(){\n        paused = true;\n    }\n\n    function resume(){\n        paused = false;\n\n        if(resumeCallback){\n            resumeCallback();\n        }\n    }\n\n    return {\n        pause: pause,\n\n        resume: resume\n    };\n}\n\nfunction createPathParser(opts){\n    reader = getReader(opts);\n    reader.open(opts, function(err, fd){\n        createFileParser(fd, function(err, parser){\n            if(err){\n                return opts.callback(err);\n            }\n\n            parser.close = function(callback){\n                return reader.close(fd, callback);\n            };\n\n            return opts.callback(null, parser);\n        });\n    });\n}\n\nfunction getReader(opts){\n    if(!arrayBufferReader){\n        // Node.js\n        return reader;\n    }\n\n    if(opts.file){\n        return fileReader;\n    }\n    return arrayBufferReader;\n}\n\nfunction visitBlock(fileBlock, block, opts){\n    BLOCK_VISITORS_BY_TYPE[fileBlock.blobHeader.type](block, opts);\n}\n\nfunction visitOSMHeaderBlock(block, opts){\n    // TODO\n}\n\nfunction visitOSMDataBlock(block, opts){\n    var i;\n\n    for(i = 0; i < block.primitivegroup.length; ++i){\n        visitPrimitiveGroup(block.primitivegroup[i], opts);\n    }\n}\n\nfunction visitPrimitiveGroup(pg, opts){\n    var i;\n\n    // visit nodes\n    if(opts.node){\n        for(i = 0; i < pg.nodesView.length; ++i){\n            opts.node(pg.nodesView.get(i));\n        }\n    }\n\n    // visit ways\n    if(opts.way){\n        for(i = 0; i < pg.waysView.length; ++i){\n            opts.way(pg.waysView.get(i));\n        }\n    }\n\n    // visit relations\n    if(opts.relation){\n        for(i = 0; i < pg.relationsView.length; ++i){\n            opts.relation(pg.relationsView.get(i));\n        }\n    }\n}\n\nvar BLOCK_VISITORS_BY_TYPE = {\n    OSMHeader: visitOSMHeaderBlock,\n    OSMData: visitOSMDataBlock\n};\n\nvar BLOB_HEADER_SIZE_SIZE = 4;\n\nfunction readBlobHeaderContent(fd, position, size, callback){\n    return reader.readPBFElement(fd, position, size, proto.OSMPBF.BlobHeader.decode, callback);\n}\n\nfunction readFileBlock(fd, position, callback){\n    reader.readBlobHeaderSize(fd, position, BLOB_HEADER_SIZE_SIZE, function(err, blobHeaderSize){\n        if(err){\n            return callback(err);\n        }\n\n        return readBlobHeaderContent(fd, position + BLOB_HEADER_SIZE_SIZE, blobHeaderSize, function(err, blobHeader){\n            if(err){\n                return callback(err);\n            }\n\n            blobHeader.position = position + BLOB_HEADER_SIZE_SIZE + blobHeaderSize;\n\n            return callback(err, {\n                position: position,\n                size: BLOB_HEADER_SIZE_SIZE + blobHeaderSize + blobHeader.datasize,\n                blobHeader: blobHeader\n            });\n        });\n    });\n}\n\nfunction readFileBlocks(fd, callback){\n    reader.getFileSize(fd, function(err, fileSize){\n        var position, fileBlocks;\n\n        position = 0;\n        fileBlocks = [];\n\n        function readNextFileBlock(){\n            readFileBlock(fd, position, function(err, fileBlock){\n                if(err){\n                    return callback(err);\n                }\n\n                fileBlocks.push(fileBlock);\n\n                position = fileBlock.position + fileBlock.size;\n\n                if(position < fileSize){\n                    readNextFileBlock();\n                }\n                else{\n                    return callback(null, fileBlocks);\n                }\n            });\n        }\n\n        readNextFileBlock();\n    });\n}\n\nfunction getStringTableEntry(i){\n    var s, str;\n\n    // decode StringTable entry only once and cache\n    if (i in this.cache) {\n        str = this.cache[i];\n    } else {\n        s = this.s[i];\n\n        str = protobuf.util.utf8.read(s, 0, s.length);\n        this.cache[i] = str;\n    }\n\n    return str;\n}\n\nfunction extendStringTable(st){\n    st.cache = {};\n    st.getEntry = getStringTableEntry;\n}\n\nfunction createNodesView(pb, pg){\n    var length, tagsList, deltaData;\n\n    if(pg.nodes.length !== 0){\n        throw new Error('primitivegroup.nodes.length !== 0 not supported yet');\n    }\n\n    length = 0;\n\n    if(pg.dense){\n        length = pg.dense.id.length;\n    }\n\n    function createTagsList(){\n        var tagsList, i, tagsListI, tags, keyId, keysVals, valId, key, val;\n\n        if(!pg.dense){\n            return null;\n        }\n\n        keysVals = pg.dense.keysVals;\n        tags = {};\n        tagsList = [];\n\n        for(i = 0; i < keysVals.length;){\n            keyId = keysVals[i++];\n\n            if(keyId === 0){\n                tagsList.push(tags);\n\n                tags = {};\n\n                continue;\n            }\n\n            valId = keysVals[i++];\n\n            key = pb.stringtable.getEntry(keyId);\n            val = pb.stringtable.getEntry(valId);\n\n            tags[key] = val;\n        }\n\n        return tagsList;\n    }\n\n    tagsList = createTagsList();\n\n    function collectDeltaData(){\n        var i, id, timestamp, changeset, uid, userIndex, deltaDataList, deltaData, lat, lon;\n\n        if(!pg.dense){\n            return null;\n        }\n\n        id = 0;\n        lat = 0;\n        lon = 0;\n\n        if(pg.dense.denseinfo){\n            timestamp = 0;\n            changeset = 0;\n            uid = 0;\n            userIndex = 0;\n        }\n\n        deltaDataList = [];\n\n        for(i = 0; i < length; ++i){\n            // TODO we should test wheather adding 64bit numbers works fine with high values\n            id += toNumber(pg.dense.id[i]);\n\n            lat += toNumber(pg.dense.lat[i]);\n            lon += toNumber(pg.dense.lon[i]);\n\n            deltaData = {\n                id: id,\n                lat: lat,\n                lon: lon\n            };\n\n            if(pg.dense.denseinfo){\n                // TODO we should test wheather adding 64bit numbers works fine with high values\n                timestamp += toNumber(pg.dense.denseinfo.timestamp[i]);\n                changeset += toNumber(pg.dense.denseinfo.changeset[i]);\n\n                // TODO we should test wheather adding 64bit numbers works fine with high values\n                uid += pg.dense.denseinfo.uid[i];\n\n                userIndex += pg.dense.denseinfo.userSid[i];\n\n                deltaData.timestamp = timestamp * pb.dateGranularity;\n                deltaData.changeset = changeset;\n                deltaData.uid = uid;\n                deltaData.userIndex = userIndex;\n            }\n\n            deltaDataList.push(deltaData);\n        }\n\n        return deltaDataList;\n    }\n\n    deltaData = collectDeltaData();\n\n    function get(i){\n        var node, nodeDeltaData;\n\n        nodeDeltaData = deltaData[i];\n\n        node = {\n            id: '' + nodeDeltaData.id,\n            lat: (toNumber(pb.latOffset) + (pb.granularity * nodeDeltaData.lat)) / 1000000000,\n            lon: (toNumber(pb.lonOffset) + (pb.granularity * nodeDeltaData.lon)) / 1000000000,\n            tags: tagsList[i]\n        };\n\n        if(pg.dense.denseinfo){\n            node.version = pg.dense.denseinfo.version[i];\n            node.timestamp = nodeDeltaData.timestamp;\n            node.changeset = nodeDeltaData.changeset;\n            node.uid = '' + nodeDeltaData.uid;\n            node.user = pb.stringtable.getEntry(nodeDeltaData.userIndex);\n        }\n\n        return node;\n    }\n\n    return {\n        length: length,\n        get: get\n    };\n}\n\nfunction createTagsObject(pb, entity){\n    var tags, i, len, keyI, valI, key, val;\n\n    tags = {};\n\n    for(i = 0, len = entity.keys.length; i < len; ++i){\n        keyI = entity.keys[i];\n        valI = entity.vals[i];\n\n        key = pb.stringtable.getEntry(keyI);\n        val = pb.stringtable.getEntry(valI);\n\n        tags[key] = val;\n    }\n\n    return tags;\n}\n\nfunction addInfo(pb, result, info){\n    if (info) {\n        if (info.version) {\n            result.version = info.version;\n        }\n        if (info.timestamp) {\n            result.timestamp = toNumber(info.timestamp) * pb.dateGranularity;\n        }\n        if (info.changeset) {\n            result.changeset = toNumber(info.changeset);\n        }\n        if (info.uid) {\n            result.uid = '' + info.uid;\n        }\n        if (info.userSid) {\n            result.user = pb.stringtable.getEntry(info.userSid);\n        }\n    }\n}\n\nfunction createWaysView(pb, pg){\n    var length;\n\n    length = pg.ways.length;\n\n    function get(i){\n        var way, result, info;\n\n        way = pg.ways[i];\n\n        function createNodeRefIds(){\n            var nodeIds, lastRefId, i;\n\n            nodeIds = [];\n            lastRefId = 0;\n\n            for(i = 0; i < way.refs.length; ++i){\n                // TODO we should test wheather adding 64bit numbers works fine with high values\n                lastRefId += toNumber(way.refs[i]);\n\n                nodeIds.push('' + lastRefId);\n            }\n\n            return nodeIds;\n        }\n\n        result = {\n            id: way.id.toString(),\n            tags: createTagsObject(pb, way),\n            nodeRefs: createNodeRefIds()\n        };\n\n        addInfo(pb, result, way.info);\n\n        return result;\n    }\n\n    return {\n        length: length,\n        get: get\n    };\n}\n\nfunction createRelationsView(pb, pg){\n    var length;\n\n    length = pg.relations.length;\n\n    function get(i){\n        var relation, result, info;\n\n        relation = pg.relations[i];\n\n        function createMembers(){\n            var members, memberObj, lastRefId, i, MemberType, type;\n\n            MemberType = proto.OSMPBF.Relation.MemberType;\n            members = [];\n            lastRefId = 0;\n\n            for(i = 0; i < relation.memids.length; ++i){\n                memberObj = {};\n\n                // TODO we should test wheather adding 64bit numbers works fine with high values\n                lastRefId += toNumber(relation.memids[i]);\n                memberObj.ref = '' + lastRefId;\n\n                memberObj.role = pb.stringtable.getEntry(relation.rolesSid[i]);\n\n                type = relation.types[i];\n                if (MemberType.NODE === type) {\n                    memberObj.type = 'node';\n                } else if(MemberType.WAY === type) {\n                    memberObj.type = 'way';\n                } else if(MemberType.RELATION === type) {\n                    memberObj.type = 'relation';\n                }\n\n                members.push(memberObj);\n            }\n\n            return members;\n        }\n\n        result = {\n            id: relation.id.toString(),\n            tags: createTagsObject(pb, relation),\n            members: createMembers()\n        };\n\n        addInfo(pb, result, relation.info);\n\n        return result;\n    }\n\n    return {\n        length: length,\n        get: get\n    };\n}\n\nfunction toNumber(x){\n    return typeof(x) === 'number' ? x : x.toNumber();\n}\n\nfunction extendPrimitiveGroup(pb, pg){\n    pg.nodesView = createNodesView(pb, pg);\n    pg.waysView = createWaysView(pb, pg);\n    pg.relationsView = createRelationsView(pb, pg);\n}\n\nfunction decodePrimitiveBlock(buffer){\n    var data, i;\n\n    data = proto.OSMPBF.PrimitiveBlock.decode(buffer);\n\n    // extend stringtable\n    extendStringTable(data.stringtable);\n\n    // extend primitivegroup\n    for(i = 0; i < data.primitivegroup.length; ++i){\n        extendPrimitiveGroup(data, data.primitivegroup[i]);\n    }\n\n    return data;\n}\n\nvar OSM_BLOB_DECODER_BY_TYPE = {\n    'OSMHeader': proto.OSMPBF.HeaderBlock.decode,\n    'OSMData': decodePrimitiveBlock\n};\n\nfunction createFileParser(fd, callback){\n    readFileBlocks(fd, function(err, fileBlocks){\n        if(err){\n            return callback(err);\n        }\n\n        function findFileBlocksByBlobType(blobType){\n            var blocks, i, block;\n\n            blocks = [];\n\n            for(i = 0; i < fileBlocks.length; ++i){\n                block = fileBlocks[i];\n\n                if(block.blobHeader.type !== blobType){\n                    continue;\n                }\n\n                blocks.push(block);\n            }\n\n            return blocks;\n        }\n\n        function readBlob(fileBlock, callback){\n            return reader.readPBFElement(fd, fileBlock.blobHeader.position, fileBlock.blobHeader.datasize, proto.OSMPBF.Blob.decode, callback);\n        }\n\n        function readBlock(fileBlock, callback){\n            return readBlob(fileBlock, function(err, blob){\n                if(err){\n                    return callback(err);\n                }\n\n                if(blob.rawSize === 0){\n                    return callback('Uncompressed pbfs are currently not supported.');\n                }\n\n                zlib.inflateBlob(blob, function(err, data){\n                    if(err){\n                        return callback(err);\n                    }\n\n                    return buf.readPBFElementFromBuffer(data, OSM_BLOB_DECODER_BY_TYPE[fileBlock.blobHeader.type], callback);\n                });\n            });\n        }\n\n        return callback(null, {\n            fileBlocks: fileBlocks,\n\n            findFileBlocksByBlobType: findFileBlocksByBlobType,\n\n            readBlock: readBlock\n        });\n    });\n}\n\nmodule.exports = {\n    parse: parse,\n\n    createParser: createPathParser\n};\n","/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/\n\"use strict\";\n\nvar $protobuf = require(\"protobufjs/minimal\");\n\n// Common aliases\nvar $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;\n\n// Exported root namespace\nvar $root = $protobuf.roots[\"default\"] || ($protobuf.roots[\"default\"] = {});\n\n$root.OSMPBF = (function() {\n\n    /**\n     * Namespace OSMPBF.\n     * @exports OSMPBF\n     * @namespace\n     */\n    var OSMPBF = {};\n\n    OSMPBF.Blob = (function() {\n\n        /**\n         * Properties of a Blob.\n         * @memberof OSMPBF\n         * @interface IBlob\n         * @property {Uint8Array|null} [raw] Blob raw\n         * @property {number|null} [rawSize] Blob rawSize\n         * @property {Uint8Array|null} [zlibData] Blob zlibData\n         * @property {Uint8Array|null} [lzmaData] Blob lzmaData\n         * @property {Uint8Array|null} [OBSOLETEBzip2Data] Blob OBSOLETEBzip2Data\n         */\n\n        /**\n         * Constructs a new Blob.\n         * @memberof OSMPBF\n         * @classdesc Represents a Blob.\n         * @implements IBlob\n         * @constructor\n         * @param {OSMPBF.IBlob=} [properties] Properties to set\n         */\n        function Blob(properties) {\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * Blob raw.\n         * @member {Uint8Array} raw\n         * @memberof OSMPBF.Blob\n         * @instance\n         */\n        Blob.prototype.raw = $util.newBuffer([]);\n\n        /**\n         * Blob rawSize.\n         * @member {number} rawSize\n         * @memberof OSMPBF.Blob\n         * @instance\n         */\n        Blob.prototype.rawSize = 0;\n\n        /**\n         * Blob zlibData.\n         * @member {Uint8Array} zlibData\n         * @memberof OSMPBF.Blob\n         * @instance\n         */\n        Blob.prototype.zlibData = $util.newBuffer([]);\n\n        /**\n         * Blob lzmaData.\n         * @member {Uint8Array} lzmaData\n         * @memberof OSMPBF.Blob\n         * @instance\n         */\n        Blob.prototype.lzmaData = $util.newBuffer([]);\n\n        /**\n         * Blob OBSOLETEBzip2Data.\n         * @member {Uint8Array} OBSOLETEBzip2Data\n         * @memberof OSMPBF.Blob\n         * @instance\n         */\n        Blob.prototype.OBSOLETEBzip2Data = $util.newBuffer([]);\n\n        /**\n         * Creates a new Blob instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {OSMPBF.IBlob=} [properties] Properties to set\n         * @returns {OSMPBF.Blob} Blob instance\n         */\n        Blob.create = function create(properties) {\n            return new Blob(properties);\n        };\n\n        /**\n         * Encodes the specified Blob message. Does not implicitly {@link OSMPBF.Blob.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {OSMPBF.IBlob} message Blob message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Blob.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            if (message.raw != null && message.hasOwnProperty(\"raw\"))\n                writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.raw);\n            if (message.rawSize != null && message.hasOwnProperty(\"rawSize\"))\n                writer.uint32(/* id 2, wireType 0 =*/16).int32(message.rawSize);\n            if (message.zlibData != null && message.hasOwnProperty(\"zlibData\"))\n                writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.zlibData);\n            if (message.lzmaData != null && message.hasOwnProperty(\"lzmaData\"))\n                writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.lzmaData);\n            if (message.OBSOLETEBzip2Data != null && message.hasOwnProperty(\"OBSOLETEBzip2Data\"))\n                writer.uint32(/* id 5, wireType 2 =*/42).bytes(message.OBSOLETEBzip2Data);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified Blob message, length delimited. Does not implicitly {@link OSMPBF.Blob.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {OSMPBF.IBlob} message Blob message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Blob.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a Blob message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.Blob} Blob\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Blob.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.Blob();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.raw = reader.bytes();\n                    break;\n                case 2:\n                    message.rawSize = reader.int32();\n                    break;\n                case 3:\n                    message.zlibData = reader.bytes();\n                    break;\n                case 4:\n                    message.lzmaData = reader.bytes();\n                    break;\n                case 5:\n                    message.OBSOLETEBzip2Data = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Decodes a Blob message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.Blob} Blob\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Blob.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a Blob message.\n         * @function verify\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        Blob.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (message.raw != null && message.hasOwnProperty(\"raw\"))\n                if (!(message.raw && typeof message.raw.length === \"number\" || $util.isString(message.raw)))\n                    return \"raw: buffer expected\";\n            if (message.rawSize != null && message.hasOwnProperty(\"rawSize\"))\n                if (!$util.isInteger(message.rawSize))\n                    return \"rawSize: integer expected\";\n            if (message.zlibData != null && message.hasOwnProperty(\"zlibData\"))\n                if (!(message.zlibData && typeof message.zlibData.length === \"number\" || $util.isString(message.zlibData)))\n                    return \"zlibData: buffer expected\";\n            if (message.lzmaData != null && message.hasOwnProperty(\"lzmaData\"))\n                if (!(message.lzmaData && typeof message.lzmaData.length === \"number\" || $util.isString(message.lzmaData)))\n                    return \"lzmaData: buffer expected\";\n            if (message.OBSOLETEBzip2Data != null && message.hasOwnProperty(\"OBSOLETEBzip2Data\"))\n                if (!(message.OBSOLETEBzip2Data && typeof message.OBSOLETEBzip2Data.length === \"number\" || $util.isString(message.OBSOLETEBzip2Data)))\n                    return \"OBSOLETEBzip2Data: buffer expected\";\n            return null;\n        };\n\n        /**\n         * Creates a Blob message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.Blob} Blob\n         */\n        Blob.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.Blob)\n                return object;\n            var message = new $root.OSMPBF.Blob();\n            if (object.raw != null)\n                if (typeof object.raw === \"string\")\n                    $util.base64.decode(object.raw, message.raw = $util.newBuffer($util.base64.length(object.raw)), 0);\n                else if (object.raw.length)\n                    message.raw = object.raw;\n            if (object.rawSize != null)\n                message.rawSize = object.rawSize | 0;\n            if (object.zlibData != null)\n                if (typeof object.zlibData === \"string\")\n                    $util.base64.decode(object.zlibData, message.zlibData = $util.newBuffer($util.base64.length(object.zlibData)), 0);\n                else if (object.zlibData.length)\n                    message.zlibData = object.zlibData;\n            if (object.lzmaData != null)\n                if (typeof object.lzmaData === \"string\")\n                    $util.base64.decode(object.lzmaData, message.lzmaData = $util.newBuffer($util.base64.length(object.lzmaData)), 0);\n                else if (object.lzmaData.length)\n                    message.lzmaData = object.lzmaData;\n            if (object.OBSOLETEBzip2Data != null)\n                if (typeof object.OBSOLETEBzip2Data === \"string\")\n                    $util.base64.decode(object.OBSOLETEBzip2Data, message.OBSOLETEBzip2Data = $util.newBuffer($util.base64.length(object.OBSOLETEBzip2Data)), 0);\n                else if (object.OBSOLETEBzip2Data.length)\n                    message.OBSOLETEBzip2Data = object.OBSOLETEBzip2Data;\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a Blob message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.Blob\n         * @static\n         * @param {OSMPBF.Blob} message Blob\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        Blob.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.defaults) {\n                if (options.bytes === String)\n                    object.raw = \"\";\n                else {\n                    object.raw = [];\n                    if (options.bytes !== Array)\n                        object.raw = $util.newBuffer(object.raw);\n                }\n                object.rawSize = 0;\n                if (options.bytes === String)\n                    object.zlibData = \"\";\n                else {\n                    object.zlibData = [];\n                    if (options.bytes !== Array)\n                        object.zlibData = $util.newBuffer(object.zlibData);\n                }\n                if (options.bytes === String)\n                    object.lzmaData = \"\";\n                else {\n                    object.lzmaData = [];\n                    if (options.bytes !== Array)\n                        object.lzmaData = $util.newBuffer(object.lzmaData);\n                }\n                if (options.bytes === String)\n                    object.OBSOLETEBzip2Data = \"\";\n                else {\n                    object.OBSOLETEBzip2Data = [];\n                    if (options.bytes !== Array)\n                        object.OBSOLETEBzip2Data = $util.newBuffer(object.OBSOLETEBzip2Data);\n                }\n            }\n            if (message.raw != null && message.hasOwnProperty(\"raw\"))\n                object.raw = options.bytes === String ? $util.base64.encode(message.raw, 0, message.raw.length) : options.bytes === Array ? Array.prototype.slice.call(message.raw) : message.raw;\n            if (message.rawSize != null && message.hasOwnProperty(\"rawSize\"))\n                object.rawSize = message.rawSize;\n            if (message.zlibData != null && message.hasOwnProperty(\"zlibData\"))\n                object.zlibData = options.bytes === String ? $util.base64.encode(message.zlibData, 0, message.zlibData.length) : options.bytes === Array ? Array.prototype.slice.call(message.zlibData) : message.zlibData;\n            if (message.lzmaData != null && message.hasOwnProperty(\"lzmaData\"))\n                object.lzmaData = options.bytes === String ? $util.base64.encode(message.lzmaData, 0, message.lzmaData.length) : options.bytes === Array ? Array.prototype.slice.call(message.lzmaData) : message.lzmaData;\n            if (message.OBSOLETEBzip2Data != null && message.hasOwnProperty(\"OBSOLETEBzip2Data\"))\n                object.OBSOLETEBzip2Data = options.bytes === String ? $util.base64.encode(message.OBSOLETEBzip2Data, 0, message.OBSOLETEBzip2Data.length) : options.bytes === Array ? Array.prototype.slice.call(message.OBSOLETEBzip2Data) : message.OBSOLETEBzip2Data;\n            return object;\n        };\n\n        /**\n         * Converts this Blob to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.Blob\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        Blob.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return Blob;\n    })();\n\n    OSMPBF.BlobHeader = (function() {\n\n        /**\n         * Properties of a BlobHeader.\n         * @memberof OSMPBF\n         * @interface IBlobHeader\n         * @property {string} type BlobHeader type\n         * @property {Uint8Array|null} [indexdata] BlobHeader indexdata\n         * @property {number} datasize BlobHeader datasize\n         */\n\n        /**\n         * Constructs a new BlobHeader.\n         * @memberof OSMPBF\n         * @classdesc Represents a BlobHeader.\n         * @implements IBlobHeader\n         * @constructor\n         * @param {OSMPBF.IBlobHeader=} [properties] Properties to set\n         */\n        function BlobHeader(properties) {\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * BlobHeader type.\n         * @member {string} type\n         * @memberof OSMPBF.BlobHeader\n         * @instance\n         */\n        BlobHeader.prototype.type = \"\";\n\n        /**\n         * BlobHeader indexdata.\n         * @member {Uint8Array} indexdata\n         * @memberof OSMPBF.BlobHeader\n         * @instance\n         */\n        BlobHeader.prototype.indexdata = $util.newBuffer([]);\n\n        /**\n         * BlobHeader datasize.\n         * @member {number} datasize\n         * @memberof OSMPBF.BlobHeader\n         * @instance\n         */\n        BlobHeader.prototype.datasize = 0;\n\n        /**\n         * Creates a new BlobHeader instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {OSMPBF.IBlobHeader=} [properties] Properties to set\n         * @returns {OSMPBF.BlobHeader} BlobHeader instance\n         */\n        BlobHeader.create = function create(properties) {\n            return new BlobHeader(properties);\n        };\n\n        /**\n         * Encodes the specified BlobHeader message. Does not implicitly {@link OSMPBF.BlobHeader.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {OSMPBF.IBlobHeader} message BlobHeader message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        BlobHeader.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            writer.uint32(/* id 1, wireType 2 =*/10).string(message.type);\n            if (message.indexdata != null && message.hasOwnProperty(\"indexdata\"))\n                writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.indexdata);\n            writer.uint32(/* id 3, wireType 0 =*/24).int32(message.datasize);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified BlobHeader message, length delimited. Does not implicitly {@link OSMPBF.BlobHeader.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {OSMPBF.IBlobHeader} message BlobHeader message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        BlobHeader.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a BlobHeader message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.BlobHeader} BlobHeader\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        BlobHeader.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.BlobHeader();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.string();\n                    break;\n                case 2:\n                    message.indexdata = reader.bytes();\n                    break;\n                case 3:\n                    message.datasize = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            if (!message.hasOwnProperty(\"type\"))\n                throw $util.ProtocolError(\"missing required 'type'\", { instance: message });\n            if (!message.hasOwnProperty(\"datasize\"))\n                throw $util.ProtocolError(\"missing required 'datasize'\", { instance: message });\n            return message;\n        };\n\n        /**\n         * Decodes a BlobHeader message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.BlobHeader} BlobHeader\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        BlobHeader.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a BlobHeader message.\n         * @function verify\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        BlobHeader.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (!$util.isString(message.type))\n                return \"type: string expected\";\n            if (message.indexdata != null && message.hasOwnProperty(\"indexdata\"))\n                if (!(message.indexdata && typeof message.indexdata.length === \"number\" || $util.isString(message.indexdata)))\n                    return \"indexdata: buffer expected\";\n            if (!$util.isInteger(message.datasize))\n                return \"datasize: integer expected\";\n            return null;\n        };\n\n        /**\n         * Creates a BlobHeader message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.BlobHeader} BlobHeader\n         */\n        BlobHeader.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.BlobHeader)\n                return object;\n            var message = new $root.OSMPBF.BlobHeader();\n            if (object.type != null)\n                message.type = String(object.type);\n            if (object.indexdata != null)\n                if (typeof object.indexdata === \"string\")\n                    $util.base64.decode(object.indexdata, message.indexdata = $util.newBuffer($util.base64.length(object.indexdata)), 0);\n                else if (object.indexdata.length)\n                    message.indexdata = object.indexdata;\n            if (object.datasize != null)\n                message.datasize = object.datasize | 0;\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a BlobHeader message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.BlobHeader\n         * @static\n         * @param {OSMPBF.BlobHeader} message BlobHeader\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        BlobHeader.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.defaults) {\n                object.type = \"\";\n                if (options.bytes === String)\n                    object.indexdata = \"\";\n                else {\n                    object.indexdata = [];\n                    if (options.bytes !== Array)\n                        object.indexdata = $util.newBuffer(object.indexdata);\n                }\n                object.datasize = 0;\n            }\n            if (message.type != null && message.hasOwnProperty(\"type\"))\n                object.type = message.type;\n            if (message.indexdata != null && message.hasOwnProperty(\"indexdata\"))\n                object.indexdata = options.bytes === String ? $util.base64.encode(message.indexdata, 0, message.indexdata.length) : options.bytes === Array ? Array.prototype.slice.call(message.indexdata) : message.indexdata;\n            if (message.datasize != null && message.hasOwnProperty(\"datasize\"))\n                object.datasize = message.datasize;\n            return object;\n        };\n\n        /**\n         * Converts this BlobHeader to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.BlobHeader\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        BlobHeader.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return BlobHeader;\n    })();\n\n    OSMPBF.HeaderBlock = (function() {\n\n        /**\n         * Properties of a HeaderBlock.\n         * @memberof OSMPBF\n         * @interface IHeaderBlock\n         * @property {OSMPBF.IHeaderBBox|null} [bbox] HeaderBlock bbox\n         * @property {Array.<string>|null} [requiredFeatures] HeaderBlock requiredFeatures\n         * @property {Array.<string>|null} [optionalFeatures] HeaderBlock optionalFeatures\n         * @property {string|null} [writingprogram] HeaderBlock writingprogram\n         * @property {string|null} [source] HeaderBlock source\n         * @property {number|Long|null} [osmosisReplicationTimestamp] HeaderBlock osmosisReplicationTimestamp\n         * @property {number|Long|null} [osmosisReplicationSequenceNumber] HeaderBlock osmosisReplicationSequenceNumber\n         * @property {string|null} [osmosisReplicationBaseUrl] HeaderBlock osmosisReplicationBaseUrl\n         */\n\n        /**\n         * Constructs a new HeaderBlock.\n         * @memberof OSMPBF\n         * @classdesc Represents a HeaderBlock.\n         * @implements IHeaderBlock\n         * @constructor\n         * @param {OSMPBF.IHeaderBlock=} [properties] Properties to set\n         */\n        function HeaderBlock(properties) {\n            this.requiredFeatures = [];\n            this.optionalFeatures = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * HeaderBlock bbox.\n         * @member {OSMPBF.IHeaderBBox|null|undefined} bbox\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.bbox = null;\n\n        /**\n         * HeaderBlock requiredFeatures.\n         * @member {Array.<string>} requiredFeatures\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.requiredFeatures = $util.emptyArray;\n\n        /**\n         * HeaderBlock optionalFeatures.\n         * @member {Array.<string>} optionalFeatures\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.optionalFeatures = $util.emptyArray;\n\n        /**\n         * HeaderBlock writingprogram.\n         * @member {string} writingprogram\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.writingprogram = \"\";\n\n        /**\n         * HeaderBlock source.\n         * @member {string} source\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.source = \"\";\n\n        /**\n         * HeaderBlock osmosisReplicationTimestamp.\n         * @member {number|Long} osmosisReplicationTimestamp\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.osmosisReplicationTimestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * HeaderBlock osmosisReplicationSequenceNumber.\n         * @member {number|Long} osmosisReplicationSequenceNumber\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.osmosisReplicationSequenceNumber = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * HeaderBlock osmosisReplicationBaseUrl.\n         * @member {string} osmosisReplicationBaseUrl\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         */\n        HeaderBlock.prototype.osmosisReplicationBaseUrl = \"\";\n\n        /**\n         * Creates a new HeaderBlock instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {OSMPBF.IHeaderBlock=} [properties] Properties to set\n         * @returns {OSMPBF.HeaderBlock} HeaderBlock instance\n         */\n        HeaderBlock.create = function create(properties) {\n            return new HeaderBlock(properties);\n        };\n\n        /**\n         * Encodes the specified HeaderBlock message. Does not implicitly {@link OSMPBF.HeaderBlock.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {OSMPBF.IHeaderBlock} message HeaderBlock message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        HeaderBlock.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            if (message.bbox != null && message.hasOwnProperty(\"bbox\"))\n                $root.OSMPBF.HeaderBBox.encode(message.bbox, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n            if (message.requiredFeatures != null && message.requiredFeatures.length)\n                for (var i = 0; i < message.requiredFeatures.length; ++i)\n                    writer.uint32(/* id 4, wireType 2 =*/34).string(message.requiredFeatures[i]);\n            if (message.optionalFeatures != null && message.optionalFeatures.length)\n                for (var i = 0; i < message.optionalFeatures.length; ++i)\n                    writer.uint32(/* id 5, wireType 2 =*/42).string(message.optionalFeatures[i]);\n            if (message.writingprogram != null && message.hasOwnProperty(\"writingprogram\"))\n                writer.uint32(/* id 16, wireType 2 =*/130).string(message.writingprogram);\n            if (message.source != null && message.hasOwnProperty(\"source\"))\n                writer.uint32(/* id 17, wireType 2 =*/138).string(message.source);\n            if (message.osmosisReplicationTimestamp != null && message.hasOwnProperty(\"osmosisReplicationTimestamp\"))\n                writer.uint32(/* id 32, wireType 0 =*/256).int64(message.osmosisReplicationTimestamp);\n            if (message.osmosisReplicationSequenceNumber != null && message.hasOwnProperty(\"osmosisReplicationSequenceNumber\"))\n                writer.uint32(/* id 33, wireType 0 =*/264).int64(message.osmosisReplicationSequenceNumber);\n            if (message.osmosisReplicationBaseUrl != null && message.hasOwnProperty(\"osmosisReplicationBaseUrl\"))\n                writer.uint32(/* id 34, wireType 2 =*/274).string(message.osmosisReplicationBaseUrl);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified HeaderBlock message, length delimited. Does not implicitly {@link OSMPBF.HeaderBlock.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {OSMPBF.IHeaderBlock} message HeaderBlock message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        HeaderBlock.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a HeaderBlock message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.HeaderBlock} HeaderBlock\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        HeaderBlock.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.HeaderBlock();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.bbox = $root.OSMPBF.HeaderBBox.decode(reader, reader.uint32());\n                    break;\n                case 4:\n                    if (!(message.requiredFeatures && message.requiredFeatures.length))\n                        message.requiredFeatures = [];\n                    message.requiredFeatures.push(reader.string());\n                    break;\n                case 5:\n                    if (!(message.optionalFeatures && message.optionalFeatures.length))\n                        message.optionalFeatures = [];\n                    message.optionalFeatures.push(reader.string());\n                    break;\n                case 16:\n                    message.writingprogram = reader.string();\n                    break;\n                case 17:\n                    message.source = reader.string();\n                    break;\n                case 32:\n                    message.osmosisReplicationTimestamp = reader.int64();\n                    break;\n                case 33:\n                    message.osmosisReplicationSequenceNumber = reader.int64();\n                    break;\n                case 34:\n                    message.osmosisReplicationBaseUrl = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Decodes a HeaderBlock message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.HeaderBlock} HeaderBlock\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        HeaderBlock.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a HeaderBlock message.\n         * @function verify\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        HeaderBlock.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (message.bbox != null && message.hasOwnProperty(\"bbox\")) {\n                var error = $root.OSMPBF.HeaderBBox.verify(message.bbox);\n                if (error)\n                    return \"bbox.\" + error;\n            }\n            if (message.requiredFeatures != null && message.hasOwnProperty(\"requiredFeatures\")) {\n                if (!Array.isArray(message.requiredFeatures))\n                    return \"requiredFeatures: array expected\";\n                for (var i = 0; i < message.requiredFeatures.length; ++i)\n                    if (!$util.isString(message.requiredFeatures[i]))\n                        return \"requiredFeatures: string[] expected\";\n            }\n            if (message.optionalFeatures != null && message.hasOwnProperty(\"optionalFeatures\")) {\n                if (!Array.isArray(message.optionalFeatures))\n                    return \"optionalFeatures: array expected\";\n                for (var i = 0; i < message.optionalFeatures.length; ++i)\n                    if (!$util.isString(message.optionalFeatures[i]))\n                        return \"optionalFeatures: string[] expected\";\n            }\n            if (message.writingprogram != null && message.hasOwnProperty(\"writingprogram\"))\n                if (!$util.isString(message.writingprogram))\n                    return \"writingprogram: string expected\";\n            if (message.source != null && message.hasOwnProperty(\"source\"))\n                if (!$util.isString(message.source))\n                    return \"source: string expected\";\n            if (message.osmosisReplicationTimestamp != null && message.hasOwnProperty(\"osmosisReplicationTimestamp\"))\n                if (!$util.isInteger(message.osmosisReplicationTimestamp) && !(message.osmosisReplicationTimestamp && $util.isInteger(message.osmosisReplicationTimestamp.low) && $util.isInteger(message.osmosisReplicationTimestamp.high)))\n                    return \"osmosisReplicationTimestamp: integer|Long expected\";\n            if (message.osmosisReplicationSequenceNumber != null && message.hasOwnProperty(\"osmosisReplicationSequenceNumber\"))\n                if (!$util.isInteger(message.osmosisReplicationSequenceNumber) && !(message.osmosisReplicationSequenceNumber && $util.isInteger(message.osmosisReplicationSequenceNumber.low) && $util.isInteger(message.osmosisReplicationSequenceNumber.high)))\n                    return \"osmosisReplicationSequenceNumber: integer|Long expected\";\n            if (message.osmosisReplicationBaseUrl != null && message.hasOwnProperty(\"osmosisReplicationBaseUrl\"))\n                if (!$util.isString(message.osmosisReplicationBaseUrl))\n                    return \"osmosisReplicationBaseUrl: string expected\";\n            return null;\n        };\n\n        /**\n         * Creates a HeaderBlock message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.HeaderBlock} HeaderBlock\n         */\n        HeaderBlock.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.HeaderBlock)\n                return object;\n            var message = new $root.OSMPBF.HeaderBlock();\n            if (object.bbox != null) {\n                if (typeof object.bbox !== \"object\")\n                    throw TypeError(\".OSMPBF.HeaderBlock.bbox: object expected\");\n                message.bbox = $root.OSMPBF.HeaderBBox.fromObject(object.bbox);\n            }\n            if (object.requiredFeatures) {\n                if (!Array.isArray(object.requiredFeatures))\n                    throw TypeError(\".OSMPBF.HeaderBlock.requiredFeatures: array expected\");\n                message.requiredFeatures = [];\n                for (var i = 0; i < object.requiredFeatures.length; ++i)\n                    message.requiredFeatures[i] = String(object.requiredFeatures[i]);\n            }\n            if (object.optionalFeatures) {\n                if (!Array.isArray(object.optionalFeatures))\n                    throw TypeError(\".OSMPBF.HeaderBlock.optionalFeatures: array expected\");\n                message.optionalFeatures = [];\n                for (var i = 0; i < object.optionalFeatures.length; ++i)\n                    message.optionalFeatures[i] = String(object.optionalFeatures[i]);\n            }\n            if (object.writingprogram != null)\n                message.writingprogram = String(object.writingprogram);\n            if (object.source != null)\n                message.source = String(object.source);\n            if (object.osmosisReplicationTimestamp != null)\n                if ($util.Long)\n                    (message.osmosisReplicationTimestamp = $util.Long.fromValue(object.osmosisReplicationTimestamp)).unsigned = false;\n                else if (typeof object.osmosisReplicationTimestamp === \"string\")\n                    message.osmosisReplicationTimestamp = parseInt(object.osmosisReplicationTimestamp, 10);\n                else if (typeof object.osmosisReplicationTimestamp === \"number\")\n                    message.osmosisReplicationTimestamp = object.osmosisReplicationTimestamp;\n                else if (typeof object.osmosisReplicationTimestamp === \"object\")\n                    message.osmosisReplicationTimestamp = new $util.LongBits(object.osmosisReplicationTimestamp.low >>> 0, object.osmosisReplicationTimestamp.high >>> 0).toNumber();\n            if (object.osmosisReplicationSequenceNumber != null)\n                if ($util.Long)\n                    (message.osmosisReplicationSequenceNumber = $util.Long.fromValue(object.osmosisReplicationSequenceNumber)).unsigned = false;\n                else if (typeof object.osmosisReplicationSequenceNumber === \"string\")\n                    message.osmosisReplicationSequenceNumber = parseInt(object.osmosisReplicationSequenceNumber, 10);\n                else if (typeof object.osmosisReplicationSequenceNumber === \"number\")\n                    message.osmosisReplicationSequenceNumber = object.osmosisReplicationSequenceNumber;\n                else if (typeof object.osmosisReplicationSequenceNumber === \"object\")\n                    message.osmosisReplicationSequenceNumber = new $util.LongBits(object.osmosisReplicationSequenceNumber.low >>> 0, object.osmosisReplicationSequenceNumber.high >>> 0).toNumber();\n            if (object.osmosisReplicationBaseUrl != null)\n                message.osmosisReplicationBaseUrl = String(object.osmosisReplicationBaseUrl);\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a HeaderBlock message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.HeaderBlock\n         * @static\n         * @param {OSMPBF.HeaderBlock} message HeaderBlock\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        HeaderBlock.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults) {\n                object.requiredFeatures = [];\n                object.optionalFeatures = [];\n            }\n            if (options.defaults) {\n                object.bbox = null;\n                object.writingprogram = \"\";\n                object.source = \"\";\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.osmosisReplicationTimestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.osmosisReplicationTimestamp = options.longs === String ? \"0\" : 0;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.osmosisReplicationSequenceNumber = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.osmosisReplicationSequenceNumber = options.longs === String ? \"0\" : 0;\n                object.osmosisReplicationBaseUrl = \"\";\n            }\n            if (message.bbox != null && message.hasOwnProperty(\"bbox\"))\n                object.bbox = $root.OSMPBF.HeaderBBox.toObject(message.bbox, options);\n            if (message.requiredFeatures && message.requiredFeatures.length) {\n                object.requiredFeatures = [];\n                for (var j = 0; j < message.requiredFeatures.length; ++j)\n                    object.requiredFeatures[j] = message.requiredFeatures[j];\n            }\n            if (message.optionalFeatures && message.optionalFeatures.length) {\n                object.optionalFeatures = [];\n                for (var j = 0; j < message.optionalFeatures.length; ++j)\n                    object.optionalFeatures[j] = message.optionalFeatures[j];\n            }\n            if (message.writingprogram != null && message.hasOwnProperty(\"writingprogram\"))\n                object.writingprogram = message.writingprogram;\n            if (message.source != null && message.hasOwnProperty(\"source\"))\n                object.source = message.source;\n            if (message.osmosisReplicationTimestamp != null && message.hasOwnProperty(\"osmosisReplicationTimestamp\"))\n                if (typeof message.osmosisReplicationTimestamp === \"number\")\n                    object.osmosisReplicationTimestamp = options.longs === String ? String(message.osmosisReplicationTimestamp) : message.osmosisReplicationTimestamp;\n                else\n                    object.osmosisReplicationTimestamp = options.longs === String ? $util.Long.prototype.toString.call(message.osmosisReplicationTimestamp) : options.longs === Number ? new $util.LongBits(message.osmosisReplicationTimestamp.low >>> 0, message.osmosisReplicationTimestamp.high >>> 0).toNumber() : message.osmosisReplicationTimestamp;\n            if (message.osmosisReplicationSequenceNumber != null && message.hasOwnProperty(\"osmosisReplicationSequenceNumber\"))\n                if (typeof message.osmosisReplicationSequenceNumber === \"number\")\n                    object.osmosisReplicationSequenceNumber = options.longs === String ? String(message.osmosisReplicationSequenceNumber) : message.osmosisReplicationSequenceNumber;\n                else\n                    object.osmosisReplicationSequenceNumber = options.longs === String ? $util.Long.prototype.toString.call(message.osmosisReplicationSequenceNumber) : options.longs === Number ? new $util.LongBits(message.osmosisReplicationSequenceNumber.low >>> 0, message.osmosisReplicationSequenceNumber.high >>> 0).toNumber() : message.osmosisReplicationSequenceNumber;\n            if (message.osmosisReplicationBaseUrl != null && message.hasOwnProperty(\"osmosisReplicationBaseUrl\"))\n                object.osmosisReplicationBaseUrl = message.osmosisReplicationBaseUrl;\n            return object;\n        };\n\n        /**\n         * Converts this HeaderBlock to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.HeaderBlock\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        HeaderBlock.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return HeaderBlock;\n    })();\n\n    OSMPBF.HeaderBBox = (function() {\n\n        /**\n         * Properties of a HeaderBBox.\n         * @memberof OSMPBF\n         * @interface IHeaderBBox\n         * @property {number|Long} left HeaderBBox left\n         * @property {number|Long} right HeaderBBox right\n         * @property {number|Long} top HeaderBBox top\n         * @property {number|Long} bottom HeaderBBox bottom\n         */\n\n        /**\n         * Constructs a new HeaderBBox.\n         * @memberof OSMPBF\n         * @classdesc Represents a HeaderBBox.\n         * @implements IHeaderBBox\n         * @constructor\n         * @param {OSMPBF.IHeaderBBox=} [properties] Properties to set\n         */\n        function HeaderBBox(properties) {\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * HeaderBBox left.\n         * @member {number|Long} left\n         * @memberof OSMPBF.HeaderBBox\n         * @instance\n         */\n        HeaderBBox.prototype.left = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * HeaderBBox right.\n         * @member {number|Long} right\n         * @memberof OSMPBF.HeaderBBox\n         * @instance\n         */\n        HeaderBBox.prototype.right = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * HeaderBBox top.\n         * @member {number|Long} top\n         * @memberof OSMPBF.HeaderBBox\n         * @instance\n         */\n        HeaderBBox.prototype.top = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * HeaderBBox bottom.\n         * @member {number|Long} bottom\n         * @memberof OSMPBF.HeaderBBox\n         * @instance\n         */\n        HeaderBBox.prototype.bottom = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Creates a new HeaderBBox instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {OSMPBF.IHeaderBBox=} [properties] Properties to set\n         * @returns {OSMPBF.HeaderBBox} HeaderBBox instance\n         */\n        HeaderBBox.create = function create(properties) {\n            return new HeaderBBox(properties);\n        };\n\n        /**\n         * Encodes the specified HeaderBBox message. Does not implicitly {@link OSMPBF.HeaderBBox.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {OSMPBF.IHeaderBBox} message HeaderBBox message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        HeaderBBox.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            writer.uint32(/* id 1, wireType 0 =*/8).sint64(message.left);\n            writer.uint32(/* id 2, wireType 0 =*/16).sint64(message.right);\n            writer.uint32(/* id 3, wireType 0 =*/24).sint64(message.top);\n            writer.uint32(/* id 4, wireType 0 =*/32).sint64(message.bottom);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified HeaderBBox message, length delimited. Does not implicitly {@link OSMPBF.HeaderBBox.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {OSMPBF.IHeaderBBox} message HeaderBBox message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        HeaderBBox.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a HeaderBBox message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.HeaderBBox} HeaderBBox\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        HeaderBBox.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.HeaderBBox();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.left = reader.sint64();\n                    break;\n                case 2:\n                    message.right = reader.sint64();\n                    break;\n                case 3:\n                    message.top = reader.sint64();\n                    break;\n                case 4:\n                    message.bottom = reader.sint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            if (!message.hasOwnProperty(\"left\"))\n                throw $util.ProtocolError(\"missing required 'left'\", { instance: message });\n            if (!message.hasOwnProperty(\"right\"))\n                throw $util.ProtocolError(\"missing required 'right'\", { instance: message });\n            if (!message.hasOwnProperty(\"top\"))\n                throw $util.ProtocolError(\"missing required 'top'\", { instance: message });\n            if (!message.hasOwnProperty(\"bottom\"))\n                throw $util.ProtocolError(\"missing required 'bottom'\", { instance: message });\n            return message;\n        };\n\n        /**\n         * Decodes a HeaderBBox message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.HeaderBBox} HeaderBBox\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        HeaderBBox.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a HeaderBBox message.\n         * @function verify\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        HeaderBBox.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (!$util.isInteger(message.left) && !(message.left && $util.isInteger(message.left.low) && $util.isInteger(message.left.high)))\n                return \"left: integer|Long expected\";\n            if (!$util.isInteger(message.right) && !(message.right && $util.isInteger(message.right.low) && $util.isInteger(message.right.high)))\n                return \"right: integer|Long expected\";\n            if (!$util.isInteger(message.top) && !(message.top && $util.isInteger(message.top.low) && $util.isInteger(message.top.high)))\n                return \"top: integer|Long expected\";\n            if (!$util.isInteger(message.bottom) && !(message.bottom && $util.isInteger(message.bottom.low) && $util.isInteger(message.bottom.high)))\n                return \"bottom: integer|Long expected\";\n            return null;\n        };\n\n        /**\n         * Creates a HeaderBBox message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.HeaderBBox} HeaderBBox\n         */\n        HeaderBBox.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.HeaderBBox)\n                return object;\n            var message = new $root.OSMPBF.HeaderBBox();\n            if (object.left != null)\n                if ($util.Long)\n                    (message.left = $util.Long.fromValue(object.left)).unsigned = false;\n                else if (typeof object.left === \"string\")\n                    message.left = parseInt(object.left, 10);\n                else if (typeof object.left === \"number\")\n                    message.left = object.left;\n                else if (typeof object.left === \"object\")\n                    message.left = new $util.LongBits(object.left.low >>> 0, object.left.high >>> 0).toNumber();\n            if (object.right != null)\n                if ($util.Long)\n                    (message.right = $util.Long.fromValue(object.right)).unsigned = false;\n                else if (typeof object.right === \"string\")\n                    message.right = parseInt(object.right, 10);\n                else if (typeof object.right === \"number\")\n                    message.right = object.right;\n                else if (typeof object.right === \"object\")\n                    message.right = new $util.LongBits(object.right.low >>> 0, object.right.high >>> 0).toNumber();\n            if (object.top != null)\n                if ($util.Long)\n                    (message.top = $util.Long.fromValue(object.top)).unsigned = false;\n                else if (typeof object.top === \"string\")\n                    message.top = parseInt(object.top, 10);\n                else if (typeof object.top === \"number\")\n                    message.top = object.top;\n                else if (typeof object.top === \"object\")\n                    message.top = new $util.LongBits(object.top.low >>> 0, object.top.high >>> 0).toNumber();\n            if (object.bottom != null)\n                if ($util.Long)\n                    (message.bottom = $util.Long.fromValue(object.bottom)).unsigned = false;\n                else if (typeof object.bottom === \"string\")\n                    message.bottom = parseInt(object.bottom, 10);\n                else if (typeof object.bottom === \"number\")\n                    message.bottom = object.bottom;\n                else if (typeof object.bottom === \"object\")\n                    message.bottom = new $util.LongBits(object.bottom.low >>> 0, object.bottom.high >>> 0).toNumber();\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a HeaderBBox message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.HeaderBBox\n         * @static\n         * @param {OSMPBF.HeaderBBox} message HeaderBBox\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        HeaderBBox.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.defaults) {\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.left = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.left = options.longs === String ? \"0\" : 0;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.right = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.right = options.longs === String ? \"0\" : 0;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.top = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.top = options.longs === String ? \"0\" : 0;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.bottom = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.bottom = options.longs === String ? \"0\" : 0;\n            }\n            if (message.left != null && message.hasOwnProperty(\"left\"))\n                if (typeof message.left === \"number\")\n                    object.left = options.longs === String ? String(message.left) : message.left;\n                else\n                    object.left = options.longs === String ? $util.Long.prototype.toString.call(message.left) : options.longs === Number ? new $util.LongBits(message.left.low >>> 0, message.left.high >>> 0).toNumber() : message.left;\n            if (message.right != null && message.hasOwnProperty(\"right\"))\n                if (typeof message.right === \"number\")\n                    object.right = options.longs === String ? String(message.right) : message.right;\n                else\n                    object.right = options.longs === String ? $util.Long.prototype.toString.call(message.right) : options.longs === Number ? new $util.LongBits(message.right.low >>> 0, message.right.high >>> 0).toNumber() : message.right;\n            if (message.top != null && message.hasOwnProperty(\"top\"))\n                if (typeof message.top === \"number\")\n                    object.top = options.longs === String ? String(message.top) : message.top;\n                else\n                    object.top = options.longs === String ? $util.Long.prototype.toString.call(message.top) : options.longs === Number ? new $util.LongBits(message.top.low >>> 0, message.top.high >>> 0).toNumber() : message.top;\n            if (message.bottom != null && message.hasOwnProperty(\"bottom\"))\n                if (typeof message.bottom === \"number\")\n                    object.bottom = options.longs === String ? String(message.bottom) : message.bottom;\n                else\n                    object.bottom = options.longs === String ? $util.Long.prototype.toString.call(message.bottom) : options.longs === Number ? new $util.LongBits(message.bottom.low >>> 0, message.bottom.high >>> 0).toNumber() : message.bottom;\n            return object;\n        };\n\n        /**\n         * Converts this HeaderBBox to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.HeaderBBox\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        HeaderBBox.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return HeaderBBox;\n    })();\n\n    OSMPBF.PrimitiveBlock = (function() {\n\n        /**\n         * Properties of a PrimitiveBlock.\n         * @memberof OSMPBF\n         * @interface IPrimitiveBlock\n         * @property {OSMPBF.IStringTable} stringtable PrimitiveBlock stringtable\n         * @property {Array.<OSMPBF.IPrimitiveGroup>|null} [primitivegroup] PrimitiveBlock primitivegroup\n         * @property {number|null} [granularity] PrimitiveBlock granularity\n         * @property {number|Long|null} [latOffset] PrimitiveBlock latOffset\n         * @property {number|Long|null} [lonOffset] PrimitiveBlock lonOffset\n         * @property {number|null} [dateGranularity] PrimitiveBlock dateGranularity\n         */\n\n        /**\n         * Constructs a new PrimitiveBlock.\n         * @memberof OSMPBF\n         * @classdesc Represents a PrimitiveBlock.\n         * @implements IPrimitiveBlock\n         * @constructor\n         * @param {OSMPBF.IPrimitiveBlock=} [properties] Properties to set\n         */\n        function PrimitiveBlock(properties) {\n            this.primitivegroup = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * PrimitiveBlock stringtable.\n         * @member {OSMPBF.IStringTable} stringtable\n         * @memberof OSMPBF.PrimitiveBlock\n         * @instance\n         */\n        PrimitiveBlock.prototype.stringtable = null;\n\n        /**\n         * PrimitiveBlock primitivegroup.\n         * @member {Array.<OSMPBF.IPrimitiveGroup>} primitivegroup\n         * @memberof OSMPBF.PrimitiveBlock\n         * @instance\n         */\n        PrimitiveBlock.prototype.primitivegroup = $util.emptyArray;\n\n        /**\n         * PrimitiveBlock granularity.\n         * @member {number} granularity\n         * @memberof OSMPBF.PrimitiveBlock\n         * @instance\n         */\n        PrimitiveBlock.prototype.granularity = 100;\n\n        /**\n         * PrimitiveBlock latOffset.\n         * @member {number|Long} latOffset\n         * @memberof OSMPBF.PrimitiveBlock\n         * @instance\n         */\n        PrimitiveBlock.prototype.latOffset = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * PrimitiveBlock lonOffset.\n         * @member {number|Long} lonOffset\n         * @memberof OSMPBF.PrimitiveBlock\n         * @instance\n         */\n        PrimitiveBlock.prototype.lonOffset = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * PrimitiveBlock dateGranularity.\n         * @member {number} dateGranularity\n         * @memberof OSMPBF.PrimitiveBlock\n         * @instance\n         */\n        PrimitiveBlock.prototype.dateGranularity = 1000;\n\n        /**\n         * Creates a new PrimitiveBlock instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {OSMPBF.IPrimitiveBlock=} [properties] Properties to set\n         * @returns {OSMPBF.PrimitiveBlock} PrimitiveBlock instance\n         */\n        PrimitiveBlock.create = function create(properties) {\n            return new PrimitiveBlock(properties);\n        };\n\n        /**\n         * Encodes the specified PrimitiveBlock message. Does not implicitly {@link OSMPBF.PrimitiveBlock.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {OSMPBF.IPrimitiveBlock} message PrimitiveBlock message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        PrimitiveBlock.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            $root.OSMPBF.StringTable.encode(message.stringtable, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n            if (message.primitivegroup != null && message.primitivegroup.length)\n                for (var i = 0; i < message.primitivegroup.length; ++i)\n                    $root.OSMPBF.PrimitiveGroup.encode(message.primitivegroup[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n            if (message.granularity != null && message.hasOwnProperty(\"granularity\"))\n                writer.uint32(/* id 17, wireType 0 =*/136).int32(message.granularity);\n            if (message.dateGranularity != null && message.hasOwnProperty(\"dateGranularity\"))\n                writer.uint32(/* id 18, wireType 0 =*/144).int32(message.dateGranularity);\n            if (message.latOffset != null && message.hasOwnProperty(\"latOffset\"))\n                writer.uint32(/* id 19, wireType 0 =*/152).int64(message.latOffset);\n            if (message.lonOffset != null && message.hasOwnProperty(\"lonOffset\"))\n                writer.uint32(/* id 20, wireType 0 =*/160).int64(message.lonOffset);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified PrimitiveBlock message, length delimited. Does not implicitly {@link OSMPBF.PrimitiveBlock.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {OSMPBF.IPrimitiveBlock} message PrimitiveBlock message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        PrimitiveBlock.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a PrimitiveBlock message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.PrimitiveBlock} PrimitiveBlock\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        PrimitiveBlock.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.PrimitiveBlock();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.stringtable = $root.OSMPBF.StringTable.decode(reader, reader.uint32());\n                    break;\n                case 2:\n                    if (!(message.primitivegroup && message.primitivegroup.length))\n                        message.primitivegroup = [];\n                    message.primitivegroup.push($root.OSMPBF.PrimitiveGroup.decode(reader, reader.uint32()));\n                    break;\n                case 17:\n                    message.granularity = reader.int32();\n                    break;\n                case 19:\n                    message.latOffset = reader.int64();\n                    break;\n                case 20:\n                    message.lonOffset = reader.int64();\n                    break;\n                case 18:\n                    message.dateGranularity = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            if (!message.hasOwnProperty(\"stringtable\"))\n                throw $util.ProtocolError(\"missing required 'stringtable'\", { instance: message });\n            return message;\n        };\n\n        /**\n         * Decodes a PrimitiveBlock message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.PrimitiveBlock} PrimitiveBlock\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        PrimitiveBlock.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a PrimitiveBlock message.\n         * @function verify\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        PrimitiveBlock.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            {\n                var error = $root.OSMPBF.StringTable.verify(message.stringtable);\n                if (error)\n                    return \"stringtable.\" + error;\n            }\n            if (message.primitivegroup != null && message.hasOwnProperty(\"primitivegroup\")) {\n                if (!Array.isArray(message.primitivegroup))\n                    return \"primitivegroup: array expected\";\n                for (var i = 0; i < message.primitivegroup.length; ++i) {\n                    var error = $root.OSMPBF.PrimitiveGroup.verify(message.primitivegroup[i]);\n                    if (error)\n                        return \"primitivegroup.\" + error;\n                }\n            }\n            if (message.granularity != null && message.hasOwnProperty(\"granularity\"))\n                if (!$util.isInteger(message.granularity))\n                    return \"granularity: integer expected\";\n            if (message.latOffset != null && message.hasOwnProperty(\"latOffset\"))\n                if (!$util.isInteger(message.latOffset) && !(message.latOffset && $util.isInteger(message.latOffset.low) && $util.isInteger(message.latOffset.high)))\n                    return \"latOffset: integer|Long expected\";\n            if (message.lonOffset != null && message.hasOwnProperty(\"lonOffset\"))\n                if (!$util.isInteger(message.lonOffset) && !(message.lonOffset && $util.isInteger(message.lonOffset.low) && $util.isInteger(message.lonOffset.high)))\n                    return \"lonOffset: integer|Long expected\";\n            if (message.dateGranularity != null && message.hasOwnProperty(\"dateGranularity\"))\n                if (!$util.isInteger(message.dateGranularity))\n                    return \"dateGranularity: integer expected\";\n            return null;\n        };\n\n        /**\n         * Creates a PrimitiveBlock message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.PrimitiveBlock} PrimitiveBlock\n         */\n        PrimitiveBlock.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.PrimitiveBlock)\n                return object;\n            var message = new $root.OSMPBF.PrimitiveBlock();\n            if (object.stringtable != null) {\n                if (typeof object.stringtable !== \"object\")\n                    throw TypeError(\".OSMPBF.PrimitiveBlock.stringtable: object expected\");\n                message.stringtable = $root.OSMPBF.StringTable.fromObject(object.stringtable);\n            }\n            if (object.primitivegroup) {\n                if (!Array.isArray(object.primitivegroup))\n                    throw TypeError(\".OSMPBF.PrimitiveBlock.primitivegroup: array expected\");\n                message.primitivegroup = [];\n                for (var i = 0; i < object.primitivegroup.length; ++i) {\n                    if (typeof object.primitivegroup[i] !== \"object\")\n                        throw TypeError(\".OSMPBF.PrimitiveBlock.primitivegroup: object expected\");\n                    message.primitivegroup[i] = $root.OSMPBF.PrimitiveGroup.fromObject(object.primitivegroup[i]);\n                }\n            }\n            if (object.granularity != null)\n                message.granularity = object.granularity | 0;\n            if (object.latOffset != null)\n                if ($util.Long)\n                    (message.latOffset = $util.Long.fromValue(object.latOffset)).unsigned = false;\n                else if (typeof object.latOffset === \"string\")\n                    message.latOffset = parseInt(object.latOffset, 10);\n                else if (typeof object.latOffset === \"number\")\n                    message.latOffset = object.latOffset;\n                else if (typeof object.latOffset === \"object\")\n                    message.latOffset = new $util.LongBits(object.latOffset.low >>> 0, object.latOffset.high >>> 0).toNumber();\n            if (object.lonOffset != null)\n                if ($util.Long)\n                    (message.lonOffset = $util.Long.fromValue(object.lonOffset)).unsigned = false;\n                else if (typeof object.lonOffset === \"string\")\n                    message.lonOffset = parseInt(object.lonOffset, 10);\n                else if (typeof object.lonOffset === \"number\")\n                    message.lonOffset = object.lonOffset;\n                else if (typeof object.lonOffset === \"object\")\n                    message.lonOffset = new $util.LongBits(object.lonOffset.low >>> 0, object.lonOffset.high >>> 0).toNumber();\n            if (object.dateGranularity != null)\n                message.dateGranularity = object.dateGranularity | 0;\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a PrimitiveBlock message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.PrimitiveBlock\n         * @static\n         * @param {OSMPBF.PrimitiveBlock} message PrimitiveBlock\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        PrimitiveBlock.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults)\n                object.primitivegroup = [];\n            if (options.defaults) {\n                object.stringtable = null;\n                object.granularity = 100;\n                object.dateGranularity = 1000;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.latOffset = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.latOffset = options.longs === String ? \"0\" : 0;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.lonOffset = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.lonOffset = options.longs === String ? \"0\" : 0;\n            }\n            if (message.stringtable != null && message.hasOwnProperty(\"stringtable\"))\n                object.stringtable = $root.OSMPBF.StringTable.toObject(message.stringtable, options);\n            if (message.primitivegroup && message.primitivegroup.length) {\n                object.primitivegroup = [];\n                for (var j = 0; j < message.primitivegroup.length; ++j)\n                    object.primitivegroup[j] = $root.OSMPBF.PrimitiveGroup.toObject(message.primitivegroup[j], options);\n            }\n            if (message.granularity != null && message.hasOwnProperty(\"granularity\"))\n                object.granularity = message.granularity;\n            if (message.dateGranularity != null && message.hasOwnProperty(\"dateGranularity\"))\n                object.dateGranularity = message.dateGranularity;\n            if (message.latOffset != null && message.hasOwnProperty(\"latOffset\"))\n                if (typeof message.latOffset === \"number\")\n                    object.latOffset = options.longs === String ? String(message.latOffset) : message.latOffset;\n                else\n                    object.latOffset = options.longs === String ? $util.Long.prototype.toString.call(message.latOffset) : options.longs === Number ? new $util.LongBits(message.latOffset.low >>> 0, message.latOffset.high >>> 0).toNumber() : message.latOffset;\n            if (message.lonOffset != null && message.hasOwnProperty(\"lonOffset\"))\n                if (typeof message.lonOffset === \"number\")\n                    object.lonOffset = options.longs === String ? String(message.lonOffset) : message.lonOffset;\n                else\n                    object.lonOffset = options.longs === String ? $util.Long.prototype.toString.call(message.lonOffset) : options.longs === Number ? new $util.LongBits(message.lonOffset.low >>> 0, message.lonOffset.high >>> 0).toNumber() : message.lonOffset;\n            return object;\n        };\n\n        /**\n         * Converts this PrimitiveBlock to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.PrimitiveBlock\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        PrimitiveBlock.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return PrimitiveBlock;\n    })();\n\n    OSMPBF.PrimitiveGroup = (function() {\n\n        /**\n         * Properties of a PrimitiveGroup.\n         * @memberof OSMPBF\n         * @interface IPrimitiveGroup\n         * @property {Array.<OSMPBF.INode>|null} [nodes] PrimitiveGroup nodes\n         * @property {OSMPBF.IDenseNodes|null} [dense] PrimitiveGroup dense\n         * @property {Array.<OSMPBF.IWay>|null} [ways] PrimitiveGroup ways\n         * @property {Array.<OSMPBF.IRelation>|null} [relations] PrimitiveGroup relations\n         * @property {Array.<OSMPBF.IChangeSet>|null} [changesets] PrimitiveGroup changesets\n         */\n\n        /**\n         * Constructs a new PrimitiveGroup.\n         * @memberof OSMPBF\n         * @classdesc Represents a PrimitiveGroup.\n         * @implements IPrimitiveGroup\n         * @constructor\n         * @param {OSMPBF.IPrimitiveGroup=} [properties] Properties to set\n         */\n        function PrimitiveGroup(properties) {\n            this.nodes = [];\n            this.ways = [];\n            this.relations = [];\n            this.changesets = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * PrimitiveGroup nodes.\n         * @member {Array.<OSMPBF.INode>} nodes\n         * @memberof OSMPBF.PrimitiveGroup\n         * @instance\n         */\n        PrimitiveGroup.prototype.nodes = $util.emptyArray;\n\n        /**\n         * PrimitiveGroup dense.\n         * @member {OSMPBF.IDenseNodes|null|undefined} dense\n         * @memberof OSMPBF.PrimitiveGroup\n         * @instance\n         */\n        PrimitiveGroup.prototype.dense = null;\n\n        /**\n         * PrimitiveGroup ways.\n         * @member {Array.<OSMPBF.IWay>} ways\n         * @memberof OSMPBF.PrimitiveGroup\n         * @instance\n         */\n        PrimitiveGroup.prototype.ways = $util.emptyArray;\n\n        /**\n         * PrimitiveGroup relations.\n         * @member {Array.<OSMPBF.IRelation>} relations\n         * @memberof OSMPBF.PrimitiveGroup\n         * @instance\n         */\n        PrimitiveGroup.prototype.relations = $util.emptyArray;\n\n        /**\n         * PrimitiveGroup changesets.\n         * @member {Array.<OSMPBF.IChangeSet>} changesets\n         * @memberof OSMPBF.PrimitiveGroup\n         * @instance\n         */\n        PrimitiveGroup.prototype.changesets = $util.emptyArray;\n\n        /**\n         * Creates a new PrimitiveGroup instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {OSMPBF.IPrimitiveGroup=} [properties] Properties to set\n         * @returns {OSMPBF.PrimitiveGroup} PrimitiveGroup instance\n         */\n        PrimitiveGroup.create = function create(properties) {\n            return new PrimitiveGroup(properties);\n        };\n\n        /**\n         * Encodes the specified PrimitiveGroup message. Does not implicitly {@link OSMPBF.PrimitiveGroup.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {OSMPBF.IPrimitiveGroup} message PrimitiveGroup message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        PrimitiveGroup.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            if (message.nodes != null && message.nodes.length)\n                for (var i = 0; i < message.nodes.length; ++i)\n                    $root.OSMPBF.Node.encode(message.nodes[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();\n            if (message.dense != null && message.hasOwnProperty(\"dense\"))\n                $root.OSMPBF.DenseNodes.encode(message.dense, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();\n            if (message.ways != null && message.ways.length)\n                for (var i = 0; i < message.ways.length; ++i)\n                    $root.OSMPBF.Way.encode(message.ways[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();\n            if (message.relations != null && message.relations.length)\n                for (var i = 0; i < message.relations.length; ++i)\n                    $root.OSMPBF.Relation.encode(message.relations[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n            if (message.changesets != null && message.changesets.length)\n                for (var i = 0; i < message.changesets.length; ++i)\n                    $root.OSMPBF.ChangeSet.encode(message.changesets[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();\n            return writer;\n        };\n\n        /**\n         * Encodes the specified PrimitiveGroup message, length delimited. Does not implicitly {@link OSMPBF.PrimitiveGroup.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {OSMPBF.IPrimitiveGroup} message PrimitiveGroup message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        PrimitiveGroup.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a PrimitiveGroup message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.PrimitiveGroup} PrimitiveGroup\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        PrimitiveGroup.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.PrimitiveGroup();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    if (!(message.nodes && message.nodes.length))\n                        message.nodes = [];\n                    message.nodes.push($root.OSMPBF.Node.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.dense = $root.OSMPBF.DenseNodes.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    if (!(message.ways && message.ways.length))\n                        message.ways = [];\n                    message.ways.push($root.OSMPBF.Way.decode(reader, reader.uint32()));\n                    break;\n                case 4:\n                    if (!(message.relations && message.relations.length))\n                        message.relations = [];\n                    message.relations.push($root.OSMPBF.Relation.decode(reader, reader.uint32()));\n                    break;\n                case 5:\n                    if (!(message.changesets && message.changesets.length))\n                        message.changesets = [];\n                    message.changesets.push($root.OSMPBF.ChangeSet.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Decodes a PrimitiveGroup message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.PrimitiveGroup} PrimitiveGroup\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        PrimitiveGroup.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a PrimitiveGroup message.\n         * @function verify\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        PrimitiveGroup.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (message.nodes != null && message.hasOwnProperty(\"nodes\")) {\n                if (!Array.isArray(message.nodes))\n                    return \"nodes: array expected\";\n                for (var i = 0; i < message.nodes.length; ++i) {\n                    var error = $root.OSMPBF.Node.verify(message.nodes[i]);\n                    if (error)\n                        return \"nodes.\" + error;\n                }\n            }\n            if (message.dense != null && message.hasOwnProperty(\"dense\")) {\n                var error = $root.OSMPBF.DenseNodes.verify(message.dense);\n                if (error)\n                    return \"dense.\" + error;\n            }\n            if (message.ways != null && message.hasOwnProperty(\"ways\")) {\n                if (!Array.isArray(message.ways))\n                    return \"ways: array expected\";\n                for (var i = 0; i < message.ways.length; ++i) {\n                    var error = $root.OSMPBF.Way.verify(message.ways[i]);\n                    if (error)\n                        return \"ways.\" + error;\n                }\n            }\n            if (message.relations != null && message.hasOwnProperty(\"relations\")) {\n                if (!Array.isArray(message.relations))\n                    return \"relations: array expected\";\n                for (var i = 0; i < message.relations.length; ++i) {\n                    var error = $root.OSMPBF.Relation.verify(message.relations[i]);\n                    if (error)\n                        return \"relations.\" + error;\n                }\n            }\n            if (message.changesets != null && message.hasOwnProperty(\"changesets\")) {\n                if (!Array.isArray(message.changesets))\n                    return \"changesets: array expected\";\n                for (var i = 0; i < message.changesets.length; ++i) {\n                    var error = $root.OSMPBF.ChangeSet.verify(message.changesets[i]);\n                    if (error)\n                        return \"changesets.\" + error;\n                }\n            }\n            return null;\n        };\n\n        /**\n         * Creates a PrimitiveGroup message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.PrimitiveGroup} PrimitiveGroup\n         */\n        PrimitiveGroup.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.PrimitiveGroup)\n                return object;\n            var message = new $root.OSMPBF.PrimitiveGroup();\n            if (object.nodes) {\n                if (!Array.isArray(object.nodes))\n                    throw TypeError(\".OSMPBF.PrimitiveGroup.nodes: array expected\");\n                message.nodes = [];\n                for (var i = 0; i < object.nodes.length; ++i) {\n                    if (typeof object.nodes[i] !== \"object\")\n                        throw TypeError(\".OSMPBF.PrimitiveGroup.nodes: object expected\");\n                    message.nodes[i] = $root.OSMPBF.Node.fromObject(object.nodes[i]);\n                }\n            }\n            if (object.dense != null) {\n                if (typeof object.dense !== \"object\")\n                    throw TypeError(\".OSMPBF.PrimitiveGroup.dense: object expected\");\n                message.dense = $root.OSMPBF.DenseNodes.fromObject(object.dense);\n            }\n            if (object.ways) {\n                if (!Array.isArray(object.ways))\n                    throw TypeError(\".OSMPBF.PrimitiveGroup.ways: array expected\");\n                message.ways = [];\n                for (var i = 0; i < object.ways.length; ++i) {\n                    if (typeof object.ways[i] !== \"object\")\n                        throw TypeError(\".OSMPBF.PrimitiveGroup.ways: object expected\");\n                    message.ways[i] = $root.OSMPBF.Way.fromObject(object.ways[i]);\n                }\n            }\n            if (object.relations) {\n                if (!Array.isArray(object.relations))\n                    throw TypeError(\".OSMPBF.PrimitiveGroup.relations: array expected\");\n                message.relations = [];\n                for (var i = 0; i < object.relations.length; ++i) {\n                    if (typeof object.relations[i] !== \"object\")\n                        throw TypeError(\".OSMPBF.PrimitiveGroup.relations: object expected\");\n                    message.relations[i] = $root.OSMPBF.Relation.fromObject(object.relations[i]);\n                }\n            }\n            if (object.changesets) {\n                if (!Array.isArray(object.changesets))\n                    throw TypeError(\".OSMPBF.PrimitiveGroup.changesets: array expected\");\n                message.changesets = [];\n                for (var i = 0; i < object.changesets.length; ++i) {\n                    if (typeof object.changesets[i] !== \"object\")\n                        throw TypeError(\".OSMPBF.PrimitiveGroup.changesets: object expected\");\n                    message.changesets[i] = $root.OSMPBF.ChangeSet.fromObject(object.changesets[i]);\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a PrimitiveGroup message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.PrimitiveGroup\n         * @static\n         * @param {OSMPBF.PrimitiveGroup} message PrimitiveGroup\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        PrimitiveGroup.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults) {\n                object.nodes = [];\n                object.ways = [];\n                object.relations = [];\n                object.changesets = [];\n            }\n            if (options.defaults)\n                object.dense = null;\n            if (message.nodes && message.nodes.length) {\n                object.nodes = [];\n                for (var j = 0; j < message.nodes.length; ++j)\n                    object.nodes[j] = $root.OSMPBF.Node.toObject(message.nodes[j], options);\n            }\n            if (message.dense != null && message.hasOwnProperty(\"dense\"))\n                object.dense = $root.OSMPBF.DenseNodes.toObject(message.dense, options);\n            if (message.ways && message.ways.length) {\n                object.ways = [];\n                for (var j = 0; j < message.ways.length; ++j)\n                    object.ways[j] = $root.OSMPBF.Way.toObject(message.ways[j], options);\n            }\n            if (message.relations && message.relations.length) {\n                object.relations = [];\n                for (var j = 0; j < message.relations.length; ++j)\n                    object.relations[j] = $root.OSMPBF.Relation.toObject(message.relations[j], options);\n            }\n            if (message.changesets && message.changesets.length) {\n                object.changesets = [];\n                for (var j = 0; j < message.changesets.length; ++j)\n                    object.changesets[j] = $root.OSMPBF.ChangeSet.toObject(message.changesets[j], options);\n            }\n            return object;\n        };\n\n        /**\n         * Converts this PrimitiveGroup to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.PrimitiveGroup\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        PrimitiveGroup.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return PrimitiveGroup;\n    })();\n\n    OSMPBF.StringTable = (function() {\n\n        /**\n         * Properties of a StringTable.\n         * @memberof OSMPBF\n         * @interface IStringTable\n         * @property {Array.<Uint8Array>|null} [s] StringTable s\n         */\n\n        /**\n         * Constructs a new StringTable.\n         * @memberof OSMPBF\n         * @classdesc String table, contains the common strings in each block.\n         *\n         * Note that we reserve index '0' as a delimiter, so the entry at that\n         * index in the table is ALWAYS blank and unused.\n         * @implements IStringTable\n         * @constructor\n         * @param {OSMPBF.IStringTable=} [properties] Properties to set\n         */\n        function StringTable(properties) {\n            this.s = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * StringTable s.\n         * @member {Array.<Uint8Array>} s\n         * @memberof OSMPBF.StringTable\n         * @instance\n         */\n        StringTable.prototype.s = $util.emptyArray;\n\n        /**\n         * Creates a new StringTable instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {OSMPBF.IStringTable=} [properties] Properties to set\n         * @returns {OSMPBF.StringTable} StringTable instance\n         */\n        StringTable.create = function create(properties) {\n            return new StringTable(properties);\n        };\n\n        /**\n         * Encodes the specified StringTable message. Does not implicitly {@link OSMPBF.StringTable.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {OSMPBF.IStringTable} message StringTable message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        StringTable.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            if (message.s != null && message.s.length)\n                for (var i = 0; i < message.s.length; ++i)\n                    writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.s[i]);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified StringTable message, length delimited. Does not implicitly {@link OSMPBF.StringTable.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {OSMPBF.IStringTable} message StringTable message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        StringTable.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a StringTable message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.StringTable} StringTable\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        StringTable.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.StringTable();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    if (!(message.s && message.s.length))\n                        message.s = [];\n                    message.s.push(reader.bytes());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Decodes a StringTable message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.StringTable} StringTable\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        StringTable.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a StringTable message.\n         * @function verify\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        StringTable.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (message.s != null && message.hasOwnProperty(\"s\")) {\n                if (!Array.isArray(message.s))\n                    return \"s: array expected\";\n                for (var i = 0; i < message.s.length; ++i)\n                    if (!(message.s[i] && typeof message.s[i].length === \"number\" || $util.isString(message.s[i])))\n                        return \"s: buffer[] expected\";\n            }\n            return null;\n        };\n\n        /**\n         * Creates a StringTable message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.StringTable} StringTable\n         */\n        StringTable.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.StringTable)\n                return object;\n            var message = new $root.OSMPBF.StringTable();\n            if (object.s) {\n                if (!Array.isArray(object.s))\n                    throw TypeError(\".OSMPBF.StringTable.s: array expected\");\n                message.s = [];\n                for (var i = 0; i < object.s.length; ++i)\n                    if (typeof object.s[i] === \"string\")\n                        $util.base64.decode(object.s[i], message.s[i] = $util.newBuffer($util.base64.length(object.s[i])), 0);\n                    else if (object.s[i].length)\n                        message.s[i] = object.s[i];\n            }\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a StringTable message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.StringTable\n         * @static\n         * @param {OSMPBF.StringTable} message StringTable\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        StringTable.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults)\n                object.s = [];\n            if (message.s && message.s.length) {\n                object.s = [];\n                for (var j = 0; j < message.s.length; ++j)\n                    object.s[j] = options.bytes === String ? $util.base64.encode(message.s[j], 0, message.s[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.s[j]) : message.s[j];\n            }\n            return object;\n        };\n\n        /**\n         * Converts this StringTable to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.StringTable\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        StringTable.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return StringTable;\n    })();\n\n    OSMPBF.Info = (function() {\n\n        /**\n         * Properties of an Info.\n         * @memberof OSMPBF\n         * @interface IInfo\n         * @property {number|null} [version] Info version\n         * @property {number|Long|null} [timestamp] Info timestamp\n         * @property {number|Long|null} [changeset] Info changeset\n         * @property {number|null} [uid] Info uid\n         * @property {number|null} [userSid] Info userSid\n         * @property {boolean|null} [visible] Info visible\n         */\n\n        /**\n         * Constructs a new Info.\n         * @memberof OSMPBF\n         * @classdesc Represents an Info.\n         * @implements IInfo\n         * @constructor\n         * @param {OSMPBF.IInfo=} [properties] Properties to set\n         */\n        function Info(properties) {\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * Info version.\n         * @member {number} version\n         * @memberof OSMPBF.Info\n         * @instance\n         */\n        Info.prototype.version = -1;\n\n        /**\n         * Info timestamp.\n         * @member {number|Long} timestamp\n         * @memberof OSMPBF.Info\n         * @instance\n         */\n        Info.prototype.timestamp = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Info changeset.\n         * @member {number|Long} changeset\n         * @memberof OSMPBF.Info\n         * @instance\n         */\n        Info.prototype.changeset = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Info uid.\n         * @member {number} uid\n         * @memberof OSMPBF.Info\n         * @instance\n         */\n        Info.prototype.uid = 0;\n\n        /**\n         * Info userSid.\n         * @member {number} userSid\n         * @memberof OSMPBF.Info\n         * @instance\n         */\n        Info.prototype.userSid = 0;\n\n        /**\n         * Info visible.\n         * @member {boolean} visible\n         * @memberof OSMPBF.Info\n         * @instance\n         */\n        Info.prototype.visible = false;\n\n        /**\n         * Creates a new Info instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {OSMPBF.IInfo=} [properties] Properties to set\n         * @returns {OSMPBF.Info} Info instance\n         */\n        Info.create = function create(properties) {\n            return new Info(properties);\n        };\n\n        /**\n         * Encodes the specified Info message. Does not implicitly {@link OSMPBF.Info.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {OSMPBF.IInfo} message Info message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Info.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            if (message.version != null && message.hasOwnProperty(\"version\"))\n                writer.uint32(/* id 1, wireType 0 =*/8).int32(message.version);\n            if (message.timestamp != null && message.hasOwnProperty(\"timestamp\"))\n                writer.uint32(/* id 2, wireType 0 =*/16).int64(message.timestamp);\n            if (message.changeset != null && message.hasOwnProperty(\"changeset\"))\n                writer.uint32(/* id 3, wireType 0 =*/24).int64(message.changeset);\n            if (message.uid != null && message.hasOwnProperty(\"uid\"))\n                writer.uint32(/* id 4, wireType 0 =*/32).int32(message.uid);\n            if (message.userSid != null && message.hasOwnProperty(\"userSid\"))\n                writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.userSid);\n            if (message.visible != null && message.hasOwnProperty(\"visible\"))\n                writer.uint32(/* id 6, wireType 0 =*/48).bool(message.visible);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified Info message, length delimited. Does not implicitly {@link OSMPBF.Info.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {OSMPBF.IInfo} message Info message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Info.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes an Info message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.Info} Info\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Info.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.Info();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.version = reader.int32();\n                    break;\n                case 2:\n                    message.timestamp = reader.int64();\n                    break;\n                case 3:\n                    message.changeset = reader.int64();\n                    break;\n                case 4:\n                    message.uid = reader.int32();\n                    break;\n                case 5:\n                    message.userSid = reader.uint32();\n                    break;\n                case 6:\n                    message.visible = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Decodes an Info message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.Info} Info\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Info.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies an Info message.\n         * @function verify\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        Info.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (message.version != null && message.hasOwnProperty(\"version\"))\n                if (!$util.isInteger(message.version))\n                    return \"version: integer expected\";\n            if (message.timestamp != null && message.hasOwnProperty(\"timestamp\"))\n                if (!$util.isInteger(message.timestamp) && !(message.timestamp && $util.isInteger(message.timestamp.low) && $util.isInteger(message.timestamp.high)))\n                    return \"timestamp: integer|Long expected\";\n            if (message.changeset != null && message.hasOwnProperty(\"changeset\"))\n                if (!$util.isInteger(message.changeset) && !(message.changeset && $util.isInteger(message.changeset.low) && $util.isInteger(message.changeset.high)))\n                    return \"changeset: integer|Long expected\";\n            if (message.uid != null && message.hasOwnProperty(\"uid\"))\n                if (!$util.isInteger(message.uid))\n                    return \"uid: integer expected\";\n            if (message.userSid != null && message.hasOwnProperty(\"userSid\"))\n                if (!$util.isInteger(message.userSid))\n                    return \"userSid: integer expected\";\n            if (message.visible != null && message.hasOwnProperty(\"visible\"))\n                if (typeof message.visible !== \"boolean\")\n                    return \"visible: boolean expected\";\n            return null;\n        };\n\n        /**\n         * Creates an Info message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.Info} Info\n         */\n        Info.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.Info)\n                return object;\n            var message = new $root.OSMPBF.Info();\n            if (object.version != null)\n                message.version = object.version | 0;\n            if (object.timestamp != null)\n                if ($util.Long)\n                    (message.timestamp = $util.Long.fromValue(object.timestamp)).unsigned = false;\n                else if (typeof object.timestamp === \"string\")\n                    message.timestamp = parseInt(object.timestamp, 10);\n                else if (typeof object.timestamp === \"number\")\n                    message.timestamp = object.timestamp;\n                else if (typeof object.timestamp === \"object\")\n                    message.timestamp = new $util.LongBits(object.timestamp.low >>> 0, object.timestamp.high >>> 0).toNumber();\n            if (object.changeset != null)\n                if ($util.Long)\n                    (message.changeset = $util.Long.fromValue(object.changeset)).unsigned = false;\n                else if (typeof object.changeset === \"string\")\n                    message.changeset = parseInt(object.changeset, 10);\n                else if (typeof object.changeset === \"number\")\n                    message.changeset = object.changeset;\n                else if (typeof object.changeset === \"object\")\n                    message.changeset = new $util.LongBits(object.changeset.low >>> 0, object.changeset.high >>> 0).toNumber();\n            if (object.uid != null)\n                message.uid = object.uid | 0;\n            if (object.userSid != null)\n                message.userSid = object.userSid >>> 0;\n            if (object.visible != null)\n                message.visible = Boolean(object.visible);\n            return message;\n        };\n\n        /**\n         * Creates a plain object from an Info message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.Info\n         * @static\n         * @param {OSMPBF.Info} message Info\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        Info.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.defaults) {\n                object.version = -1;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.timestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.timestamp = options.longs === String ? \"0\" : 0;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.changeset = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.changeset = options.longs === String ? \"0\" : 0;\n                object.uid = 0;\n                object.userSid = 0;\n                object.visible = false;\n            }\n            if (message.version != null && message.hasOwnProperty(\"version\"))\n                object.version = message.version;\n            if (message.timestamp != null && message.hasOwnProperty(\"timestamp\"))\n                if (typeof message.timestamp === \"number\")\n                    object.timestamp = options.longs === String ? String(message.timestamp) : message.timestamp;\n                else\n                    object.timestamp = options.longs === String ? $util.Long.prototype.toString.call(message.timestamp) : options.longs === Number ? new $util.LongBits(message.timestamp.low >>> 0, message.timestamp.high >>> 0).toNumber() : message.timestamp;\n            if (message.changeset != null && message.hasOwnProperty(\"changeset\"))\n                if (typeof message.changeset === \"number\")\n                    object.changeset = options.longs === String ? String(message.changeset) : message.changeset;\n                else\n                    object.changeset = options.longs === String ? $util.Long.prototype.toString.call(message.changeset) : options.longs === Number ? new $util.LongBits(message.changeset.low >>> 0, message.changeset.high >>> 0).toNumber() : message.changeset;\n            if (message.uid != null && message.hasOwnProperty(\"uid\"))\n                object.uid = message.uid;\n            if (message.userSid != null && message.hasOwnProperty(\"userSid\"))\n                object.userSid = message.userSid;\n            if (message.visible != null && message.hasOwnProperty(\"visible\"))\n                object.visible = message.visible;\n            return object;\n        };\n\n        /**\n         * Converts this Info to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.Info\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        Info.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return Info;\n    })();\n\n    OSMPBF.DenseInfo = (function() {\n\n        /**\n         * Properties of a DenseInfo.\n         * @memberof OSMPBF\n         * @interface IDenseInfo\n         * @property {Array.<number>|null} [version] DenseInfo version\n         * @property {Array.<number|Long>|null} [timestamp] DenseInfo timestamp\n         * @property {Array.<number|Long>|null} [changeset] DenseInfo changeset\n         * @property {Array.<number>|null} [uid] DenseInfo uid\n         * @property {Array.<number>|null} [userSid] DenseInfo userSid\n         * @property {Array.<boolean>|null} [visible] DenseInfo visible\n         */\n\n        /**\n         * Constructs a new DenseInfo.\n         * @memberof OSMPBF\n         * @classdesc Optional metadata that may be included into each primitive. Special dense format used in DenseNodes.\n         * @implements IDenseInfo\n         * @constructor\n         * @param {OSMPBF.IDenseInfo=} [properties] Properties to set\n         */\n        function DenseInfo(properties) {\n            this.version = [];\n            this.timestamp = [];\n            this.changeset = [];\n            this.uid = [];\n            this.userSid = [];\n            this.visible = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * DenseInfo version.\n         * @member {Array.<number>} version\n         * @memberof OSMPBF.DenseInfo\n         * @instance\n         */\n        DenseInfo.prototype.version = $util.emptyArray;\n\n        /**\n         * DenseInfo timestamp.\n         * @member {Array.<number|Long>} timestamp\n         * @memberof OSMPBF.DenseInfo\n         * @instance\n         */\n        DenseInfo.prototype.timestamp = $util.emptyArray;\n\n        /**\n         * DenseInfo changeset.\n         * @member {Array.<number|Long>} changeset\n         * @memberof OSMPBF.DenseInfo\n         * @instance\n         */\n        DenseInfo.prototype.changeset = $util.emptyArray;\n\n        /**\n         * DenseInfo uid.\n         * @member {Array.<number>} uid\n         * @memberof OSMPBF.DenseInfo\n         * @instance\n         */\n        DenseInfo.prototype.uid = $util.emptyArray;\n\n        /**\n         * DenseInfo userSid.\n         * @member {Array.<number>} userSid\n         * @memberof OSMPBF.DenseInfo\n         * @instance\n         */\n        DenseInfo.prototype.userSid = $util.emptyArray;\n\n        /**\n         * DenseInfo visible.\n         * @member {Array.<boolean>} visible\n         * @memberof OSMPBF.DenseInfo\n         * @instance\n         */\n        DenseInfo.prototype.visible = $util.emptyArray;\n\n        /**\n         * Creates a new DenseInfo instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {OSMPBF.IDenseInfo=} [properties] Properties to set\n         * @returns {OSMPBF.DenseInfo} DenseInfo instance\n         */\n        DenseInfo.create = function create(properties) {\n            return new DenseInfo(properties);\n        };\n\n        /**\n         * Encodes the specified DenseInfo message. Does not implicitly {@link OSMPBF.DenseInfo.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {OSMPBF.IDenseInfo} message DenseInfo message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        DenseInfo.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            if (message.version != null && message.version.length) {\n                writer.uint32(/* id 1, wireType 2 =*/10).fork();\n                for (var i = 0; i < message.version.length; ++i)\n                    writer.int32(message.version[i]);\n                writer.ldelim();\n            }\n            if (message.timestamp != null && message.timestamp.length) {\n                writer.uint32(/* id 2, wireType 2 =*/18).fork();\n                for (var i = 0; i < message.timestamp.length; ++i)\n                    writer.sint64(message.timestamp[i]);\n                writer.ldelim();\n            }\n            if (message.changeset != null && message.changeset.length) {\n                writer.uint32(/* id 3, wireType 2 =*/26).fork();\n                for (var i = 0; i < message.changeset.length; ++i)\n                    writer.sint64(message.changeset[i]);\n                writer.ldelim();\n            }\n            if (message.uid != null && message.uid.length) {\n                writer.uint32(/* id 4, wireType 2 =*/34).fork();\n                for (var i = 0; i < message.uid.length; ++i)\n                    writer.sint32(message.uid[i]);\n                writer.ldelim();\n            }\n            if (message.userSid != null && message.userSid.length) {\n                writer.uint32(/* id 5, wireType 2 =*/42).fork();\n                for (var i = 0; i < message.userSid.length; ++i)\n                    writer.sint32(message.userSid[i]);\n                writer.ldelim();\n            }\n            if (message.visible != null && message.visible.length) {\n                writer.uint32(/* id 6, wireType 2 =*/50).fork();\n                for (var i = 0; i < message.visible.length; ++i)\n                    writer.bool(message.visible[i]);\n                writer.ldelim();\n            }\n            return writer;\n        };\n\n        /**\n         * Encodes the specified DenseInfo message, length delimited. Does not implicitly {@link OSMPBF.DenseInfo.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {OSMPBF.IDenseInfo} message DenseInfo message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        DenseInfo.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a DenseInfo message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.DenseInfo} DenseInfo\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        DenseInfo.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.DenseInfo();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    if (!(message.version && message.version.length))\n                        message.version = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.version.push(reader.int32());\n                    } else\n                        message.version.push(reader.int32());\n                    break;\n                case 2:\n                    if (!(message.timestamp && message.timestamp.length))\n                        message.timestamp = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.timestamp.push(reader.sint64());\n                    } else\n                        message.timestamp.push(reader.sint64());\n                    break;\n                case 3:\n                    if (!(message.changeset && message.changeset.length))\n                        message.changeset = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.changeset.push(reader.sint64());\n                    } else\n                        message.changeset.push(reader.sint64());\n                    break;\n                case 4:\n                    if (!(message.uid && message.uid.length))\n                        message.uid = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.uid.push(reader.sint32());\n                    } else\n                        message.uid.push(reader.sint32());\n                    break;\n                case 5:\n                    if (!(message.userSid && message.userSid.length))\n                        message.userSid = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.userSid.push(reader.sint32());\n                    } else\n                        message.userSid.push(reader.sint32());\n                    break;\n                case 6:\n                    if (!(message.visible && message.visible.length))\n                        message.visible = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.visible.push(reader.bool());\n                    } else\n                        message.visible.push(reader.bool());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Decodes a DenseInfo message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.DenseInfo} DenseInfo\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        DenseInfo.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a DenseInfo message.\n         * @function verify\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        DenseInfo.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (message.version != null && message.hasOwnProperty(\"version\")) {\n                if (!Array.isArray(message.version))\n                    return \"version: array expected\";\n                for (var i = 0; i < message.version.length; ++i)\n                    if (!$util.isInteger(message.version[i]))\n                        return \"version: integer[] expected\";\n            }\n            if (message.timestamp != null && message.hasOwnProperty(\"timestamp\")) {\n                if (!Array.isArray(message.timestamp))\n                    return \"timestamp: array expected\";\n                for (var i = 0; i < message.timestamp.length; ++i)\n                    if (!$util.isInteger(message.timestamp[i]) && !(message.timestamp[i] && $util.isInteger(message.timestamp[i].low) && $util.isInteger(message.timestamp[i].high)))\n                        return \"timestamp: integer|Long[] expected\";\n            }\n            if (message.changeset != null && message.hasOwnProperty(\"changeset\")) {\n                if (!Array.isArray(message.changeset))\n                    return \"changeset: array expected\";\n                for (var i = 0; i < message.changeset.length; ++i)\n                    if (!$util.isInteger(message.changeset[i]) && !(message.changeset[i] && $util.isInteger(message.changeset[i].low) && $util.isInteger(message.changeset[i].high)))\n                        return \"changeset: integer|Long[] expected\";\n            }\n            if (message.uid != null && message.hasOwnProperty(\"uid\")) {\n                if (!Array.isArray(message.uid))\n                    return \"uid: array expected\";\n                for (var i = 0; i < message.uid.length; ++i)\n                    if (!$util.isInteger(message.uid[i]))\n                        return \"uid: integer[] expected\";\n            }\n            if (message.userSid != null && message.hasOwnProperty(\"userSid\")) {\n                if (!Array.isArray(message.userSid))\n                    return \"userSid: array expected\";\n                for (var i = 0; i < message.userSid.length; ++i)\n                    if (!$util.isInteger(message.userSid[i]))\n                        return \"userSid: integer[] expected\";\n            }\n            if (message.visible != null && message.hasOwnProperty(\"visible\")) {\n                if (!Array.isArray(message.visible))\n                    return \"visible: array expected\";\n                for (var i = 0; i < message.visible.length; ++i)\n                    if (typeof message.visible[i] !== \"boolean\")\n                        return \"visible: boolean[] expected\";\n            }\n            return null;\n        };\n\n        /**\n         * Creates a DenseInfo message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.DenseInfo} DenseInfo\n         */\n        DenseInfo.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.DenseInfo)\n                return object;\n            var message = new $root.OSMPBF.DenseInfo();\n            if (object.version) {\n                if (!Array.isArray(object.version))\n                    throw TypeError(\".OSMPBF.DenseInfo.version: array expected\");\n                message.version = [];\n                for (var i = 0; i < object.version.length; ++i)\n                    message.version[i] = object.version[i] | 0;\n            }\n            if (object.timestamp) {\n                if (!Array.isArray(object.timestamp))\n                    throw TypeError(\".OSMPBF.DenseInfo.timestamp: array expected\");\n                message.timestamp = [];\n                for (var i = 0; i < object.timestamp.length; ++i)\n                    if ($util.Long)\n                        (message.timestamp[i] = $util.Long.fromValue(object.timestamp[i])).unsigned = false;\n                    else if (typeof object.timestamp[i] === \"string\")\n                        message.timestamp[i] = parseInt(object.timestamp[i], 10);\n                    else if (typeof object.timestamp[i] === \"number\")\n                        message.timestamp[i] = object.timestamp[i];\n                    else if (typeof object.timestamp[i] === \"object\")\n                        message.timestamp[i] = new $util.LongBits(object.timestamp[i].low >>> 0, object.timestamp[i].high >>> 0).toNumber();\n            }\n            if (object.changeset) {\n                if (!Array.isArray(object.changeset))\n                    throw TypeError(\".OSMPBF.DenseInfo.changeset: array expected\");\n                message.changeset = [];\n                for (var i = 0; i < object.changeset.length; ++i)\n                    if ($util.Long)\n                        (message.changeset[i] = $util.Long.fromValue(object.changeset[i])).unsigned = false;\n                    else if (typeof object.changeset[i] === \"string\")\n                        message.changeset[i] = parseInt(object.changeset[i], 10);\n                    else if (typeof object.changeset[i] === \"number\")\n                        message.changeset[i] = object.changeset[i];\n                    else if (typeof object.changeset[i] === \"object\")\n                        message.changeset[i] = new $util.LongBits(object.changeset[i].low >>> 0, object.changeset[i].high >>> 0).toNumber();\n            }\n            if (object.uid) {\n                if (!Array.isArray(object.uid))\n                    throw TypeError(\".OSMPBF.DenseInfo.uid: array expected\");\n                message.uid = [];\n                for (var i = 0; i < object.uid.length; ++i)\n                    message.uid[i] = object.uid[i] | 0;\n            }\n            if (object.userSid) {\n                if (!Array.isArray(object.userSid))\n                    throw TypeError(\".OSMPBF.DenseInfo.userSid: array expected\");\n                message.userSid = [];\n                for (var i = 0; i < object.userSid.length; ++i)\n                    message.userSid[i] = object.userSid[i] | 0;\n            }\n            if (object.visible) {\n                if (!Array.isArray(object.visible))\n                    throw TypeError(\".OSMPBF.DenseInfo.visible: array expected\");\n                message.visible = [];\n                for (var i = 0; i < object.visible.length; ++i)\n                    message.visible[i] = Boolean(object.visible[i]);\n            }\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a DenseInfo message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.DenseInfo\n         * @static\n         * @param {OSMPBF.DenseInfo} message DenseInfo\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        DenseInfo.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults) {\n                object.version = [];\n                object.timestamp = [];\n                object.changeset = [];\n                object.uid = [];\n                object.userSid = [];\n                object.visible = [];\n            }\n            if (message.version && message.version.length) {\n                object.version = [];\n                for (var j = 0; j < message.version.length; ++j)\n                    object.version[j] = message.version[j];\n            }\n            if (message.timestamp && message.timestamp.length) {\n                object.timestamp = [];\n                for (var j = 0; j < message.timestamp.length; ++j)\n                    if (typeof message.timestamp[j] === \"number\")\n                        object.timestamp[j] = options.longs === String ? String(message.timestamp[j]) : message.timestamp[j];\n                    else\n                        object.timestamp[j] = options.longs === String ? $util.Long.prototype.toString.call(message.timestamp[j]) : options.longs === Number ? new $util.LongBits(message.timestamp[j].low >>> 0, message.timestamp[j].high >>> 0).toNumber() : message.timestamp[j];\n            }\n            if (message.changeset && message.changeset.length) {\n                object.changeset = [];\n                for (var j = 0; j < message.changeset.length; ++j)\n                    if (typeof message.changeset[j] === \"number\")\n                        object.changeset[j] = options.longs === String ? String(message.changeset[j]) : message.changeset[j];\n                    else\n                        object.changeset[j] = options.longs === String ? $util.Long.prototype.toString.call(message.changeset[j]) : options.longs === Number ? new $util.LongBits(message.changeset[j].low >>> 0, message.changeset[j].high >>> 0).toNumber() : message.changeset[j];\n            }\n            if (message.uid && message.uid.length) {\n                object.uid = [];\n                for (var j = 0; j < message.uid.length; ++j)\n                    object.uid[j] = message.uid[j];\n            }\n            if (message.userSid && message.userSid.length) {\n                object.userSid = [];\n                for (var j = 0; j < message.userSid.length; ++j)\n                    object.userSid[j] = message.userSid[j];\n            }\n            if (message.visible && message.visible.length) {\n                object.visible = [];\n                for (var j = 0; j < message.visible.length; ++j)\n                    object.visible[j] = message.visible[j];\n            }\n            return object;\n        };\n\n        /**\n         * Converts this DenseInfo to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.DenseInfo\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        DenseInfo.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return DenseInfo;\n    })();\n\n    OSMPBF.ChangeSet = (function() {\n\n        /**\n         * Properties of a ChangeSet.\n         * @memberof OSMPBF\n         * @interface IChangeSet\n         * @property {number|Long} id ChangeSet id\n         */\n\n        /**\n         * Constructs a new ChangeSet.\n         * @memberof OSMPBF\n         * @classdesc Represents a ChangeSet.\n         * @implements IChangeSet\n         * @constructor\n         * @param {OSMPBF.IChangeSet=} [properties] Properties to set\n         */\n        function ChangeSet(properties) {\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * ChangeSet id.\n         * @member {number|Long} id\n         * @memberof OSMPBF.ChangeSet\n         * @instance\n         */\n        ChangeSet.prototype.id = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Creates a new ChangeSet instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {OSMPBF.IChangeSet=} [properties] Properties to set\n         * @returns {OSMPBF.ChangeSet} ChangeSet instance\n         */\n        ChangeSet.create = function create(properties) {\n            return new ChangeSet(properties);\n        };\n\n        /**\n         * Encodes the specified ChangeSet message. Does not implicitly {@link OSMPBF.ChangeSet.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {OSMPBF.IChangeSet} message ChangeSet message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        ChangeSet.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            writer.uint32(/* id 1, wireType 0 =*/8).int64(message.id);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified ChangeSet message, length delimited. Does not implicitly {@link OSMPBF.ChangeSet.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {OSMPBF.IChangeSet} message ChangeSet message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        ChangeSet.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a ChangeSet message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.ChangeSet} ChangeSet\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        ChangeSet.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.ChangeSet();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.int64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            if (!message.hasOwnProperty(\"id\"))\n                throw $util.ProtocolError(\"missing required 'id'\", { instance: message });\n            return message;\n        };\n\n        /**\n         * Decodes a ChangeSet message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.ChangeSet} ChangeSet\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        ChangeSet.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a ChangeSet message.\n         * @function verify\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        ChangeSet.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (!$util.isInteger(message.id) && !(message.id && $util.isInteger(message.id.low) && $util.isInteger(message.id.high)))\n                return \"id: integer|Long expected\";\n            return null;\n        };\n\n        /**\n         * Creates a ChangeSet message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.ChangeSet} ChangeSet\n         */\n        ChangeSet.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.ChangeSet)\n                return object;\n            var message = new $root.OSMPBF.ChangeSet();\n            if (object.id != null)\n                if ($util.Long)\n                    (message.id = $util.Long.fromValue(object.id)).unsigned = false;\n                else if (typeof object.id === \"string\")\n                    message.id = parseInt(object.id, 10);\n                else if (typeof object.id === \"number\")\n                    message.id = object.id;\n                else if (typeof object.id === \"object\")\n                    message.id = new $util.LongBits(object.id.low >>> 0, object.id.high >>> 0).toNumber();\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a ChangeSet message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.ChangeSet\n         * @static\n         * @param {OSMPBF.ChangeSet} message ChangeSet\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        ChangeSet.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.defaults)\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.id = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.id = options.longs === String ? \"0\" : 0;\n            if (message.id != null && message.hasOwnProperty(\"id\"))\n                if (typeof message.id === \"number\")\n                    object.id = options.longs === String ? String(message.id) : message.id;\n                else\n                    object.id = options.longs === String ? $util.Long.prototype.toString.call(message.id) : options.longs === Number ? new $util.LongBits(message.id.low >>> 0, message.id.high >>> 0).toNumber() : message.id;\n            return object;\n        };\n\n        /**\n         * Converts this ChangeSet to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.ChangeSet\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        ChangeSet.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return ChangeSet;\n    })();\n\n    OSMPBF.Node = (function() {\n\n        /**\n         * Properties of a Node.\n         * @memberof OSMPBF\n         * @interface INode\n         * @property {number|Long} id Node id\n         * @property {Array.<number>|null} [keys] Node keys\n         * @property {Array.<number>|null} [vals] Node vals\n         * @property {OSMPBF.IInfo|null} [info] Node info\n         * @property {number|Long} lat Node lat\n         * @property {number|Long} lon Node lon\n         */\n\n        /**\n         * Constructs a new Node.\n         * @memberof OSMPBF\n         * @classdesc Represents a Node.\n         * @implements INode\n         * @constructor\n         * @param {OSMPBF.INode=} [properties] Properties to set\n         */\n        function Node(properties) {\n            this.keys = [];\n            this.vals = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * Node id.\n         * @member {number|Long} id\n         * @memberof OSMPBF.Node\n         * @instance\n         */\n        Node.prototype.id = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Node keys.\n         * @member {Array.<number>} keys\n         * @memberof OSMPBF.Node\n         * @instance\n         */\n        Node.prototype.keys = $util.emptyArray;\n\n        /**\n         * Node vals.\n         * @member {Array.<number>} vals\n         * @memberof OSMPBF.Node\n         * @instance\n         */\n        Node.prototype.vals = $util.emptyArray;\n\n        /**\n         * Node info.\n         * @member {OSMPBF.IInfo|null|undefined} info\n         * @memberof OSMPBF.Node\n         * @instance\n         */\n        Node.prototype.info = null;\n\n        /**\n         * Node lat.\n         * @member {number|Long} lat\n         * @memberof OSMPBF.Node\n         * @instance\n         */\n        Node.prototype.lat = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Node lon.\n         * @member {number|Long} lon\n         * @memberof OSMPBF.Node\n         * @instance\n         */\n        Node.prototype.lon = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Creates a new Node instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {OSMPBF.INode=} [properties] Properties to set\n         * @returns {OSMPBF.Node} Node instance\n         */\n        Node.create = function create(properties) {\n            return new Node(properties);\n        };\n\n        /**\n         * Encodes the specified Node message. Does not implicitly {@link OSMPBF.Node.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {OSMPBF.INode} message Node message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Node.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            writer.uint32(/* id 1, wireType 0 =*/8).sint64(message.id);\n            if (message.keys != null && message.keys.length) {\n                writer.uint32(/* id 2, wireType 2 =*/18).fork();\n                for (var i = 0; i < message.keys.length; ++i)\n                    writer.uint32(message.keys[i]);\n                writer.ldelim();\n            }\n            if (message.vals != null && message.vals.length) {\n                writer.uint32(/* id 3, wireType 2 =*/26).fork();\n                for (var i = 0; i < message.vals.length; ++i)\n                    writer.uint32(message.vals[i]);\n                writer.ldelim();\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\"))\n                $root.OSMPBF.Info.encode(message.info, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n            writer.uint32(/* id 8, wireType 0 =*/64).sint64(message.lat);\n            writer.uint32(/* id 9, wireType 0 =*/72).sint64(message.lon);\n            return writer;\n        };\n\n        /**\n         * Encodes the specified Node message, length delimited. Does not implicitly {@link OSMPBF.Node.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {OSMPBF.INode} message Node message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Node.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a Node message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.Node} Node\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Node.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.Node();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.sint64();\n                    break;\n                case 2:\n                    if (!(message.keys && message.keys.length))\n                        message.keys = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.keys.push(reader.uint32());\n                    } else\n                        message.keys.push(reader.uint32());\n                    break;\n                case 3:\n                    if (!(message.vals && message.vals.length))\n                        message.vals = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.vals.push(reader.uint32());\n                    } else\n                        message.vals.push(reader.uint32());\n                    break;\n                case 4:\n                    message.info = $root.OSMPBF.Info.decode(reader, reader.uint32());\n                    break;\n                case 8:\n                    message.lat = reader.sint64();\n                    break;\n                case 9:\n                    message.lon = reader.sint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            if (!message.hasOwnProperty(\"id\"))\n                throw $util.ProtocolError(\"missing required 'id'\", { instance: message });\n            if (!message.hasOwnProperty(\"lat\"))\n                throw $util.ProtocolError(\"missing required 'lat'\", { instance: message });\n            if (!message.hasOwnProperty(\"lon\"))\n                throw $util.ProtocolError(\"missing required 'lon'\", { instance: message });\n            return message;\n        };\n\n        /**\n         * Decodes a Node message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.Node} Node\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Node.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a Node message.\n         * @function verify\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        Node.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (!$util.isInteger(message.id) && !(message.id && $util.isInteger(message.id.low) && $util.isInteger(message.id.high)))\n                return \"id: integer|Long expected\";\n            if (message.keys != null && message.hasOwnProperty(\"keys\")) {\n                if (!Array.isArray(message.keys))\n                    return \"keys: array expected\";\n                for (var i = 0; i < message.keys.length; ++i)\n                    if (!$util.isInteger(message.keys[i]))\n                        return \"keys: integer[] expected\";\n            }\n            if (message.vals != null && message.hasOwnProperty(\"vals\")) {\n                if (!Array.isArray(message.vals))\n                    return \"vals: array expected\";\n                for (var i = 0; i < message.vals.length; ++i)\n                    if (!$util.isInteger(message.vals[i]))\n                        return \"vals: integer[] expected\";\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\")) {\n                var error = $root.OSMPBF.Info.verify(message.info);\n                if (error)\n                    return \"info.\" + error;\n            }\n            if (!$util.isInteger(message.lat) && !(message.lat && $util.isInteger(message.lat.low) && $util.isInteger(message.lat.high)))\n                return \"lat: integer|Long expected\";\n            if (!$util.isInteger(message.lon) && !(message.lon && $util.isInteger(message.lon.low) && $util.isInteger(message.lon.high)))\n                return \"lon: integer|Long expected\";\n            return null;\n        };\n\n        /**\n         * Creates a Node message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.Node} Node\n         */\n        Node.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.Node)\n                return object;\n            var message = new $root.OSMPBF.Node();\n            if (object.id != null)\n                if ($util.Long)\n                    (message.id = $util.Long.fromValue(object.id)).unsigned = false;\n                else if (typeof object.id === \"string\")\n                    message.id = parseInt(object.id, 10);\n                else if (typeof object.id === \"number\")\n                    message.id = object.id;\n                else if (typeof object.id === \"object\")\n                    message.id = new $util.LongBits(object.id.low >>> 0, object.id.high >>> 0).toNumber();\n            if (object.keys) {\n                if (!Array.isArray(object.keys))\n                    throw TypeError(\".OSMPBF.Node.keys: array expected\");\n                message.keys = [];\n                for (var i = 0; i < object.keys.length; ++i)\n                    message.keys[i] = object.keys[i] >>> 0;\n            }\n            if (object.vals) {\n                if (!Array.isArray(object.vals))\n                    throw TypeError(\".OSMPBF.Node.vals: array expected\");\n                message.vals = [];\n                for (var i = 0; i < object.vals.length; ++i)\n                    message.vals[i] = object.vals[i] >>> 0;\n            }\n            if (object.info != null) {\n                if (typeof object.info !== \"object\")\n                    throw TypeError(\".OSMPBF.Node.info: object expected\");\n                message.info = $root.OSMPBF.Info.fromObject(object.info);\n            }\n            if (object.lat != null)\n                if ($util.Long)\n                    (message.lat = $util.Long.fromValue(object.lat)).unsigned = false;\n                else if (typeof object.lat === \"string\")\n                    message.lat = parseInt(object.lat, 10);\n                else if (typeof object.lat === \"number\")\n                    message.lat = object.lat;\n                else if (typeof object.lat === \"object\")\n                    message.lat = new $util.LongBits(object.lat.low >>> 0, object.lat.high >>> 0).toNumber();\n            if (object.lon != null)\n                if ($util.Long)\n                    (message.lon = $util.Long.fromValue(object.lon)).unsigned = false;\n                else if (typeof object.lon === \"string\")\n                    message.lon = parseInt(object.lon, 10);\n                else if (typeof object.lon === \"number\")\n                    message.lon = object.lon;\n                else if (typeof object.lon === \"object\")\n                    message.lon = new $util.LongBits(object.lon.low >>> 0, object.lon.high >>> 0).toNumber();\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a Node message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.Node\n         * @static\n         * @param {OSMPBF.Node} message Node\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        Node.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults) {\n                object.keys = [];\n                object.vals = [];\n            }\n            if (options.defaults) {\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.id = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.id = options.longs === String ? \"0\" : 0;\n                object.info = null;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.lat = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.lat = options.longs === String ? \"0\" : 0;\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.lon = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.lon = options.longs === String ? \"0\" : 0;\n            }\n            if (message.id != null && message.hasOwnProperty(\"id\"))\n                if (typeof message.id === \"number\")\n                    object.id = options.longs === String ? String(message.id) : message.id;\n                else\n                    object.id = options.longs === String ? $util.Long.prototype.toString.call(message.id) : options.longs === Number ? new $util.LongBits(message.id.low >>> 0, message.id.high >>> 0).toNumber() : message.id;\n            if (message.keys && message.keys.length) {\n                object.keys = [];\n                for (var j = 0; j < message.keys.length; ++j)\n                    object.keys[j] = message.keys[j];\n            }\n            if (message.vals && message.vals.length) {\n                object.vals = [];\n                for (var j = 0; j < message.vals.length; ++j)\n                    object.vals[j] = message.vals[j];\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\"))\n                object.info = $root.OSMPBF.Info.toObject(message.info, options);\n            if (message.lat != null && message.hasOwnProperty(\"lat\"))\n                if (typeof message.lat === \"number\")\n                    object.lat = options.longs === String ? String(message.lat) : message.lat;\n                else\n                    object.lat = options.longs === String ? $util.Long.prototype.toString.call(message.lat) : options.longs === Number ? new $util.LongBits(message.lat.low >>> 0, message.lat.high >>> 0).toNumber() : message.lat;\n            if (message.lon != null && message.hasOwnProperty(\"lon\"))\n                if (typeof message.lon === \"number\")\n                    object.lon = options.longs === String ? String(message.lon) : message.lon;\n                else\n                    object.lon = options.longs === String ? $util.Long.prototype.toString.call(message.lon) : options.longs === Number ? new $util.LongBits(message.lon.low >>> 0, message.lon.high >>> 0).toNumber() : message.lon;\n            return object;\n        };\n\n        /**\n         * Converts this Node to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.Node\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        Node.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return Node;\n    })();\n\n    OSMPBF.DenseNodes = (function() {\n\n        /**\n         * Properties of a DenseNodes.\n         * @memberof OSMPBF\n         * @interface IDenseNodes\n         * @property {Array.<number|Long>|null} [id] DenseNodes id\n         * @property {OSMPBF.IDenseInfo|null} [denseinfo] DenseNodes denseinfo\n         * @property {Array.<number|Long>|null} [lat] DenseNodes lat\n         * @property {Array.<number|Long>|null} [lon] DenseNodes lon\n         * @property {Array.<number>|null} [keysVals] DenseNodes keysVals\n         */\n\n        /**\n         * Constructs a new DenseNodes.\n         * @memberof OSMPBF\n         * @classdesc Represents a DenseNodes.\n         * @implements IDenseNodes\n         * @constructor\n         * @param {OSMPBF.IDenseNodes=} [properties] Properties to set\n         */\n        function DenseNodes(properties) {\n            this.id = [];\n            this.lat = [];\n            this.lon = [];\n            this.keysVals = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * DenseNodes id.\n         * @member {Array.<number|Long>} id\n         * @memberof OSMPBF.DenseNodes\n         * @instance\n         */\n        DenseNodes.prototype.id = $util.emptyArray;\n\n        /**\n         * DenseNodes denseinfo.\n         * @member {OSMPBF.IDenseInfo|null|undefined} denseinfo\n         * @memberof OSMPBF.DenseNodes\n         * @instance\n         */\n        DenseNodes.prototype.denseinfo = null;\n\n        /**\n         * DenseNodes lat.\n         * @member {Array.<number|Long>} lat\n         * @memberof OSMPBF.DenseNodes\n         * @instance\n         */\n        DenseNodes.prototype.lat = $util.emptyArray;\n\n        /**\n         * DenseNodes lon.\n         * @member {Array.<number|Long>} lon\n         * @memberof OSMPBF.DenseNodes\n         * @instance\n         */\n        DenseNodes.prototype.lon = $util.emptyArray;\n\n        /**\n         * DenseNodes keysVals.\n         * @member {Array.<number>} keysVals\n         * @memberof OSMPBF.DenseNodes\n         * @instance\n         */\n        DenseNodes.prototype.keysVals = $util.emptyArray;\n\n        /**\n         * Creates a new DenseNodes instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {OSMPBF.IDenseNodes=} [properties] Properties to set\n         * @returns {OSMPBF.DenseNodes} DenseNodes instance\n         */\n        DenseNodes.create = function create(properties) {\n            return new DenseNodes(properties);\n        };\n\n        /**\n         * Encodes the specified DenseNodes message. Does not implicitly {@link OSMPBF.DenseNodes.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {OSMPBF.IDenseNodes} message DenseNodes message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        DenseNodes.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            if (message.id != null && message.id.length) {\n                writer.uint32(/* id 1, wireType 2 =*/10).fork();\n                for (var i = 0; i < message.id.length; ++i)\n                    writer.sint64(message.id[i]);\n                writer.ldelim();\n            }\n            if (message.denseinfo != null && message.hasOwnProperty(\"denseinfo\"))\n                $root.OSMPBF.DenseInfo.encode(message.denseinfo, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();\n            if (message.lat != null && message.lat.length) {\n                writer.uint32(/* id 8, wireType 2 =*/66).fork();\n                for (var i = 0; i < message.lat.length; ++i)\n                    writer.sint64(message.lat[i]);\n                writer.ldelim();\n            }\n            if (message.lon != null && message.lon.length) {\n                writer.uint32(/* id 9, wireType 2 =*/74).fork();\n                for (var i = 0; i < message.lon.length; ++i)\n                    writer.sint64(message.lon[i]);\n                writer.ldelim();\n            }\n            if (message.keysVals != null && message.keysVals.length) {\n                writer.uint32(/* id 10, wireType 2 =*/82).fork();\n                for (var i = 0; i < message.keysVals.length; ++i)\n                    writer.int32(message.keysVals[i]);\n                writer.ldelim();\n            }\n            return writer;\n        };\n\n        /**\n         * Encodes the specified DenseNodes message, length delimited. Does not implicitly {@link OSMPBF.DenseNodes.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {OSMPBF.IDenseNodes} message DenseNodes message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        DenseNodes.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a DenseNodes message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.DenseNodes} DenseNodes\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        DenseNodes.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.DenseNodes();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    if (!(message.id && message.id.length))\n                        message.id = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.id.push(reader.sint64());\n                    } else\n                        message.id.push(reader.sint64());\n                    break;\n                case 5:\n                    message.denseinfo = $root.OSMPBF.DenseInfo.decode(reader, reader.uint32());\n                    break;\n                case 8:\n                    if (!(message.lat && message.lat.length))\n                        message.lat = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.lat.push(reader.sint64());\n                    } else\n                        message.lat.push(reader.sint64());\n                    break;\n                case 9:\n                    if (!(message.lon && message.lon.length))\n                        message.lon = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.lon.push(reader.sint64());\n                    } else\n                        message.lon.push(reader.sint64());\n                    break;\n                case 10:\n                    if (!(message.keysVals && message.keysVals.length))\n                        message.keysVals = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.keysVals.push(reader.int32());\n                    } else\n                        message.keysVals.push(reader.int32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            return message;\n        };\n\n        /**\n         * Decodes a DenseNodes message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.DenseNodes} DenseNodes\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        DenseNodes.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a DenseNodes message.\n         * @function verify\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        DenseNodes.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (message.id != null && message.hasOwnProperty(\"id\")) {\n                if (!Array.isArray(message.id))\n                    return \"id: array expected\";\n                for (var i = 0; i < message.id.length; ++i)\n                    if (!$util.isInteger(message.id[i]) && !(message.id[i] && $util.isInteger(message.id[i].low) && $util.isInteger(message.id[i].high)))\n                        return \"id: integer|Long[] expected\";\n            }\n            if (message.denseinfo != null && message.hasOwnProperty(\"denseinfo\")) {\n                var error = $root.OSMPBF.DenseInfo.verify(message.denseinfo);\n                if (error)\n                    return \"denseinfo.\" + error;\n            }\n            if (message.lat != null && message.hasOwnProperty(\"lat\")) {\n                if (!Array.isArray(message.lat))\n                    return \"lat: array expected\";\n                for (var i = 0; i < message.lat.length; ++i)\n                    if (!$util.isInteger(message.lat[i]) && !(message.lat[i] && $util.isInteger(message.lat[i].low) && $util.isInteger(message.lat[i].high)))\n                        return \"lat: integer|Long[] expected\";\n            }\n            if (message.lon != null && message.hasOwnProperty(\"lon\")) {\n                if (!Array.isArray(message.lon))\n                    return \"lon: array expected\";\n                for (var i = 0; i < message.lon.length; ++i)\n                    if (!$util.isInteger(message.lon[i]) && !(message.lon[i] && $util.isInteger(message.lon[i].low) && $util.isInteger(message.lon[i].high)))\n                        return \"lon: integer|Long[] expected\";\n            }\n            if (message.keysVals != null && message.hasOwnProperty(\"keysVals\")) {\n                if (!Array.isArray(message.keysVals))\n                    return \"keysVals: array expected\";\n                for (var i = 0; i < message.keysVals.length; ++i)\n                    if (!$util.isInteger(message.keysVals[i]))\n                        return \"keysVals: integer[] expected\";\n            }\n            return null;\n        };\n\n        /**\n         * Creates a DenseNodes message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.DenseNodes} DenseNodes\n         */\n        DenseNodes.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.DenseNodes)\n                return object;\n            var message = new $root.OSMPBF.DenseNodes();\n            if (object.id) {\n                if (!Array.isArray(object.id))\n                    throw TypeError(\".OSMPBF.DenseNodes.id: array expected\");\n                message.id = [];\n                for (var i = 0; i < object.id.length; ++i)\n                    if ($util.Long)\n                        (message.id[i] = $util.Long.fromValue(object.id[i])).unsigned = false;\n                    else if (typeof object.id[i] === \"string\")\n                        message.id[i] = parseInt(object.id[i], 10);\n                    else if (typeof object.id[i] === \"number\")\n                        message.id[i] = object.id[i];\n                    else if (typeof object.id[i] === \"object\")\n                        message.id[i] = new $util.LongBits(object.id[i].low >>> 0, object.id[i].high >>> 0).toNumber();\n            }\n            if (object.denseinfo != null) {\n                if (typeof object.denseinfo !== \"object\")\n                    throw TypeError(\".OSMPBF.DenseNodes.denseinfo: object expected\");\n                message.denseinfo = $root.OSMPBF.DenseInfo.fromObject(object.denseinfo);\n            }\n            if (object.lat) {\n                if (!Array.isArray(object.lat))\n                    throw TypeError(\".OSMPBF.DenseNodes.lat: array expected\");\n                message.lat = [];\n                for (var i = 0; i < object.lat.length; ++i)\n                    if ($util.Long)\n                        (message.lat[i] = $util.Long.fromValue(object.lat[i])).unsigned = false;\n                    else if (typeof object.lat[i] === \"string\")\n                        message.lat[i] = parseInt(object.lat[i], 10);\n                    else if (typeof object.lat[i] === \"number\")\n                        message.lat[i] = object.lat[i];\n                    else if (typeof object.lat[i] === \"object\")\n                        message.lat[i] = new $util.LongBits(object.lat[i].low >>> 0, object.lat[i].high >>> 0).toNumber();\n            }\n            if (object.lon) {\n                if (!Array.isArray(object.lon))\n                    throw TypeError(\".OSMPBF.DenseNodes.lon: array expected\");\n                message.lon = [];\n                for (var i = 0; i < object.lon.length; ++i)\n                    if ($util.Long)\n                        (message.lon[i] = $util.Long.fromValue(object.lon[i])).unsigned = false;\n                    else if (typeof object.lon[i] === \"string\")\n                        message.lon[i] = parseInt(object.lon[i], 10);\n                    else if (typeof object.lon[i] === \"number\")\n                        message.lon[i] = object.lon[i];\n                    else if (typeof object.lon[i] === \"object\")\n                        message.lon[i] = new $util.LongBits(object.lon[i].low >>> 0, object.lon[i].high >>> 0).toNumber();\n            }\n            if (object.keysVals) {\n                if (!Array.isArray(object.keysVals))\n                    throw TypeError(\".OSMPBF.DenseNodes.keysVals: array expected\");\n                message.keysVals = [];\n                for (var i = 0; i < object.keysVals.length; ++i)\n                    message.keysVals[i] = object.keysVals[i] | 0;\n            }\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a DenseNodes message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.DenseNodes\n         * @static\n         * @param {OSMPBF.DenseNodes} message DenseNodes\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        DenseNodes.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults) {\n                object.id = [];\n                object.lat = [];\n                object.lon = [];\n                object.keysVals = [];\n            }\n            if (options.defaults)\n                object.denseinfo = null;\n            if (message.id && message.id.length) {\n                object.id = [];\n                for (var j = 0; j < message.id.length; ++j)\n                    if (typeof message.id[j] === \"number\")\n                        object.id[j] = options.longs === String ? String(message.id[j]) : message.id[j];\n                    else\n                        object.id[j] = options.longs === String ? $util.Long.prototype.toString.call(message.id[j]) : options.longs === Number ? new $util.LongBits(message.id[j].low >>> 0, message.id[j].high >>> 0).toNumber() : message.id[j];\n            }\n            if (message.denseinfo != null && message.hasOwnProperty(\"denseinfo\"))\n                object.denseinfo = $root.OSMPBF.DenseInfo.toObject(message.denseinfo, options);\n            if (message.lat && message.lat.length) {\n                object.lat = [];\n                for (var j = 0; j < message.lat.length; ++j)\n                    if (typeof message.lat[j] === \"number\")\n                        object.lat[j] = options.longs === String ? String(message.lat[j]) : message.lat[j];\n                    else\n                        object.lat[j] = options.longs === String ? $util.Long.prototype.toString.call(message.lat[j]) : options.longs === Number ? new $util.LongBits(message.lat[j].low >>> 0, message.lat[j].high >>> 0).toNumber() : message.lat[j];\n            }\n            if (message.lon && message.lon.length) {\n                object.lon = [];\n                for (var j = 0; j < message.lon.length; ++j)\n                    if (typeof message.lon[j] === \"number\")\n                        object.lon[j] = options.longs === String ? String(message.lon[j]) : message.lon[j];\n                    else\n                        object.lon[j] = options.longs === String ? $util.Long.prototype.toString.call(message.lon[j]) : options.longs === Number ? new $util.LongBits(message.lon[j].low >>> 0, message.lon[j].high >>> 0).toNumber() : message.lon[j];\n            }\n            if (message.keysVals && message.keysVals.length) {\n                object.keysVals = [];\n                for (var j = 0; j < message.keysVals.length; ++j)\n                    object.keysVals[j] = message.keysVals[j];\n            }\n            return object;\n        };\n\n        /**\n         * Converts this DenseNodes to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.DenseNodes\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        DenseNodes.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return DenseNodes;\n    })();\n\n    OSMPBF.Way = (function() {\n\n        /**\n         * Properties of a Way.\n         * @memberof OSMPBF\n         * @interface IWay\n         * @property {number|Long} id Way id\n         * @property {Array.<number>|null} [keys] Way keys\n         * @property {Array.<number>|null} [vals] Way vals\n         * @property {OSMPBF.IInfo|null} [info] Way info\n         * @property {Array.<number|Long>|null} [refs] Way refs\n         */\n\n        /**\n         * Constructs a new Way.\n         * @memberof OSMPBF\n         * @classdesc Represents a Way.\n         * @implements IWay\n         * @constructor\n         * @param {OSMPBF.IWay=} [properties] Properties to set\n         */\n        function Way(properties) {\n            this.keys = [];\n            this.vals = [];\n            this.refs = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * Way id.\n         * @member {number|Long} id\n         * @memberof OSMPBF.Way\n         * @instance\n         */\n        Way.prototype.id = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Way keys.\n         * @member {Array.<number>} keys\n         * @memberof OSMPBF.Way\n         * @instance\n         */\n        Way.prototype.keys = $util.emptyArray;\n\n        /**\n         * Way vals.\n         * @member {Array.<number>} vals\n         * @memberof OSMPBF.Way\n         * @instance\n         */\n        Way.prototype.vals = $util.emptyArray;\n\n        /**\n         * Way info.\n         * @member {OSMPBF.IInfo|null|undefined} info\n         * @memberof OSMPBF.Way\n         * @instance\n         */\n        Way.prototype.info = null;\n\n        /**\n         * Way refs.\n         * @member {Array.<number|Long>} refs\n         * @memberof OSMPBF.Way\n         * @instance\n         */\n        Way.prototype.refs = $util.emptyArray;\n\n        /**\n         * Creates a new Way instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {OSMPBF.IWay=} [properties] Properties to set\n         * @returns {OSMPBF.Way} Way instance\n         */\n        Way.create = function create(properties) {\n            return new Way(properties);\n        };\n\n        /**\n         * Encodes the specified Way message. Does not implicitly {@link OSMPBF.Way.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {OSMPBF.IWay} message Way message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Way.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            writer.uint32(/* id 1, wireType 0 =*/8).int64(message.id);\n            if (message.keys != null && message.keys.length) {\n                writer.uint32(/* id 2, wireType 2 =*/18).fork();\n                for (var i = 0; i < message.keys.length; ++i)\n                    writer.uint32(message.keys[i]);\n                writer.ldelim();\n            }\n            if (message.vals != null && message.vals.length) {\n                writer.uint32(/* id 3, wireType 2 =*/26).fork();\n                for (var i = 0; i < message.vals.length; ++i)\n                    writer.uint32(message.vals[i]);\n                writer.ldelim();\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\"))\n                $root.OSMPBF.Info.encode(message.info, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n            if (message.refs != null && message.refs.length) {\n                writer.uint32(/* id 8, wireType 2 =*/66).fork();\n                for (var i = 0; i < message.refs.length; ++i)\n                    writer.sint64(message.refs[i]);\n                writer.ldelim();\n            }\n            return writer;\n        };\n\n        /**\n         * Encodes the specified Way message, length delimited. Does not implicitly {@link OSMPBF.Way.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {OSMPBF.IWay} message Way message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Way.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a Way message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.Way} Way\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Way.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.Way();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.int64();\n                    break;\n                case 2:\n                    if (!(message.keys && message.keys.length))\n                        message.keys = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.keys.push(reader.uint32());\n                    } else\n                        message.keys.push(reader.uint32());\n                    break;\n                case 3:\n                    if (!(message.vals && message.vals.length))\n                        message.vals = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.vals.push(reader.uint32());\n                    } else\n                        message.vals.push(reader.uint32());\n                    break;\n                case 4:\n                    message.info = $root.OSMPBF.Info.decode(reader, reader.uint32());\n                    break;\n                case 8:\n                    if (!(message.refs && message.refs.length))\n                        message.refs = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.refs.push(reader.sint64());\n                    } else\n                        message.refs.push(reader.sint64());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            if (!message.hasOwnProperty(\"id\"))\n                throw $util.ProtocolError(\"missing required 'id'\", { instance: message });\n            return message;\n        };\n\n        /**\n         * Decodes a Way message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.Way} Way\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Way.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a Way message.\n         * @function verify\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        Way.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (!$util.isInteger(message.id) && !(message.id && $util.isInteger(message.id.low) && $util.isInteger(message.id.high)))\n                return \"id: integer|Long expected\";\n            if (message.keys != null && message.hasOwnProperty(\"keys\")) {\n                if (!Array.isArray(message.keys))\n                    return \"keys: array expected\";\n                for (var i = 0; i < message.keys.length; ++i)\n                    if (!$util.isInteger(message.keys[i]))\n                        return \"keys: integer[] expected\";\n            }\n            if (message.vals != null && message.hasOwnProperty(\"vals\")) {\n                if (!Array.isArray(message.vals))\n                    return \"vals: array expected\";\n                for (var i = 0; i < message.vals.length; ++i)\n                    if (!$util.isInteger(message.vals[i]))\n                        return \"vals: integer[] expected\";\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\")) {\n                var error = $root.OSMPBF.Info.verify(message.info);\n                if (error)\n                    return \"info.\" + error;\n            }\n            if (message.refs != null && message.hasOwnProperty(\"refs\")) {\n                if (!Array.isArray(message.refs))\n                    return \"refs: array expected\";\n                for (var i = 0; i < message.refs.length; ++i)\n                    if (!$util.isInteger(message.refs[i]) && !(message.refs[i] && $util.isInteger(message.refs[i].low) && $util.isInteger(message.refs[i].high)))\n                        return \"refs: integer|Long[] expected\";\n            }\n            return null;\n        };\n\n        /**\n         * Creates a Way message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.Way} Way\n         */\n        Way.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.Way)\n                return object;\n            var message = new $root.OSMPBF.Way();\n            if (object.id != null)\n                if ($util.Long)\n                    (message.id = $util.Long.fromValue(object.id)).unsigned = false;\n                else if (typeof object.id === \"string\")\n                    message.id = parseInt(object.id, 10);\n                else if (typeof object.id === \"number\")\n                    message.id = object.id;\n                else if (typeof object.id === \"object\")\n                    message.id = new $util.LongBits(object.id.low >>> 0, object.id.high >>> 0).toNumber();\n            if (object.keys) {\n                if (!Array.isArray(object.keys))\n                    throw TypeError(\".OSMPBF.Way.keys: array expected\");\n                message.keys = [];\n                for (var i = 0; i < object.keys.length; ++i)\n                    message.keys[i] = object.keys[i] >>> 0;\n            }\n            if (object.vals) {\n                if (!Array.isArray(object.vals))\n                    throw TypeError(\".OSMPBF.Way.vals: array expected\");\n                message.vals = [];\n                for (var i = 0; i < object.vals.length; ++i)\n                    message.vals[i] = object.vals[i] >>> 0;\n            }\n            if (object.info != null) {\n                if (typeof object.info !== \"object\")\n                    throw TypeError(\".OSMPBF.Way.info: object expected\");\n                message.info = $root.OSMPBF.Info.fromObject(object.info);\n            }\n            if (object.refs) {\n                if (!Array.isArray(object.refs))\n                    throw TypeError(\".OSMPBF.Way.refs: array expected\");\n                message.refs = [];\n                for (var i = 0; i < object.refs.length; ++i)\n                    if ($util.Long)\n                        (message.refs[i] = $util.Long.fromValue(object.refs[i])).unsigned = false;\n                    else if (typeof object.refs[i] === \"string\")\n                        message.refs[i] = parseInt(object.refs[i], 10);\n                    else if (typeof object.refs[i] === \"number\")\n                        message.refs[i] = object.refs[i];\n                    else if (typeof object.refs[i] === \"object\")\n                        message.refs[i] = new $util.LongBits(object.refs[i].low >>> 0, object.refs[i].high >>> 0).toNumber();\n            }\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a Way message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.Way\n         * @static\n         * @param {OSMPBF.Way} message Way\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        Way.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults) {\n                object.keys = [];\n                object.vals = [];\n                object.refs = [];\n            }\n            if (options.defaults) {\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.id = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.id = options.longs === String ? \"0\" : 0;\n                object.info = null;\n            }\n            if (message.id != null && message.hasOwnProperty(\"id\"))\n                if (typeof message.id === \"number\")\n                    object.id = options.longs === String ? String(message.id) : message.id;\n                else\n                    object.id = options.longs === String ? $util.Long.prototype.toString.call(message.id) : options.longs === Number ? new $util.LongBits(message.id.low >>> 0, message.id.high >>> 0).toNumber() : message.id;\n            if (message.keys && message.keys.length) {\n                object.keys = [];\n                for (var j = 0; j < message.keys.length; ++j)\n                    object.keys[j] = message.keys[j];\n            }\n            if (message.vals && message.vals.length) {\n                object.vals = [];\n                for (var j = 0; j < message.vals.length; ++j)\n                    object.vals[j] = message.vals[j];\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\"))\n                object.info = $root.OSMPBF.Info.toObject(message.info, options);\n            if (message.refs && message.refs.length) {\n                object.refs = [];\n                for (var j = 0; j < message.refs.length; ++j)\n                    if (typeof message.refs[j] === \"number\")\n                        object.refs[j] = options.longs === String ? String(message.refs[j]) : message.refs[j];\n                    else\n                        object.refs[j] = options.longs === String ? $util.Long.prototype.toString.call(message.refs[j]) : options.longs === Number ? new $util.LongBits(message.refs[j].low >>> 0, message.refs[j].high >>> 0).toNumber() : message.refs[j];\n            }\n            return object;\n        };\n\n        /**\n         * Converts this Way to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.Way\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        Way.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        return Way;\n    })();\n\n    OSMPBF.Relation = (function() {\n\n        /**\n         * Properties of a Relation.\n         * @memberof OSMPBF\n         * @interface IRelation\n         * @property {number|Long} id Relation id\n         * @property {Array.<number>|null} [keys] Relation keys\n         * @property {Array.<number>|null} [vals] Relation vals\n         * @property {OSMPBF.IInfo|null} [info] Relation info\n         * @property {Array.<number>|null} [rolesSid] Relation rolesSid\n         * @property {Array.<number|Long>|null} [memids] Relation memids\n         * @property {Array.<OSMPBF.Relation.MemberType>|null} [types] Relation types\n         */\n\n        /**\n         * Constructs a new Relation.\n         * @memberof OSMPBF\n         * @classdesc Represents a Relation.\n         * @implements IRelation\n         * @constructor\n         * @param {OSMPBF.IRelation=} [properties] Properties to set\n         */\n        function Relation(properties) {\n            this.keys = [];\n            this.vals = [];\n            this.rolesSid = [];\n            this.memids = [];\n            this.types = [];\n            if (properties)\n                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n                    if (properties[keys[i]] != null)\n                        this[keys[i]] = properties[keys[i]];\n        }\n\n        /**\n         * Relation id.\n         * @member {number|Long} id\n         * @memberof OSMPBF.Relation\n         * @instance\n         */\n        Relation.prototype.id = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n        /**\n         * Relation keys.\n         * @member {Array.<number>} keys\n         * @memberof OSMPBF.Relation\n         * @instance\n         */\n        Relation.prototype.keys = $util.emptyArray;\n\n        /**\n         * Relation vals.\n         * @member {Array.<number>} vals\n         * @memberof OSMPBF.Relation\n         * @instance\n         */\n        Relation.prototype.vals = $util.emptyArray;\n\n        /**\n         * Relation info.\n         * @member {OSMPBF.IInfo|null|undefined} info\n         * @memberof OSMPBF.Relation\n         * @instance\n         */\n        Relation.prototype.info = null;\n\n        /**\n         * Relation rolesSid.\n         * @member {Array.<number>} rolesSid\n         * @memberof OSMPBF.Relation\n         * @instance\n         */\n        Relation.prototype.rolesSid = $util.emptyArray;\n\n        /**\n         * Relation memids.\n         * @member {Array.<number|Long>} memids\n         * @memberof OSMPBF.Relation\n         * @instance\n         */\n        Relation.prototype.memids = $util.emptyArray;\n\n        /**\n         * Relation types.\n         * @member {Array.<OSMPBF.Relation.MemberType>} types\n         * @memberof OSMPBF.Relation\n         * @instance\n         */\n        Relation.prototype.types = $util.emptyArray;\n\n        /**\n         * Creates a new Relation instance using the specified properties.\n         * @function create\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {OSMPBF.IRelation=} [properties] Properties to set\n         * @returns {OSMPBF.Relation} Relation instance\n         */\n        Relation.create = function create(properties) {\n            return new Relation(properties);\n        };\n\n        /**\n         * Encodes the specified Relation message. Does not implicitly {@link OSMPBF.Relation.verify|verify} messages.\n         * @function encode\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {OSMPBF.IRelation} message Relation message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Relation.encode = function encode(message, writer) {\n            if (!writer)\n                writer = $Writer.create();\n            writer.uint32(/* id 1, wireType 0 =*/8).int64(message.id);\n            if (message.keys != null && message.keys.length) {\n                writer.uint32(/* id 2, wireType 2 =*/18).fork();\n                for (var i = 0; i < message.keys.length; ++i)\n                    writer.uint32(message.keys[i]);\n                writer.ldelim();\n            }\n            if (message.vals != null && message.vals.length) {\n                writer.uint32(/* id 3, wireType 2 =*/26).fork();\n                for (var i = 0; i < message.vals.length; ++i)\n                    writer.uint32(message.vals[i]);\n                writer.ldelim();\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\"))\n                $root.OSMPBF.Info.encode(message.info, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();\n            if (message.rolesSid != null && message.rolesSid.length) {\n                writer.uint32(/* id 8, wireType 2 =*/66).fork();\n                for (var i = 0; i < message.rolesSid.length; ++i)\n                    writer.int32(message.rolesSid[i]);\n                writer.ldelim();\n            }\n            if (message.memids != null && message.memids.length) {\n                writer.uint32(/* id 9, wireType 2 =*/74).fork();\n                for (var i = 0; i < message.memids.length; ++i)\n                    writer.sint64(message.memids[i]);\n                writer.ldelim();\n            }\n            if (message.types != null && message.types.length) {\n                writer.uint32(/* id 10, wireType 2 =*/82).fork();\n                for (var i = 0; i < message.types.length; ++i)\n                    writer.int32(message.types[i]);\n                writer.ldelim();\n            }\n            return writer;\n        };\n\n        /**\n         * Encodes the specified Relation message, length delimited. Does not implicitly {@link OSMPBF.Relation.verify|verify} messages.\n         * @function encodeDelimited\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {OSMPBF.IRelation} message Relation message or plain object to encode\n         * @param {$protobuf.Writer} [writer] Writer to encode to\n         * @returns {$protobuf.Writer} Writer\n         */\n        Relation.encodeDelimited = function encodeDelimited(message, writer) {\n            return this.encode(message, writer).ldelim();\n        };\n\n        /**\n         * Decodes a Relation message from the specified reader or buffer.\n         * @function decode\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @param {number} [length] Message length if known beforehand\n         * @returns {OSMPBF.Relation} Relation\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Relation.decode = function decode(reader, length) {\n            if (!(reader instanceof $Reader))\n                reader = $Reader.create(reader);\n            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.OSMPBF.Relation();\n            while (reader.pos < end) {\n                var tag = reader.uint32();\n                switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.int64();\n                    break;\n                case 2:\n                    if (!(message.keys && message.keys.length))\n                        message.keys = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.keys.push(reader.uint32());\n                    } else\n                        message.keys.push(reader.uint32());\n                    break;\n                case 3:\n                    if (!(message.vals && message.vals.length))\n                        message.vals = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.vals.push(reader.uint32());\n                    } else\n                        message.vals.push(reader.uint32());\n                    break;\n                case 4:\n                    message.info = $root.OSMPBF.Info.decode(reader, reader.uint32());\n                    break;\n                case 8:\n                    if (!(message.rolesSid && message.rolesSid.length))\n                        message.rolesSid = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.rolesSid.push(reader.int32());\n                    } else\n                        message.rolesSid.push(reader.int32());\n                    break;\n                case 9:\n                    if (!(message.memids && message.memids.length))\n                        message.memids = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.memids.push(reader.sint64());\n                    } else\n                        message.memids.push(reader.sint64());\n                    break;\n                case 10:\n                    if (!(message.types && message.types.length))\n                        message.types = [];\n                    if ((tag & 7) === 2) {\n                        var end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2)\n                            message.types.push(reader.int32());\n                    } else\n                        message.types.push(reader.int32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n                }\n            }\n            if (!message.hasOwnProperty(\"id\"))\n                throw $util.ProtocolError(\"missing required 'id'\", { instance: message });\n            return message;\n        };\n\n        /**\n         * Decodes a Relation message from the specified reader or buffer, length delimited.\n         * @function decodeDelimited\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from\n         * @returns {OSMPBF.Relation} Relation\n         * @throws {Error} If the payload is not a reader or valid buffer\n         * @throws {$protobuf.util.ProtocolError} If required fields are missing\n         */\n        Relation.decodeDelimited = function decodeDelimited(reader) {\n            if (!(reader instanceof $Reader))\n                reader = new $Reader(reader);\n            return this.decode(reader, reader.uint32());\n        };\n\n        /**\n         * Verifies a Relation message.\n         * @function verify\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {Object.<string,*>} message Plain object to verify\n         * @returns {string|null} `null` if valid, otherwise the reason why it is not\n         */\n        Relation.verify = function verify(message) {\n            if (typeof message !== \"object\" || message === null)\n                return \"object expected\";\n            if (!$util.isInteger(message.id) && !(message.id && $util.isInteger(message.id.low) && $util.isInteger(message.id.high)))\n                return \"id: integer|Long expected\";\n            if (message.keys != null && message.hasOwnProperty(\"keys\")) {\n                if (!Array.isArray(message.keys))\n                    return \"keys: array expected\";\n                for (var i = 0; i < message.keys.length; ++i)\n                    if (!$util.isInteger(message.keys[i]))\n                        return \"keys: integer[] expected\";\n            }\n            if (message.vals != null && message.hasOwnProperty(\"vals\")) {\n                if (!Array.isArray(message.vals))\n                    return \"vals: array expected\";\n                for (var i = 0; i < message.vals.length; ++i)\n                    if (!$util.isInteger(message.vals[i]))\n                        return \"vals: integer[] expected\";\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\")) {\n                var error = $root.OSMPBF.Info.verify(message.info);\n                if (error)\n                    return \"info.\" + error;\n            }\n            if (message.rolesSid != null && message.hasOwnProperty(\"rolesSid\")) {\n                if (!Array.isArray(message.rolesSid))\n                    return \"rolesSid: array expected\";\n                for (var i = 0; i < message.rolesSid.length; ++i)\n                    if (!$util.isInteger(message.rolesSid[i]))\n                        return \"rolesSid: integer[] expected\";\n            }\n            if (message.memids != null && message.hasOwnProperty(\"memids\")) {\n                if (!Array.isArray(message.memids))\n                    return \"memids: array expected\";\n                for (var i = 0; i < message.memids.length; ++i)\n                    if (!$util.isInteger(message.memids[i]) && !(message.memids[i] && $util.isInteger(message.memids[i].low) && $util.isInteger(message.memids[i].high)))\n                        return \"memids: integer|Long[] expected\";\n            }\n            if (message.types != null && message.hasOwnProperty(\"types\")) {\n                if (!Array.isArray(message.types))\n                    return \"types: array expected\";\n                for (var i = 0; i < message.types.length; ++i)\n                    switch (message.types[i]) {\n                    default:\n                        return \"types: enum value[] expected\";\n                    case 0:\n                    case 1:\n                    case 2:\n                        break;\n                    }\n            }\n            return null;\n        };\n\n        /**\n         * Creates a Relation message from a plain object. Also converts values to their respective internal types.\n         * @function fromObject\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {Object.<string,*>} object Plain object\n         * @returns {OSMPBF.Relation} Relation\n         */\n        Relation.fromObject = function fromObject(object) {\n            if (object instanceof $root.OSMPBF.Relation)\n                return object;\n            var message = new $root.OSMPBF.Relation();\n            if (object.id != null)\n                if ($util.Long)\n                    (message.id = $util.Long.fromValue(object.id)).unsigned = false;\n                else if (typeof object.id === \"string\")\n                    message.id = parseInt(object.id, 10);\n                else if (typeof object.id === \"number\")\n                    message.id = object.id;\n                else if (typeof object.id === \"object\")\n                    message.id = new $util.LongBits(object.id.low >>> 0, object.id.high >>> 0).toNumber();\n            if (object.keys) {\n                if (!Array.isArray(object.keys))\n                    throw TypeError(\".OSMPBF.Relation.keys: array expected\");\n                message.keys = [];\n                for (var i = 0; i < object.keys.length; ++i)\n                    message.keys[i] = object.keys[i] >>> 0;\n            }\n            if (object.vals) {\n                if (!Array.isArray(object.vals))\n                    throw TypeError(\".OSMPBF.Relation.vals: array expected\");\n                message.vals = [];\n                for (var i = 0; i < object.vals.length; ++i)\n                    message.vals[i] = object.vals[i] >>> 0;\n            }\n            if (object.info != null) {\n                if (typeof object.info !== \"object\")\n                    throw TypeError(\".OSMPBF.Relation.info: object expected\");\n                message.info = $root.OSMPBF.Info.fromObject(object.info);\n            }\n            if (object.rolesSid) {\n                if (!Array.isArray(object.rolesSid))\n                    throw TypeError(\".OSMPBF.Relation.rolesSid: array expected\");\n                message.rolesSid = [];\n                for (var i = 0; i < object.rolesSid.length; ++i)\n                    message.rolesSid[i] = object.rolesSid[i] | 0;\n            }\n            if (object.memids) {\n                if (!Array.isArray(object.memids))\n                    throw TypeError(\".OSMPBF.Relation.memids: array expected\");\n                message.memids = [];\n                for (var i = 0; i < object.memids.length; ++i)\n                    if ($util.Long)\n                        (message.memids[i] = $util.Long.fromValue(object.memids[i])).unsigned = false;\n                    else if (typeof object.memids[i] === \"string\")\n                        message.memids[i] = parseInt(object.memids[i], 10);\n                    else if (typeof object.memids[i] === \"number\")\n                        message.memids[i] = object.memids[i];\n                    else if (typeof object.memids[i] === \"object\")\n                        message.memids[i] = new $util.LongBits(object.memids[i].low >>> 0, object.memids[i].high >>> 0).toNumber();\n            }\n            if (object.types) {\n                if (!Array.isArray(object.types))\n                    throw TypeError(\".OSMPBF.Relation.types: array expected\");\n                message.types = [];\n                for (var i = 0; i < object.types.length; ++i)\n                    switch (object.types[i]) {\n                    default:\n                    case \"NODE\":\n                    case 0:\n                        message.types[i] = 0;\n                        break;\n                    case \"WAY\":\n                    case 1:\n                        message.types[i] = 1;\n                        break;\n                    case \"RELATION\":\n                    case 2:\n                        message.types[i] = 2;\n                        break;\n                    }\n            }\n            return message;\n        };\n\n        /**\n         * Creates a plain object from a Relation message. Also converts values to other types if specified.\n         * @function toObject\n         * @memberof OSMPBF.Relation\n         * @static\n         * @param {OSMPBF.Relation} message Relation\n         * @param {$protobuf.IConversionOptions} [options] Conversion options\n         * @returns {Object.<string,*>} Plain object\n         */\n        Relation.toObject = function toObject(message, options) {\n            if (!options)\n                options = {};\n            var object = {};\n            if (options.arrays || options.defaults) {\n                object.keys = [];\n                object.vals = [];\n                object.rolesSid = [];\n                object.memids = [];\n                object.types = [];\n            }\n            if (options.defaults) {\n                if ($util.Long) {\n                    var long = new $util.Long(0, 0, false);\n                    object.id = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;\n                } else\n                    object.id = options.longs === String ? \"0\" : 0;\n                object.info = null;\n            }\n            if (message.id != null && message.hasOwnProperty(\"id\"))\n                if (typeof message.id === \"number\")\n                    object.id = options.longs === String ? String(message.id) : message.id;\n                else\n                    object.id = options.longs === String ? $util.Long.prototype.toString.call(message.id) : options.longs === Number ? new $util.LongBits(message.id.low >>> 0, message.id.high >>> 0).toNumber() : message.id;\n            if (message.keys && message.keys.length) {\n                object.keys = [];\n                for (var j = 0; j < message.keys.length; ++j)\n                    object.keys[j] = message.keys[j];\n            }\n            if (message.vals && message.vals.length) {\n                object.vals = [];\n                for (var j = 0; j < message.vals.length; ++j)\n                    object.vals[j] = message.vals[j];\n            }\n            if (message.info != null && message.hasOwnProperty(\"info\"))\n                object.info = $root.OSMPBF.Info.toObject(message.info, options);\n            if (message.rolesSid && message.rolesSid.length) {\n                object.rolesSid = [];\n                for (var j = 0; j < message.rolesSid.length; ++j)\n                    object.rolesSid[j] = message.rolesSid[j];\n            }\n            if (message.memids && message.memids.length) {\n                object.memids = [];\n                for (var j = 0; j < message.memids.length; ++j)\n                    if (typeof message.memids[j] === \"number\")\n                        object.memids[j] = options.longs === String ? String(message.memids[j]) : message.memids[j];\n                    else\n                        object.memids[j] = options.longs === String ? $util.Long.prototype.toString.call(message.memids[j]) : options.longs === Number ? new $util.LongBits(message.memids[j].low >>> 0, message.memids[j].high >>> 0).toNumber() : message.memids[j];\n            }\n            if (message.types && message.types.length) {\n                object.types = [];\n                for (var j = 0; j < message.types.length; ++j)\n                    object.types[j] = options.enums === String ? $root.OSMPBF.Relation.MemberType[message.types[j]] : message.types[j];\n            }\n            return object;\n        };\n\n        /**\n         * Converts this Relation to JSON.\n         * @function toJSON\n         * @memberof OSMPBF.Relation\n         * @instance\n         * @returns {Object.<string,*>} JSON object\n         */\n        Relation.prototype.toJSON = function toJSON() {\n            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n        };\n\n        /**\n         * MemberType enum.\n         * @name OSMPBF.Relation.MemberType\n         * @enum {string}\n         * @property {number} NODE=0 NODE value\n         * @property {number} WAY=1 WAY value\n         * @property {number} RELATION=2 RELATION value\n         */\n        Relation.MemberType = (function() {\n            var valuesById = {}, values = Object.create(valuesById);\n            values[valuesById[0] = \"NODE\"] = 0;\n            values[valuesById[1] = \"WAY\"] = 1;\n            values[valuesById[2] = \"RELATION\"] = 2;\n            return values;\n        })();\n\n        return Relation;\n    })();\n\n    return OSMPBF;\n})();\n\nmodule.exports = $root;\n","\"use strict\";\r\nmodule.exports = asPromise;\r\n\r\n/**\r\n * Callback as used by {@link util.asPromise}.\r\n * @typedef asPromiseCallback\r\n * @type {function}\r\n * @param {Error|null} error Error, if any\r\n * @param {...*} params Additional arguments\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Returns a promise from a node-style callback function.\r\n * @memberof util\r\n * @param {asPromiseCallback} fn Function to call\r\n * @param {*} ctx Function context\r\n * @param {...*} params Function arguments\r\n * @returns {Promise<*>} Promisified function\r\n */\r\nfunction asPromise(fn, ctx/*, varargs */) {\r\n    var params  = new Array(arguments.length - 1),\r\n        offset  = 0,\r\n        index   = 2,\r\n        pending = true;\r\n    while (index < arguments.length)\r\n        params[offset++] = arguments[index++];\r\n    return new Promise(function executor(resolve, reject) {\r\n        params[offset] = function callback(err/*, varargs */) {\r\n            if (pending) {\r\n                pending = false;\r\n                if (err)\r\n                    reject(err);\r\n                else {\r\n                    var params = new Array(arguments.length - 1),\r\n                        offset = 0;\r\n                    while (offset < params.length)\r\n                        params[offset++] = arguments[offset];\r\n                    resolve.apply(null, params);\r\n                }\r\n            }\r\n        };\r\n        try {\r\n            fn.apply(ctx || null, params);\r\n        } catch (err) {\r\n            if (pending) {\r\n                pending = false;\r\n                reject(err);\r\n            }\r\n        }\r\n    });\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal base64 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar base64 = exports;\r\n\r\n/**\r\n * Calculates the byte length of a base64 encoded string.\r\n * @param {string} string Base64 encoded string\r\n * @returns {number} Byte length\r\n */\r\nbase64.length = function length(string) {\r\n    var p = string.length;\r\n    if (!p)\r\n        return 0;\r\n    var n = 0;\r\n    while (--p % 4 > 1 && string.charAt(p) === \"=\")\r\n        ++n;\r\n    return Math.ceil(string.length * 3) / 4 - n;\r\n};\r\n\r\n// Base64 encoding table\r\nvar b64 = new Array(64);\r\n\r\n// Base64 decoding table\r\nvar s64 = new Array(123);\r\n\r\n// 65..90, 97..122, 48..57, 43, 47\r\nfor (var i = 0; i < 64;)\r\n    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;\r\n\r\n/**\r\n * Encodes a buffer to a base64 encoded string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} Base64 encoded string\r\n */\r\nbase64.encode = function encode(buffer, start, end) {\r\n    var parts = null,\r\n        chunk = [];\r\n    var i = 0, // output index\r\n        j = 0, // goto index\r\n        t;     // temporary\r\n    while (start < end) {\r\n        var b = buffer[start++];\r\n        switch (j) {\r\n            case 0:\r\n                chunk[i++] = b64[b >> 2];\r\n                t = (b & 3) << 4;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                chunk[i++] = b64[t | b >> 4];\r\n                t = (b & 15) << 2;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                chunk[i++] = b64[t | b >> 6];\r\n                chunk[i++] = b64[b & 63];\r\n                j = 0;\r\n                break;\r\n        }\r\n        if (i > 8191) {\r\n            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (j) {\r\n        chunk[i++] = b64[t];\r\n        chunk[i++] = 61;\r\n        if (j === 1)\r\n            chunk[i++] = 61;\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\nvar invalidEncoding = \"invalid encoding\";\r\n\r\n/**\r\n * Decodes a base64 encoded string to a buffer.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Number of bytes written\r\n * @throws {Error} If encoding is invalid\r\n */\r\nbase64.decode = function decode(string, buffer, offset) {\r\n    var start = offset;\r\n    var j = 0, // goto index\r\n        t;     // temporary\r\n    for (var i = 0; i < string.length;) {\r\n        var c = string.charCodeAt(i++);\r\n        if (c === 61 && j > 1)\r\n            break;\r\n        if ((c = s64[c]) === undefined)\r\n            throw Error(invalidEncoding);\r\n        switch (j) {\r\n            case 0:\r\n                t = c;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                buffer[offset++] = t << 2 | (c & 48) >> 4;\r\n                t = c;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;\r\n                t = c;\r\n                j = 3;\r\n                break;\r\n            case 3:\r\n                buffer[offset++] = (t & 3) << 6 | c;\r\n                j = 0;\r\n                break;\r\n        }\r\n    }\r\n    if (j === 1)\r\n        throw Error(invalidEncoding);\r\n    return offset - start;\r\n};\r\n\r\n/**\r\n * Tests if the specified string appears to be base64 encoded.\r\n * @param {string} string String to test\r\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\r\n */\r\nbase64.test = function test(string) {\r\n    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);\r\n};\r\n","\"use strict\";\r\nmodule.exports = EventEmitter;\r\n\r\n/**\r\n * Constructs a new event emitter instance.\r\n * @classdesc A minimal event emitter.\r\n * @memberof util\r\n * @constructor\r\n */\r\nfunction EventEmitter() {\r\n\r\n    /**\r\n     * Registered listeners.\r\n     * @type {Object.<string,*>}\r\n     * @private\r\n     */\r\n    this._listeners = {};\r\n}\r\n\r\n/**\r\n * Registers an event listener.\r\n * @param {string} evt Event name\r\n * @param {function} fn Listener\r\n * @param {*} [ctx] Listener context\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\r\n    (this._listeners[evt] || (this._listeners[evt] = [])).push({\r\n        fn  : fn,\r\n        ctx : ctx || this\r\n    });\r\n    return this;\r\n};\r\n\r\n/**\r\n * Removes an event listener or any matching listeners if arguments are omitted.\r\n * @param {string} [evt] Event name. Removes all listeners if omitted.\r\n * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.off = function off(evt, fn) {\r\n    if (evt === undefined)\r\n        this._listeners = {};\r\n    else {\r\n        if (fn === undefined)\r\n            this._listeners[evt] = [];\r\n        else {\r\n            var listeners = this._listeners[evt];\r\n            for (var i = 0; i < listeners.length;)\r\n                if (listeners[i].fn === fn)\r\n                    listeners.splice(i, 1);\r\n                else\r\n                    ++i;\r\n        }\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Emits an event by calling its listeners with the specified arguments.\r\n * @param {string} evt Event name\r\n * @param {...*} args Arguments\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.emit = function emit(evt) {\r\n    var listeners = this._listeners[evt];\r\n    if (listeners) {\r\n        var args = [],\r\n            i = 1;\r\n        for (; i < arguments.length;)\r\n            args.push(arguments[i++]);\r\n        for (i = 0; i < listeners.length;)\r\n            listeners[i].fn.apply(listeners[i++].ctx, args);\r\n    }\r\n    return this;\r\n};\r\n","\"use strict\";\r\n\r\nmodule.exports = factory(factory);\r\n\r\n/**\r\n * Reads / writes floats / doubles from / to buffers.\r\n * @name util.float\r\n * @namespace\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using little endian byte order.\r\n * @name util.float.writeFloatLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using big endian byte order.\r\n * @name util.float.writeFloatBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using little endian byte order.\r\n * @name util.float.readFloatLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using big endian byte order.\r\n * @name util.float.readFloatBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using little endian byte order.\r\n * @name util.float.writeDoubleLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using big endian byte order.\r\n * @name util.float.writeDoubleBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using little endian byte order.\r\n * @name util.float.readDoubleLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using big endian byte order.\r\n * @name util.float.readDoubleBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n// Factory function for the purpose of node-based testing in modified global environments\r\nfunction factory(exports) {\r\n\r\n    // float: typed array\r\n    if (typeof Float32Array !== \"undefined\") (function() {\r\n\r\n        var f32 = new Float32Array([ -0 ]),\r\n            f8b = new Uint8Array(f32.buffer),\r\n            le  = f8b[3] === 128;\r\n\r\n        function writeFloat_f32_cpy(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n        }\r\n\r\n        function writeFloat_f32_rev(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[3];\r\n            buf[pos + 1] = f8b[2];\r\n            buf[pos + 2] = f8b[1];\r\n            buf[pos + 3] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r\n\r\n        function readFloat_f32_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        function readFloat_f32_rev(buf, pos) {\r\n            f8b[3] = buf[pos    ];\r\n            f8b[2] = buf[pos + 1];\r\n            f8b[1] = buf[pos + 2];\r\n            f8b[0] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r\n\r\n    // float: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeFloat_ieee754(writeUint, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0)\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\r\n            else if (isNaN(val))\r\n                writeUint(2143289344, buf, pos);\r\n            else if (val > 3.4028234663852886e+38) // +-Infinity\r\n                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\r\n            else if (val < 1.1754943508222875e-38) // denormal\r\n                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r\n            else {\r\n                var exponent = Math.floor(Math.log(val) / Math.LN2),\r\n                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\r\n                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\r\n            }\r\n        }\r\n\r\n        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r\n        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r\n\r\n        function readFloat_ieee754(readUint, buf, pos) {\r\n            var uint = readUint(buf, pos),\r\n                sign = (uint >> 31) * 2 + 1,\r\n                exponent = uint >>> 23 & 255,\r\n                mantissa = uint & 8388607;\r\n            return exponent === 255\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 1.401298464324817e-45 * mantissa\r\n                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r\n        }\r\n\r\n        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r\n        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r\n\r\n    })();\r\n\r\n    // double: typed array\r\n    if (typeof Float64Array !== \"undefined\") (function() {\r\n\r\n        var f64 = new Float64Array([-0]),\r\n            f8b = new Uint8Array(f64.buffer),\r\n            le  = f8b[7] === 128;\r\n\r\n        function writeDouble_f64_cpy(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n            buf[pos + 4] = f8b[4];\r\n            buf[pos + 5] = f8b[5];\r\n            buf[pos + 6] = f8b[6];\r\n            buf[pos + 7] = f8b[7];\r\n        }\r\n\r\n        function writeDouble_f64_rev(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[7];\r\n            buf[pos + 1] = f8b[6];\r\n            buf[pos + 2] = f8b[5];\r\n            buf[pos + 3] = f8b[4];\r\n            buf[pos + 4] = f8b[3];\r\n            buf[pos + 5] = f8b[2];\r\n            buf[pos + 6] = f8b[1];\r\n            buf[pos + 7] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r\n\r\n        function readDouble_f64_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            f8b[4] = buf[pos + 4];\r\n            f8b[5] = buf[pos + 5];\r\n            f8b[6] = buf[pos + 6];\r\n            f8b[7] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        function readDouble_f64_rev(buf, pos) {\r\n            f8b[7] = buf[pos    ];\r\n            f8b[6] = buf[pos + 1];\r\n            f8b[5] = buf[pos + 2];\r\n            f8b[4] = buf[pos + 3];\r\n            f8b[3] = buf[pos + 4];\r\n            f8b[2] = buf[pos + 5];\r\n            f8b[1] = buf[pos + 6];\r\n            f8b[0] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r\n\r\n    // double: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\r\n            } else if (isNaN(val)) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(2146959360, buf, pos + off1);\r\n            } else if (val > 1.7976931348623157e+308) { // +-Infinity\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\r\n            } else {\r\n                var mantissa;\r\n                if (val < 2.2250738585072014e-308) { // denormal\r\n                    mantissa = val / 5e-324;\r\n                    writeUint(mantissa >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\r\n                } else {\r\n                    var exponent = Math.floor(Math.log(val) / Math.LN2);\r\n                    if (exponent === 1024)\r\n                        exponent = 1023;\r\n                    mantissa = val * Math.pow(2, -exponent);\r\n                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r\n                }\r\n            }\r\n        }\r\n\r\n        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r\n        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r\n\r\n        function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r\n            var lo = readUint(buf, pos + off0),\r\n                hi = readUint(buf, pos + off1);\r\n            var sign = (hi >> 31) * 2 + 1,\r\n                exponent = hi >>> 20 & 2047,\r\n                mantissa = 4294967296 * (hi & 1048575) + lo;\r\n            return exponent === 2047\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 5e-324 * mantissa\r\n                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r\n        }\r\n\r\n        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r\n        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r\n\r\n    })();\r\n\r\n    return exports;\r\n}\r\n\r\n// uint helpers\r\n\r\nfunction writeUintLE(val, buf, pos) {\r\n    buf[pos    ] =  val        & 255;\r\n    buf[pos + 1] =  val >>> 8  & 255;\r\n    buf[pos + 2] =  val >>> 16 & 255;\r\n    buf[pos + 3] =  val >>> 24;\r\n}\r\n\r\nfunction writeUintBE(val, buf, pos) {\r\n    buf[pos    ] =  val >>> 24;\r\n    buf[pos + 1] =  val >>> 16 & 255;\r\n    buf[pos + 2] =  val >>> 8  & 255;\r\n    buf[pos + 3] =  val        & 255;\r\n}\r\n\r\nfunction readUintLE(buf, pos) {\r\n    return (buf[pos    ]\r\n          | buf[pos + 1] << 8\r\n          | buf[pos + 2] << 16\r\n          | buf[pos + 3] << 24) >>> 0;\r\n}\r\n\r\nfunction readUintBE(buf, pos) {\r\n    return (buf[pos    ] << 24\r\n          | buf[pos + 1] << 16\r\n          | buf[pos + 2] << 8\r\n          | buf[pos + 3]) >>> 0;\r\n}\r\n","\"use strict\";\r\nmodule.exports = inquire;\r\n\r\n/**\r\n * Requires a module only if available.\r\n * @memberof util\r\n * @param {string} moduleName Module to require\r\n * @returns {?Object} Required module if available and not empty, otherwise `null`\r\n */\r\nfunction inquire(moduleName) {\r\n    try {\r\n        var mod = eval(\"quire\".replace(/^/,\"re\"))(moduleName); // eslint-disable-line no-eval\r\n        if (mod && (mod.length || Object.keys(mod).length))\r\n            return mod;\r\n    } catch (e) {} // eslint-disable-line no-empty\r\n    return null;\r\n}\r\n","\"use strict\";\r\nmodule.exports = pool;\r\n\r\n/**\r\n * An allocator as used by {@link util.pool}.\r\n * @typedef PoolAllocator\r\n * @type {function}\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n */\r\n\r\n/**\r\n * A slicer as used by {@link util.pool}.\r\n * @typedef PoolSlicer\r\n * @type {function}\r\n * @param {number} start Start offset\r\n * @param {number} end End offset\r\n * @returns {Uint8Array} Buffer slice\r\n * @this {Uint8Array}\r\n */\r\n\r\n/**\r\n * A general purpose buffer pool.\r\n * @memberof util\r\n * @function\r\n * @param {PoolAllocator} alloc Allocator\r\n * @param {PoolSlicer} slice Slicer\r\n * @param {number} [size=8192] Slab size\r\n * @returns {PoolAllocator} Pooled allocator\r\n */\r\nfunction pool(alloc, slice, size) {\r\n    var SIZE   = size || 8192;\r\n    var MAX    = SIZE >>> 1;\r\n    var slab   = null;\r\n    var offset = SIZE;\r\n    return function pool_alloc(size) {\r\n        if (size < 1 || size > MAX)\r\n            return alloc(size);\r\n        if (offset + size > SIZE) {\r\n            slab = alloc(SIZE);\r\n            offset = 0;\r\n        }\r\n        var buf = slice.call(slab, offset, offset += size);\r\n        if (offset & 7) // align to 32 bit\r\n            offset = (offset | 7) + 1;\r\n        return buf;\r\n    };\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal UTF8 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar utf8 = exports;\r\n\r\n/**\r\n * Calculates the UTF8 byte length of a string.\r\n * @param {string} string String\r\n * @returns {number} Byte length\r\n */\r\nutf8.length = function utf8_length(string) {\r\n    var len = 0,\r\n        c = 0;\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c = string.charCodeAt(i);\r\n        if (c < 128)\r\n            len += 1;\r\n        else if (c < 2048)\r\n            len += 2;\r\n        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\r\n            ++i;\r\n            len += 4;\r\n        } else\r\n            len += 3;\r\n    }\r\n    return len;\r\n};\r\n\r\n/**\r\n * Reads UTF8 bytes as a string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} String read\r\n */\r\nutf8.read = function utf8_read(buffer, start, end) {\r\n    var len = end - start;\r\n    if (len < 1)\r\n        return \"\";\r\n    var parts = null,\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 || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\n/**\r\n * Writes a string as UTF8 bytes.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Bytes written\r\n */\r\nutf8.write = function utf8_write(string, buffer, offset) {\r\n    var start = offset,\r\n        c1, // character 1\r\n        c2; // character 2\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c1 = string.charCodeAt(i);\r\n        if (c1 < 128) {\r\n            buffer[offset++] = c1;\r\n        } else if (c1 < 2048) {\r\n            buffer[offset++] = c1 >> 6       | 192;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\r\n            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\r\n            ++i;\r\n            buffer[offset++] = c1 >> 18      | 240;\r\n            buffer[offset++] = c1 >> 12 & 63 | 128;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else {\r\n            buffer[offset++] = c1 >> 12      | 224;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        }\r\n    }\r\n    return offset - start;\r\n};\r\n","// minimal library entry point.\r\n\r\n\"use strict\";\r\nmodule.exports = require(\"./src/index-minimal\");\r\n","\"use strict\";\r\nvar protobuf = exports;\r\n\r\n/**\r\n * Build type, one of `\"full\"`, `\"light\"` or `\"minimal\"`.\r\n * @name build\r\n * @type {string}\r\n * @const\r\n */\r\nprotobuf.build = \"minimal\";\r\n\r\n// Serialization\r\nprotobuf.Writer       = require(\"./writer\");\r\nprotobuf.BufferWriter = require(\"./writer_buffer\");\r\nprotobuf.Reader       = require(\"./reader\");\r\nprotobuf.BufferReader = require(\"./reader_buffer\");\r\n\r\n// Utility\r\nprotobuf.util         = require(\"./util/minimal\");\r\nprotobuf.rpc          = require(\"./rpc\");\r\nprotobuf.roots        = require(\"./roots\");\r\nprotobuf.configure    = configure;\r\n\r\n/* istanbul ignore next */\r\n/**\r\n * Reconfigures the library according to the environment.\r\n * @returns {undefined}\r\n */\r\nfunction configure() {\r\n    protobuf.Reader._configure(protobuf.BufferReader);\r\n    protobuf.util._configure();\r\n}\r\n\r\n// Set up buffer utility according to the environment\r\nprotobuf.Writer._configure(protobuf.BufferWriter);\r\nconfigure();\r\n","\"use strict\";\r\nmodule.exports = Reader;\r\n\r\nvar util      = require(\"./util/minimal\");\r\n\r\nvar BufferReader; // cyclic\r\n\r\nvar LongBits  = util.LongBits,\r\n    utf8      = util.utf8;\r\n\r\n/* istanbul ignore next */\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\nvar create_array = typeof Uint8Array !== \"undefined\"\r\n    ? function create_typed_array(buffer) {\r\n        if (buffer instanceof Uint8Array || Array.isArray(buffer))\r\n            return new Reader(buffer);\r\n        throw Error(\"illegal buffer\");\r\n    }\r\n    /* istanbul ignore next */\r\n    : function create_array(buffer) {\r\n        if (Array.isArray(buffer))\r\n            return new Reader(buffer);\r\n        throw Error(\"illegal buffer\");\r\n    };\r\n\r\n/**\r\n * Creates a new reader using the specified buffer.\r\n * @function\r\n * @param {Uint8Array|Buffer} buffer Buffer to read from\r\n * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}\r\n * @throws {Error} If `buffer` is not a valid buffer\r\n */\r\nReader.create = util.Buffer\r\n    ? function create_buffer_setup(buffer) {\r\n        return (Reader.create = function create_buffer(buffer) {\r\n            return util.Buffer.isBuffer(buffer)\r\n                ? new BufferReader(buffer)\r\n                /* istanbul ignore next */\r\n                : create_array(buffer);\r\n        })(buffer);\r\n    }\r\n    /* istanbul ignore next */\r\n    : create_array;\r\n\r\nReader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;\r\n\r\n/**\r\n * Reads a varint as an unsigned 32 bit value.\r\n * @function\r\n * @returns {number} Value read\r\n */\r\nReader.prototype.uint32 = (function read_uint32_setup() {\r\n    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)\r\n    return function read_uint32() {\r\n        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;\r\n        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;\r\n        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;\r\n        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;\r\n        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;\r\n\r\n        /* istanbul ignore if */\r\n        if ((this.pos += 5) > this.len) {\r\n            this.pos = this.len;\r\n            throw indexOutOfRange(this, 10);\r\n        }\r\n        return value;\r\n    };\r\n})();\r\n\r\n/**\r\n * Reads a varint as a signed 32 bit value.\r\n * @returns {number} Value read\r\n */\r\nReader.prototype.int32 = function read_int32() {\r\n    return this.uint32() | 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\nReader.prototype.sint32 = function read_sint32() {\r\n    var value = this.uint32();\r\n    return value >>> 1 ^ -(value & 1) | 0;\r\n};\r\n\r\n/* eslint-disable no-invalid-this */\r\n\r\nfunction readLongVarint() {\r\n    // tends to deopt with local vars for octet etc.\r\n    var bits = new LongBits(0, 0);\r\n    var i = 0;\r\n    if (this.len - this.pos > 4) { // fast route (lo)\r\n        for (; i < 4; ++i) {\r\n            // 1st..4th\r\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\r\n            if (this.buf[this.pos++] < 128)\r\n                return bits;\r\n        }\r\n        // 5th\r\n        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;\r\n        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;\r\n        if (this.buf[this.pos++] < 128)\r\n            return bits;\r\n        i = 0;\r\n    } else {\r\n        for (; i < 3; ++i) {\r\n            /* istanbul ignore if */\r\n            if (this.pos >= this.len)\r\n                throw indexOutOfRange(this);\r\n            // 1st..3th\r\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\r\n            if (this.buf[this.pos++] < 128)\r\n                return bits;\r\n        }\r\n        // 4th\r\n        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;\r\n        return bits;\r\n    }\r\n    if (this.len - this.pos > 4) { // fast route (hi)\r\n        for (; i < 5; ++i) {\r\n            // 6th..10th\r\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\r\n            if (this.buf[this.pos++] < 128)\r\n                return bits;\r\n        }\r\n    } else {\r\n        for (; i < 5; ++i) {\r\n            /* istanbul ignore if */\r\n            if (this.pos >= this.len)\r\n                throw indexOutOfRange(this);\r\n            // 6th..10th\r\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\r\n            if (this.buf[this.pos++] < 128)\r\n                return bits;\r\n        }\r\n    }\r\n    /* istanbul ignore next */\r\n    throw Error(\"invalid varint encoding\");\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} 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} 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} 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\nReader.prototype.bool = function read_bool() {\r\n    return this.uint32() !== 0;\r\n};\r\n\r\nfunction readFixed32_end(buf, end) { // note that this uses `end`, not `pos`\r\n    return (buf[end - 4]\r\n          | buf[end - 3] << 8\r\n          | buf[end - 2] << 16\r\n          | buf[end - 1] << 24) >>> 0;\r\n}\r\n\r\n/**\r\n * Reads fixed 32 bits as an unsigned 32 bit integer.\r\n * @returns {number} Value read\r\n */\r\nReader.prototype.fixed32 = function read_fixed32() {\r\n\r\n    /* istanbul ignore if */\r\n    if (this.pos + 4 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n\r\n    return readFixed32_end(this.buf, this.pos += 4);\r\n};\r\n\r\n/**\r\n * Reads fixed 32 bits as a signed 32 bit integer.\r\n * @returns {number} Value read\r\n */\r\nReader.prototype.sfixed32 = function read_sfixed32() {\r\n\r\n    /* istanbul ignore if */\r\n    if (this.pos + 4 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n\r\n    return readFixed32_end(this.buf, this.pos += 4) | 0;\r\n};\r\n\r\n/* eslint-disable no-invalid-this */\r\n\r\nfunction readFixed64(/* this: Reader */) {\r\n\r\n    /* istanbul ignore if */\r\n    if (this.pos + 8 > this.len)\r\n        throw indexOutOfRange(this, 8);\r\n\r\n    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));\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} 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} Value read\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\nReader.prototype.float = function read_float() {\r\n\r\n    /* istanbul ignore if */\r\n    if (this.pos + 4 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n\r\n    var value = util.float.readFloatLE(this.buf, this.pos);\r\n    this.pos += 4;\r\n    return value;\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\nReader.prototype.double = function read_double() {\r\n\r\n    /* istanbul ignore if */\r\n    if (this.pos + 8 > this.len)\r\n        throw indexOutOfRange(this, 4);\r\n\r\n    var value = util.float.readDoubleLE(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\nReader.prototype.bytes = function read_bytes() {\r\n    var length = this.uint32(),\r\n        start  = this.pos,\r\n        end    = this.pos + length;\r\n\r\n    /* istanbul ignore if */\r\n    if (end > this.len)\r\n        throw indexOutOfRange(this, length);\r\n\r\n    this.pos += length;\r\n    if (Array.isArray(this.buf)) // plain array\r\n        return this.buf.slice(start, end);\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\nReader.prototype.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\nReader.prototype.skip = function skip(length) {\r\n    if (typeof length === \"number\") {\r\n        /* istanbul ignore if */\r\n        if (this.pos + length > this.len)\r\n            throw indexOutOfRange(this, length);\r\n        this.pos += length;\r\n    } else {\r\n        do {\r\n            /* istanbul ignore if */\r\n            if (this.pos >= this.len)\r\n                throw indexOutOfRange(this);\r\n        } while (this.buf[this.pos++] & 128);\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\nReader.prototype.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            while ((wireType = this.uint32() & 7) !== 4) {\r\n                this.skipType(wireType);\r\n            }\r\n            break;\r\n        case 5:\r\n            this.skip(4);\r\n            break;\r\n\r\n        /* istanbul ignore next */\r\n        default:\r\n            throw Error(\"invalid wire type \" + wireType + \" at offset \" + this.pos);\r\n    }\r\n    return this;\r\n};\r\n\r\nReader._configure = function(BufferReader_) {\r\n    BufferReader = BufferReader_;\r\n\r\n    var fn = util.Long ? \"toLong\" : /* istanbul ignore next */ \"toNumber\";\r\n    util.merge(Reader.prototype, {\r\n\r\n        int64: function read_int64() {\r\n            return readLongVarint.call(this)[fn](false);\r\n        },\r\n\r\n        uint64: function read_uint64() {\r\n            return readLongVarint.call(this)[fn](true);\r\n        },\r\n\r\n        sint64: function read_sint64() {\r\n            return readLongVarint.call(this).zzDecode()[fn](false);\r\n        },\r\n\r\n        fixed64: function read_fixed64() {\r\n            return readFixed64.call(this)[fn](true);\r\n        },\r\n\r\n        sfixed64: function read_sfixed64() {\r\n            return readFixed64.call(this)[fn](false);\r\n        }\r\n\r\n    });\r\n};\r\n","\"use strict\";\r\nmodule.exports = BufferReader;\r\n\r\n// extends Reader\r\nvar Reader = require(\"./reader\");\r\n(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;\r\n\r\nvar util = require(\"./util/minimal\");\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    Reader.call(this, buffer);\r\n\r\n    /**\r\n     * Read buffer.\r\n     * @name BufferReader#buf\r\n     * @type {Buffer}\r\n     */\r\n}\r\n\r\n/* istanbul ignore else */\r\nif (util.Buffer)\r\n    BufferReader.prototype._slice = util.Buffer.prototype.slice;\r\n\r\n/**\r\n * @override\r\n */\r\nBufferReader.prototype.string = function read_string_buffer() {\r\n    var len = this.uint32(); // modifies pos\r\n    return this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len));\r\n};\r\n\r\n/**\r\n * Reads a sequence of bytes preceeded by its length as a varint.\r\n * @name BufferReader#bytes\r\n * @function\r\n * @returns {Buffer} Value read\r\n */\r\n","\"use strict\";\r\nmodule.exports = {};\r\n\r\n/**\r\n * Named roots.\r\n * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).\r\n * Can also be used manually to make roots available accross modules.\r\n * @name roots\r\n * @type {Object.<string,Root>}\r\n * @example\r\n * // pbjs -r myroot -o compiled.js ...\r\n *\r\n * // in another module:\r\n * require(\"./compiled.js\");\r\n *\r\n * // in any subsequent module:\r\n * var root = protobuf.roots[\"myroot\"];\r\n */\r\n","\"use strict\";\r\n\r\n/**\r\n * Streaming RPC helpers.\r\n * @namespace\r\n */\r\nvar rpc = exports;\r\n\r\n/**\r\n * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.\r\n * @typedef RPCImpl\r\n * @type {function}\r\n * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called\r\n * @param {Uint8Array} requestData Request data\r\n * @param {RPCImplCallback} callback Callback function\r\n * @returns {undefined}\r\n * @example\r\n * function rpcImpl(method, requestData, callback) {\r\n *     if (protobuf.util.lcFirst(method.name) !== \"myMethod\") // compatible with static code\r\n *         throw Error(\"no such method\");\r\n *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {\r\n *         callback(err, responseData);\r\n *     });\r\n * }\r\n */\r\n\r\n/**\r\n * Node-style callback as used by {@link RPCImpl}.\r\n * @typedef RPCImplCallback\r\n * @type {function}\r\n * @param {Error|null} error Error, if any, otherwise `null`\r\n * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error\r\n * @returns {undefined}\r\n */\r\n\r\nrpc.Service = require(\"./rpc/service\");\r\n","\"use strict\";\r\nmodule.exports = Service;\r\n\r\nvar util = require(\"../util/minimal\");\r\n\r\n// Extends EventEmitter\r\n(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;\r\n\r\n/**\r\n * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.\r\n *\r\n * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.\r\n * @typedef rpc.ServiceMethodCallback\r\n * @template TRes extends Message<TRes>\r\n * @type {function}\r\n * @param {Error|null} error Error, if any\r\n * @param {TRes} [response] Response message\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * A service method part of a {@link rpc.Service} as created by {@link Service.create}.\r\n * @typedef rpc.ServiceMethod\r\n * @template TReq extends Message<TReq>\r\n * @template TRes extends Message<TRes>\r\n * @type {function}\r\n * @param {TReq|Properties<TReq>} request Request message or plain object\r\n * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message\r\n * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`\r\n */\r\n\r\n/**\r\n * Constructs a new RPC service instance.\r\n * @classdesc An RPC service as returned by {@link Service#create}.\r\n * @exports rpc.Service\r\n * @extends util.EventEmitter\r\n * @constructor\r\n * @param {RPCImpl} rpcImpl RPC implementation\r\n * @param {boolean} [requestDelimited=false] Whether requests are length-delimited\r\n * @param {boolean} [responseDelimited=false] Whether responses are length-delimited\r\n */\r\nfunction Service(rpcImpl, requestDelimited, responseDelimited) {\r\n\r\n    if (typeof rpcImpl !== \"function\")\r\n        throw TypeError(\"rpcImpl must be a function\");\r\n\r\n    util.EventEmitter.call(this);\r\n\r\n    /**\r\n     * RPC implementation. Becomes `null` once the service is ended.\r\n     * @type {RPCImpl|null}\r\n     */\r\n    this.rpcImpl = rpcImpl;\r\n\r\n    /**\r\n     * Whether requests are length-delimited.\r\n     * @type {boolean}\r\n     */\r\n    this.requestDelimited = Boolean(requestDelimited);\r\n\r\n    /**\r\n     * Whether responses are length-delimited.\r\n     * @type {boolean}\r\n     */\r\n    this.responseDelimited = Boolean(responseDelimited);\r\n}\r\n\r\n/**\r\n * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.\r\n * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method\r\n * @param {Constructor<TReq>} requestCtor Request constructor\r\n * @param {Constructor<TRes>} responseCtor Response constructor\r\n * @param {TReq|Properties<TReq>} request Request message or plain object\r\n * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback\r\n * @returns {undefined}\r\n * @template TReq extends Message<TReq>\r\n * @template TRes extends Message<TRes>\r\n */\r\nService.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {\r\n\r\n    if (!request)\r\n        throw TypeError(\"request must be specified\");\r\n\r\n    var self = this;\r\n    if (!callback)\r\n        return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);\r\n\r\n    if (!self.rpcImpl) {\r\n        setTimeout(function() { callback(Error(\"already ended\")); }, 0);\r\n        return undefined;\r\n    }\r\n\r\n    try {\r\n        return self.rpcImpl(\r\n            method,\r\n            requestCtor[self.requestDelimited ? \"encodeDelimited\" : \"encode\"](request).finish(),\r\n            function rpcCallback(err, response) {\r\n\r\n                if (err) {\r\n                    self.emit(\"error\", err, method);\r\n                    return callback(err);\r\n                }\r\n\r\n                if (response === null) {\r\n                    self.end(/* endedByRPC */ true);\r\n                    return undefined;\r\n                }\r\n\r\n                if (!(response instanceof responseCtor)) {\r\n                    try {\r\n                        response = responseCtor[self.responseDelimited ? \"decodeDelimited\" : \"decode\"](response);\r\n                    } catch (err) {\r\n                        self.emit(\"error\", err, method);\r\n                        return callback(err);\r\n                    }\r\n                }\r\n\r\n                self.emit(\"data\", response, method);\r\n                return callback(null, response);\r\n            }\r\n        );\r\n    } catch (err) {\r\n        self.emit(\"error\", err, method);\r\n        setTimeout(function() { callback(err); }, 0);\r\n        return undefined;\r\n    }\r\n};\r\n\r\n/**\r\n * Ends this service and emits the `end` event.\r\n * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.\r\n * @returns {rpc.Service} `this`\r\n */\r\nService.prototype.end = function end(endedByRPC) {\r\n    if (this.rpcImpl) {\r\n        if (!endedByRPC) // signal end to rpcImpl\r\n            this.rpcImpl(null, null, null);\r\n        this.rpcImpl = null;\r\n        this.emit(\"end\").off();\r\n    }\r\n    return this;\r\n};\r\n","\"use strict\";\r\nmodule.exports = LongBits;\r\n\r\nvar util = require(\"../util/minimal\");\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 32 bits, unsigned\r\n * @param {number} hi High 32 bits, unsigned\r\n */\r\nfunction LongBits(lo, hi) {\r\n\r\n    // note that the casts below are theoretically unnecessary as of today, but older statically\r\n    // generated converter code might still call the ctor with signed 32bits. kept for compat.\r\n\r\n    /**\r\n     * Low bits.\r\n     * @type {number}\r\n     */\r\n    this.lo = lo >>> 0;\r\n\r\n    /**\r\n     * High bits.\r\n     * @type {number}\r\n     */\r\n    this.hi = hi >>> 0;\r\n}\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 * Zero hash.\r\n * @memberof util.LongBits\r\n * @type {string}\r\n */\r\nvar zeroHash = LongBits.zeroHash = \"\\0\\0\\0\\0\\0\\0\\0\\0\";\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    if (sign)\r\n        value = -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 (util.isString(value)) {\r\n        /* istanbul ignore else */\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\nLongBits.prototype.toNumber = function toNumber(unsigned) {\r\n    if (!unsigned && this.hi >>> 31) {\r\n        var lo = ~this.lo + 1 >>> 0,\r\n            hi = ~this.hi     >>> 0;\r\n        if (!lo)\r\n            hi = hi + 1 >>> 0;\r\n        return -(lo + 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\nLongBits.prototype.toLong = function toLong(unsigned) {\r\n    return util.Long\r\n        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))\r\n        /* istanbul ignore next */\r\n        : { low: this.lo | 0, high: this.hi | 0, 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    if (hash === zeroHash)\r\n        return zero;\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\nLongBits.prototype.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      ,\r\n        this.hi        & 255,\r\n        this.hi >>> 8  & 255,\r\n        this.hi >>> 16 & 255,\r\n        this.hi >>> 24\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\nLongBits.prototype.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\nLongBits.prototype.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\nLongBits.prototype.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    return part2 === 0\r\n         ? part1 === 0\r\n           ? part0 < 16384\r\n             ? part0 < 128 ? 1 : 2\r\n             : part0 < 2097152 ? 3 : 4\r\n           : part1 < 16384\r\n             ? part1 < 128 ? 5 : 6\r\n             : part1 < 2097152 ? 7 : 8\r\n         : part2 < 128 ? 9 : 10;\r\n};\r\n","\"use strict\";\r\nvar util = exports;\r\n\r\n// used to return a Promise where callback is omitted\r\nutil.asPromise = require(\"@protobufjs/aspromise\");\r\n\r\n// converts to / from base64 encoded strings\r\nutil.base64 = require(\"@protobufjs/base64\");\r\n\r\n// base class of rpc.Service\r\nutil.EventEmitter = require(\"@protobufjs/eventemitter\");\r\n\r\n// float handling accross browsers\r\nutil.float = require(\"@protobufjs/float\");\r\n\r\n// requires modules optionally and hides the call from bundlers\r\nutil.inquire = require(\"@protobufjs/inquire\");\r\n\r\n// converts to / from utf8 encoded strings\r\nutil.utf8 = require(\"@protobufjs/utf8\");\r\n\r\n// provides a node-like buffer pool in the browser\r\nutil.pool = require(\"@protobufjs/pool\");\r\n\r\n// utility to work with the low and high bits of a 64 bit value\r\nutil.LongBits = require(\"./longbits\");\r\n\r\n// global object reference\r\nutil.global = typeof window !== \"undefined\" && window\r\n           || typeof global !== \"undefined\" && global\r\n           || typeof self   !== \"undefined\" && self\r\n           || this; // eslint-disable-line no-invalid-this\r\n\r\n/**\r\n * An immuable empty array.\r\n * @memberof util\r\n * @type {Array.<*>}\r\n * @const\r\n */\r\nutil.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes\r\n\r\n/**\r\n * An immutable empty object.\r\n * @type {Object}\r\n * @const\r\n */\r\nutil.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes\r\n\r\n/**\r\n * Whether running within node or not.\r\n * @memberof util\r\n * @type {boolean}\r\n * @const\r\n */\r\nutil.isNode = Boolean(util.global.process && util.global.process.versions && util.global.process.versions.node);\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 || /* istanbul ignore next */ 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 value && typeof value === \"object\";\r\n};\r\n\r\n/**\r\n * Checks if a property on a message is considered to be present.\r\n * This is an alias of {@link util.isSet}.\r\n * @function\r\n * @param {Object} obj Plain object or message instance\r\n * @param {string} prop Property name\r\n * @returns {boolean} `true` if considered to be present, otherwise `false`\r\n */\r\nutil.isset =\r\n\r\n/**\r\n * Checks if a property on a message is considered to be present.\r\n * @param {Object} obj Plain object or message instance\r\n * @param {string} prop Property name\r\n * @returns {boolean} `true` if considered to be present, otherwise `false`\r\n */\r\nutil.isSet = function isSet(obj, prop) {\r\n    var value = obj[prop];\r\n    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins\r\n        return typeof value !== \"object\" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;\r\n    return false;\r\n};\r\n\r\n/**\r\n * Any compatible Buffer instance.\r\n * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.\r\n * @interface Buffer\r\n * @extends Uint8Array\r\n */\r\n\r\n/**\r\n * Node's Buffer class if available.\r\n * @type {Constructor<Buffer>}\r\n */\r\nutil.Buffer = (function() {\r\n    try {\r\n        var Buffer = util.inquire(\"buffer\").Buffer;\r\n        // refuse to use non-node buffers if not explicitly assigned (perf reasons):\r\n        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;\r\n    } catch (e) {\r\n        /* istanbul ignore next */\r\n        return null;\r\n    }\r\n})();\r\n\r\n// Internal alias of or polyfull for Buffer.from.\r\nutil._Buffer_from = null;\r\n\r\n// Internal alias of or polyfill for Buffer.allocUnsafe.\r\nutil._Buffer_allocUnsafe = null;\r\n\r\n/**\r\n * Creates a new buffer of whatever type supported by the environment.\r\n * @param {number|number[]} [sizeOrArray=0] Buffer size or number array\r\n * @returns {Uint8Array|Buffer} Buffer\r\n */\r\nutil.newBuffer = function newBuffer(sizeOrArray) {\r\n    /* istanbul ignore next */\r\n    return typeof sizeOrArray === \"number\"\r\n        ? util.Buffer\r\n            ? util._Buffer_allocUnsafe(sizeOrArray)\r\n            : new util.Array(sizeOrArray)\r\n        : util.Buffer\r\n            ? util._Buffer_from(sizeOrArray)\r\n            : typeof Uint8Array === \"undefined\"\r\n                ? sizeOrArray\r\n                : new Uint8Array(sizeOrArray);\r\n};\r\n\r\n/**\r\n * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.\r\n * @type {Constructor<Uint8Array>}\r\n */\r\nutil.Array = typeof Uint8Array !== \"undefined\" ? Uint8Array /* istanbul ignore next */ : Array;\r\n\r\n/**\r\n * Any compatible Long instance.\r\n * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.\r\n * @interface Long\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 * Long.js's Long class if available.\r\n * @type {Constructor<Long>}\r\n */\r\nutil.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long\r\n         || /* istanbul ignore next */ util.global.Long\r\n         || util.inquire(\"long\");\r\n\r\n/**\r\n * Regular expression used to verify 2 bit (`bool`) map keys.\r\n * @type {RegExp}\r\n * @const\r\n */\r\nutil.key2Re = /^true|false|0|1$/;\r\n\r\n/**\r\n * Regular expression used to verify 32 bit (`int32` etc.) map keys.\r\n * @type {RegExp}\r\n * @const\r\n */\r\nutil.key32Re = /^-?(?:0|[1-9][0-9]*)$/;\r\n\r\n/**\r\n * Regular expression used to verify 64 bit (`int64` etc.) map keys.\r\n * @type {RegExp}\r\n * @const\r\n */\r\nutil.key64Re = /^(?:[\\\\x00-\\\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;\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        ? util.LongBits.from(value).toHash()\r\n        : util.LongBits.zeroHash;\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 = util.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 * Merges the properties of the source object into the destination object.\r\n * @memberof util\r\n * @param {Object.<string,*>} dst Destination object\r\n * @param {Object.<string,*>} src Source object\r\n * @param {boolean} [ifNotSet=false] Merges only if the key is not already set\r\n * @returns {Object.<string,*>} Destination object\r\n */\r\nfunction merge(dst, src, ifNotSet) { // used by converters\r\n    for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)\r\n        if (dst[keys[i]] === undefined || !ifNotSet)\r\n            dst[keys[i]] = src[keys[i]];\r\n    return dst;\r\n}\r\n\r\nutil.merge = merge;\r\n\r\n/**\r\n * Converts the first character of a string to lower case.\r\n * @param {string} str String to convert\r\n * @returns {string} Converted string\r\n */\r\nutil.lcFirst = function lcFirst(str) {\r\n    return str.charAt(0).toLowerCase() + str.substring(1);\r\n};\r\n\r\n/**\r\n * Creates a custom error constructor.\r\n * @memberof util\r\n * @param {string} name Error name\r\n * @returns {Constructor<Error>} Custom error constructor\r\n */\r\nfunction newError(name) {\r\n\r\n    function CustomError(message, properties) {\r\n\r\n        if (!(this instanceof CustomError))\r\n            return new CustomError(message, properties);\r\n\r\n        // Error.call(this, message);\r\n        // ^ just returns a new error instance because the ctor can be called as a function\r\n\r\n        Object.defineProperty(this, \"message\", { get: function() { return message; } });\r\n\r\n        /* istanbul ignore next */\r\n        if (Error.captureStackTrace) // node\r\n            Error.captureStackTrace(this, CustomError);\r\n        else\r\n            Object.defineProperty(this, \"stack\", { value: (new Error()).stack || \"\" });\r\n\r\n        if (properties)\r\n            merge(this, properties);\r\n    }\r\n\r\n    (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;\r\n\r\n    Object.defineProperty(CustomError.prototype, \"name\", { get: function() { return name; } });\r\n\r\n    CustomError.prototype.toString = function toString() {\r\n        return this.name + \": \" + this.message;\r\n    };\r\n\r\n    return CustomError;\r\n}\r\n\r\nutil.newError = newError;\r\n\r\n/**\r\n * Constructs a new protocol error.\r\n * @classdesc Error subclass indicating a protocol specifc error.\r\n * @memberof util\r\n * @extends Error\r\n * @template T extends Message<T>\r\n * @constructor\r\n * @param {string} message Error message\r\n * @param {Object.<string,*>} [properties] Additional properties\r\n * @example\r\n * try {\r\n *     MyMessage.decode(someBuffer); // throws if required fields are missing\r\n * } catch (e) {\r\n *     if (e instanceof ProtocolError && e.instance)\r\n *         console.log(\"decoded so far: \" + JSON.stringify(e.instance));\r\n * }\r\n */\r\nutil.ProtocolError = newError(\"ProtocolError\");\r\n\r\n/**\r\n * So far decoded message instance.\r\n * @name util.ProtocolError#instance\r\n * @type {Message<T>}\r\n */\r\n\r\n/**\r\n * A OneOf getter as returned by {@link util.oneOfGetter}.\r\n * @typedef OneOfGetter\r\n * @type {function}\r\n * @returns {string|undefined} Set field name, if any\r\n */\r\n\r\n/**\r\n * Builds a getter for a oneof's present field name.\r\n * @param {string[]} fieldNames Field names\r\n * @returns {OneOfGetter} Unbound getter\r\n */\r\nutil.oneOfGetter = function getOneOf(fieldNames) {\r\n    var fieldMap = {};\r\n    for (var i = 0; i < fieldNames.length; ++i)\r\n        fieldMap[fieldNames[i]] = 1;\r\n\r\n    /**\r\n     * @returns {string|undefined} Set field name, if any\r\n     * @this Object\r\n     * @ignore\r\n     */\r\n    return function() { // eslint-disable-line consistent-return\r\n        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)\r\n            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)\r\n                return keys[i];\r\n    };\r\n};\r\n\r\n/**\r\n * A OneOf setter as returned by {@link util.oneOfSetter}.\r\n * @typedef OneOfSetter\r\n * @type {function}\r\n * @param {string|undefined} value Field name\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Builds a setter for a oneof's present field name.\r\n * @param {string[]} fieldNames Field names\r\n * @returns {OneOfSetter} Unbound setter\r\n */\r\nutil.oneOfSetter = function setOneOf(fieldNames) {\r\n\r\n    /**\r\n     * @param {string} name Field name\r\n     * @returns {undefined}\r\n     * @this Object\r\n     * @ignore\r\n     */\r\n    return function(name) {\r\n        for (var i = 0; i < fieldNames.length; ++i)\r\n            if (fieldNames[i] !== name)\r\n                delete this[fieldNames[i]];\r\n    };\r\n};\r\n\r\n/**\r\n * Default conversion options used for {@link Message#toJSON} implementations.\r\n *\r\n * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:\r\n *\r\n * - Longs become strings\r\n * - Enums become string keys\r\n * - Bytes become base64 encoded strings\r\n * - (Sub-)Messages become plain objects\r\n * - Maps become plain objects with all string keys\r\n * - Repeated fields become arrays\r\n * - NaN and Infinity for float and double fields become strings\r\n *\r\n * @type {IConversionOptions}\r\n * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json\r\n */\r\nutil.toJSONOptions = {\r\n    longs: String,\r\n    enums: String,\r\n    bytes: String,\r\n    json: true\r\n};\r\n\r\n// Sets up buffer utility according to the environment (called in index-minimal)\r\nutil._configure = function() {\r\n    var Buffer = util.Buffer;\r\n    /* istanbul ignore if */\r\n    if (!Buffer) {\r\n        util._Buffer_from = util._Buffer_allocUnsafe = null;\r\n        return;\r\n    }\r\n    // because node 4.x buffers are incompatible & immutable\r\n    // see: https://github.com/dcodeIO/protobuf.js/pull/665\r\n    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||\r\n        /* istanbul ignore next */\r\n        function Buffer_from(value, encoding) {\r\n            return new Buffer(value, encoding);\r\n        };\r\n    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||\r\n        /* istanbul ignore next */\r\n        function Buffer_allocUnsafe(size) {\r\n            return new Buffer(size);\r\n        };\r\n};\r\n","\"use strict\";\r\nmodule.exports = Writer;\r\n\r\nvar util      = require(\"./util/minimal\");\r\n\r\nvar BufferWriter; // cyclic\r\n\r\nvar LongBits  = util.LongBits,\r\n    base64    = util.base64,\r\n    utf8      = util.utf8;\r\n\r\n/**\r\n * Constructs a new writer operation instance.\r\n * @classdesc Scheduled writer operation.\r\n * @constructor\r\n * @param {function(*, Uint8Array, number)} fn Function to call\r\n * @param {number} len Value byte length\r\n * @param {*} val Value to write\r\n * @ignore\r\n */\r\nfunction Op(fn, len, val) {\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 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|undefined}\r\n     */\r\n    this.next = undefined;\r\n\r\n    /**\r\n     * Value to write.\r\n     * @type {*}\r\n     */\r\n    this.val = val; // type varies\r\n}\r\n\r\n/* istanbul ignore next */\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 * @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|null}\r\n     */\r\n    this.next = writer.states;\r\n}\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|null}\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 operations with already prepared values.\r\n}\r\n\r\n/**\r\n * Creates a new writer.\r\n * @function\r\n * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}\r\n */\r\nWriter.create = util.Buffer\r\n    ? function create_buffer_setup() {\r\n        return (Writer.create = function create_buffer() {\r\n            return new BufferWriter();\r\n        })();\r\n    }\r\n    /* istanbul ignore next */\r\n    : function create_array() {\r\n        return new 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 util.Array(size);\r\n};\r\n\r\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\r\n/* istanbul ignore else */\r\nif (util.Array !== Array)\r\n    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);\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 * @private\r\n */\r\nWriter.prototype._push = function push(fn, len, val) {\r\n    this.tail = this.tail.next = new Op(fn, len, val);\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 * Constructs a new varint writer operation instance.\r\n * @classdesc Scheduled varint writer operation.\r\n * @extends Op\r\n * @constructor\r\n * @param {number} len Value byte length\r\n * @param {number} val Value to write\r\n * @ignore\r\n */\r\nfunction VarintOp(len, val) {\r\n    this.len = len;\r\n    this.next = undefined;\r\n    this.val = val;\r\n}\r\n\r\nVarintOp.prototype = Object.create(Op.prototype);\r\nVarintOp.prototype.fn = writeVarint32;\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\nWriter.prototype.uint32 = function write_uint32(value) {\r\n    // here, the call to this.push has been inlined and a varint specific Op subclass is used.\r\n    // uint32 is by far the most frequently used operation and benefits significantly from this.\r\n    this.len += (this.tail = this.tail.next = new VarintOp(\r\n        (value = value >>> 0)\r\n                < 128       ? 1\r\n        : value < 16384     ? 2\r\n        : value < 2097152   ? 3\r\n        : value < 268435456 ? 4\r\n        :                     5,\r\n    value)).len;\r\n    return this;\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\nWriter.prototype.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\nWriter.prototype.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\nWriter.prototype.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\nWriter.prototype.int64 = Writer.prototype.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\nWriter.prototype.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\nWriter.prototype.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 + 1] =  val >>> 8   & 255;\r\n    buf[pos + 2] =  val >>> 16  & 255;\r\n    buf[pos + 3] =  val >>> 24;\r\n}\r\n\r\n/**\r\n * Writes an unsigned 32 bit value as fixed 32 bits.\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriter.prototype.fixed32 = function write_fixed32(value) {\r\n    return this._push(writeFixed32, 4, value >>> 0);\r\n};\r\n\r\n/**\r\n * Writes a signed 32 bit value as fixed 32 bits.\r\n * @function\r\n * @param {number} value Value to write\r\n * @returns {Writer} `this`\r\n */\r\nWriter.prototype.sfixed32 = Writer.prototype.fixed32;\r\n\r\n/**\r\n * Writes an unsigned 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\nWriter.prototype.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 signed 64 bit value as fixed 64 bits.\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\nWriter.prototype.sfixed64 = Writer.prototype.fixed64;\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\nWriter.prototype.float = function write_float(value) {\r\n    return this._push(util.float.writeFloatLE, 4, value);\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\nWriter.prototype.double = function write_double(value) {\r\n    return this._push(util.float.writeDoubleLE, 8, value);\r\n};\r\n\r\nvar writeBytes = util.Array.prototype.set\r\n    ? function writeBytes_set(val, buf, pos) {\r\n        buf.set(val, pos); // also works for plain array values\r\n    }\r\n    /* istanbul ignore next */\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\nWriter.prototype.bytes = function write_bytes(value) {\r\n    var len = value.length >>> 0;\r\n    if (!len)\r\n        return this._push(writeByte, 1, 0);\r\n    if (util.isString(value)) {\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 this.uint32(len)._push(writeBytes, len, value);\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\nWriter.prototype.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|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.\r\n * @returns {Writer} `this`\r\n */\r\nWriter.prototype.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\nWriter.prototype.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 * @returns {Writer} `this`\r\n */\r\nWriter.prototype.ldelim = function ldelim() {\r\n    var head = this.head,\r\n        tail = this.tail,\r\n        len  = this.len;\r\n    this.reset().uint32(len);\r\n    if (len) {\r\n        this.tail.next = head.next; // skip noop\r\n        this.tail = tail;\r\n        this.len += len;\r\n    }\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\nWriter.prototype.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;\r\n    return buf;\r\n};\r\n\r\nWriter._configure = function(BufferWriter_) {\r\n    BufferWriter = BufferWriter_;\r\n};\r\n","\"use strict\";\r\nmodule.exports = BufferWriter;\r\n\r\n// extends Writer\r\nvar Writer = require(\"./writer\");\r\n(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;\r\n\r\nvar util = require(\"./util/minimal\");\r\n\r\nvar Buffer = util.Buffer;\r\n\r\n/**\r\n * Constructs a new buffer writer instance.\r\n * @classdesc Wire format writer using node buffers.\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 {Buffer} Buffer\r\n */\r\nBufferWriter.alloc = function alloc_buffer(size) {\r\n    return (BufferWriter.alloc = util._Buffer_allocUnsafe)(size);\r\n};\r\n\r\nvar writeBytesBuffer = Buffer && Buffer.prototype instanceof Uint8Array && Buffer.prototype.set.name === \"set\"\r\n    ? function writeBytesBuffer_set(val, buf, pos) {\r\n        buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)\r\n                           // also works for plain array values\r\n    }\r\n    /* istanbul ignore next */\r\n    : function writeBytesBuffer_copy(val, buf, pos) {\r\n        if (val.copy) // Buffer values\r\n            val.copy(buf, pos, 0, val.length);\r\n        else for (var i = 0; i < val.length;) // plain array values\r\n            buf[pos++] = val[i++];\r\n    };\r\n\r\n/**\r\n * @override\r\n */\r\nBufferWriter.prototype.bytes = function write_bytes_buffer(value) {\r\n    if (util.isString(value))\r\n        value = util._Buffer_from(value, \"base64\");\r\n    var len = value.length >>> 0;\r\n    this.uint32(len);\r\n    if (len)\r\n        this._push(writeBytesBuffer, len, value);\r\n    return this;\r\n};\r\n\r\nfunction writeStringBuffer(val, buf, pos) {\r\n    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)\r\n        util.utf8.write(val, buf, pos);\r\n    else\r\n        buf.utf8Write(val, pos);\r\n}\r\n\r\n/**\r\n * @override\r\n */\r\nBufferWriter.prototype.string = function write_string_buffer(value) {\r\n    var len = Buffer.byteLength(value);\r\n    this.uint32(len);\r\n    if (len)\r\n        this._push(writeStringBuffer, len, value);\r\n    return this;\r\n};\r\n\r\n\r\n/**\r\n * Finishes the write operation.\r\n * @name BufferWriter#finish\r\n * @function\r\n * @returns {Buffer} Finished buffer\r\n */\r\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var setImmediate;\n\n    function addFromSetImmediateArguments(args) {\n        tasksByHandle[nextHandle] = partiallyApplied.apply(undefined, args);\n        return nextHandle++;\n    }\n\n    // This function accepts the same arguments as setImmediate, but\n    // returns a function that requires no arguments.\n    function partiallyApplied(handler) {\n        var args = [].slice.call(arguments, 1);\n        return function() {\n            if (typeof handler === \"function\") {\n                handler.apply(undefined, args);\n            } else {\n                (new Function(\"\" + handler))();\n            }\n        };\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(partiallyApplied(runIfPresent, handle), 0);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    task();\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function installNextTickImplementation() {\n        setImmediate = function() {\n            var handle = addFromSetImmediateArguments(arguments);\n            process.nextTick(partiallyApplied(runIfPresent, handle));\n            return handle;\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        setImmediate = function() {\n            var handle = addFromSetImmediateArguments(arguments);\n            global.postMessage(messagePrefix + handle, \"*\");\n            return handle;\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        setImmediate = function() {\n            var handle = addFromSetImmediateArguments(arguments);\n            channel.port2.postMessage(handle);\n            return handle;\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        setImmediate = function() {\n            var handle = addFromSetImmediateArguments(arguments);\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n            return handle;\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        setImmediate = function() {\n            var handle = addFromSetImmediateArguments(arguments);\n            setTimeout(partiallyApplied(runIfPresent, handle), 0);\n            return handle;\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6â€“8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(new Function(\"return this\")()));\n","/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var m=this;function q(c,d){var a=c.split(\".\"),b=m;!(a[0]in b)&&b.execScript&&b.execScript(\"var \"+a[0]);for(var e;a.length&&(e=a.shift());)!a.length&&void 0!==d?b[e]=d:b=b[e]?b[e]:b[e]={}};var s=\"undefined\"!==typeof Uint8Array&&\"undefined\"!==typeof Uint16Array&&\"undefined\"!==typeof Uint32Array&&\"undefined\"!==typeof DataView;function t(c){var d=c.length,a=0,b=Number.POSITIVE_INFINITY,e,f,g,h,k,l,p,n,r,K;for(n=0;n<d;++n)c[n]>a&&(a=c[n]),c[n]<b&&(b=c[n]);e=1<<a;f=new (s?Uint32Array:Array)(e);g=1;h=0;for(k=2;g<=a;){for(n=0;n<d;++n)if(c[n]===g){l=0;p=h;for(r=0;r<g;++r)l=l<<1|p&1,p>>=1;K=g<<16|n;for(r=l;r<e;r+=k)f[r]=K;++h}++g;h<<=1;k<<=1}return[f,a,b]};function u(c,d){this.g=[];this.h=32768;this.d=this.f=this.a=this.l=0;this.input=s?new Uint8Array(c):c;this.m=!1;this.i=v;this.s=!1;if(d||!(d={}))d.index&&(this.a=d.index),d.bufferSize&&(this.h=d.bufferSize),d.bufferType&&(this.i=d.bufferType),d.resize&&(this.s=d.resize);switch(this.i){case w:this.b=32768;this.c=new (s?Uint8Array:Array)(32768+this.h+258);break;case v:this.b=0;this.c=new (s?Uint8Array:Array)(this.h);this.e=this.A;this.n=this.w;this.j=this.z;break;default:throw Error(\"invalid inflate mode\");\n}}var w=0,v=1,x={u:w,t:v};\nu.prototype.k=function(){for(;!this.m;){var c=y(this,3);c&1&&(this.m=!0);c>>>=1;switch(c){case 0:var d=this.input,a=this.a,b=this.c,e=this.b,f=d.length,g=void 0,h=void 0,k=b.length,l=void 0;this.d=this.f=0;if(a+1>=f)throw Error(\"invalid uncompressed block header: LEN\");g=d[a++]|d[a++]<<8;if(a+1>=f)throw Error(\"invalid uncompressed block header: NLEN\");h=d[a++]|d[a++]<<8;if(g===~h)throw Error(\"invalid uncompressed block header: length verify\");if(a+g>d.length)throw Error(\"input buffer is broken\");switch(this.i){case w:for(;e+\ng>b.length;){l=k-e;g-=l;if(s)b.set(d.subarray(a,a+l),e),e+=l,a+=l;else for(;l--;)b[e++]=d[a++];this.b=e;b=this.e();e=this.b}break;case v:for(;e+g>b.length;)b=this.e({p:2});break;default:throw Error(\"invalid inflate mode\");}if(s)b.set(d.subarray(a,a+g),e),e+=g,a+=g;else for(;g--;)b[e++]=d[a++];this.a=a;this.b=e;this.c=b;break;case 1:this.j(z,A);break;case 2:B(this);break;default:throw Error(\"unknown BTYPE: \"+c);}}return this.n()};\nvar C=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],D=s?new Uint16Array(C):C,E=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,258,258],F=s?new Uint16Array(E):E,G=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0],H=s?new Uint8Array(G):G,I=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],J=s?new Uint16Array(I):I,L=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,\n13],M=s?new Uint8Array(L):L,N=new (s?Uint8Array:Array)(288),O,P;O=0;for(P=N.length;O<P;++O)N[O]=143>=O?8:255>=O?9:279>=O?7:8;var z=t(N),Q=new (s?Uint8Array:Array)(30),R,S;R=0;for(S=Q.length;R<S;++R)Q[R]=5;var A=t(Q);function y(c,d){for(var a=c.f,b=c.d,e=c.input,f=c.a,g=e.length,h;b<d;){if(f>=g)throw Error(\"input buffer is broken\");a|=e[f++]<<b;b+=8}h=a&(1<<d)-1;c.f=a>>>d;c.d=b-d;c.a=f;return h}\nfunction T(c,d){for(var a=c.f,b=c.d,e=c.input,f=c.a,g=e.length,h=d[0],k=d[1],l,p;b<k&&!(f>=g);)a|=e[f++]<<b,b+=8;l=h[a&(1<<k)-1];p=l>>>16;c.f=a>>p;c.d=b-p;c.a=f;return l&65535}\nfunction B(c){function d(a,c,b){var d,e=this.q,f,g;for(g=0;g<a;)switch(d=T(this,c),d){case 16:for(f=3+y(this,2);f--;)b[g++]=e;break;case 17:for(f=3+y(this,3);f--;)b[g++]=0;e=0;break;case 18:for(f=11+y(this,7);f--;)b[g++]=0;e=0;break;default:e=b[g++]=d}this.q=e;return b}var a=y(c,5)+257,b=y(c,5)+1,e=y(c,4)+4,f=new (s?Uint8Array:Array)(D.length),g,h,k,l;for(l=0;l<e;++l)f[D[l]]=y(c,3);if(!s){l=e;for(e=f.length;l<e;++l)f[D[l]]=0}g=t(f);h=new (s?Uint8Array:Array)(a);k=new (s?Uint8Array:Array)(b);c.q=0;\nc.j(t(d.call(c,a,g,h)),t(d.call(c,b,g,k)))}u.prototype.j=function(c,d){var a=this.c,b=this.b;this.o=c;for(var e=a.length-258,f,g,h,k;256!==(f=T(this,c));)if(256>f)b>=e&&(this.b=b,a=this.e(),b=this.b),a[b++]=f;else{g=f-257;k=F[g];0<H[g]&&(k+=y(this,H[g]));f=T(this,d);h=J[f];0<M[f]&&(h+=y(this,M[f]));b>=e&&(this.b=b,a=this.e(),b=this.b);for(;k--;)a[b]=a[b++-h]}for(;8<=this.d;)this.d-=8,this.a--;this.b=b};\nu.prototype.z=function(c,d){var a=this.c,b=this.b;this.o=c;for(var e=a.length,f,g,h,k;256!==(f=T(this,c));)if(256>f)b>=e&&(a=this.e(),e=a.length),a[b++]=f;else{g=f-257;k=F[g];0<H[g]&&(k+=y(this,H[g]));f=T(this,d);h=J[f];0<M[f]&&(h+=y(this,M[f]));b+k>e&&(a=this.e(),e=a.length);for(;k--;)a[b]=a[b++-h]}for(;8<=this.d;)this.d-=8,this.a--;this.b=b};\nu.prototype.e=function(){var c=new (s?Uint8Array:Array)(this.b-32768),d=this.b-32768,a,b,e=this.c;if(s)c.set(e.subarray(32768,c.length));else{a=0;for(b=c.length;a<b;++a)c[a]=e[a+32768]}this.g.push(c);this.l+=c.length;if(s)e.set(e.subarray(d,d+32768));else for(a=0;32768>a;++a)e[a]=e[d+a];this.b=32768;return e};\nu.prototype.A=function(c){var d,a=this.input.length/this.a+1|0,b,e,f,g=this.input,h=this.c;c&&(\"number\"===typeof c.p&&(a=c.p),\"number\"===typeof c.v&&(a+=c.v));2>a?(b=(g.length-this.a)/this.o[2],f=258*(b/2)|0,e=f<h.length?h.length+f:h.length<<1):e=h.length*a;s?(d=new Uint8Array(e),d.set(h)):d=h;return this.c=d};\nu.prototype.n=function(){var c=0,d=this.c,a=this.g,b,e=new (s?Uint8Array:Array)(this.l+(this.b-32768)),f,g,h,k;if(0===a.length)return s?this.c.subarray(32768,this.b):this.c.slice(32768,this.b);f=0;for(g=a.length;f<g;++f){b=a[f];h=0;for(k=b.length;h<k;++h)e[c++]=b[h]}f=32768;for(g=this.b;f<g;++f)e[c++]=d[f];this.g=[];return this.buffer=e};\nu.prototype.w=function(){var c,d=this.b;s?this.s?(c=new Uint8Array(d),c.set(this.c.subarray(0,d))):c=this.c.subarray(0,d):(this.c.length>d&&(this.c.length=d),c=this.c);return this.buffer=c};function U(c,d){var a,b;this.input=c;this.a=0;if(d||!(d={}))d.index&&(this.a=d.index),d.verify&&(this.B=d.verify);a=c[this.a++];b=c[this.a++];switch(a&15){case V:this.method=V;break;default:throw Error(\"unsupported compression method\");}if(0!==((a<<8)+b)%31)throw Error(\"invalid fcheck flag:\"+((a<<8)+b)%31);if(b&32)throw Error(\"fdict flag is not supported\");this.r=new u(c,{index:this.a,bufferSize:d.bufferSize,bufferType:d.bufferType,resize:d.resize})}\nU.prototype.k=function(){var c=this.input,d,a;d=this.r.k();this.a=this.r.a;if(this.B){a=(c[this.a++]<<24|c[this.a++]<<16|c[this.a++]<<8|c[this.a++])>>>0;var b=d;if(\"string\"===typeof b){var e=b.split(\"\"),f,g;f=0;for(g=e.length;f<g;f++)e[f]=(e[f].charCodeAt(0)&255)>>>0;b=e}for(var h=1,k=0,l=b.length,p,n=0;0<l;){p=1024<l?1024:l;l-=p;do h+=b[n++],k+=h;while(--p);h%=65521;k%=65521}if(a!==(k<<16|h)>>>0)throw Error(\"invalid adler-32 checksum\");}return d};var V=8;q(\"Zlib.Inflate\",U);q(\"Zlib.Inflate.prototype.decompress\",U.prototype.k);var W={ADAPTIVE:x.t,BLOCK:x.u},X,Y,Z,$;if(Object.keys)X=Object.keys(W);else for(Y in X=[],Z=0,W)X[Z++]=Y;Z=0;for($=X.length;Z<$;++Z)Y=X[Z],q(\"Zlib.Inflate.BufferType.\"+Y,W[Y]);}).call(this); //@ sourceMappingURL=inflate.min.js.map\n"]}