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