How to use varint - 10 common examples

function rleDecode(buf, offset, datalen, bitWidth) {
  var header = varint.decode(buf, offset);
  var count = header >>> 1;

  datalen -= varint.decode.bytes;
  if (header & 1) { // Bit packed
    console.log('read ' + (count * 8) + ' bit packed values');
  } else {          // RLE
    console.log('read ' + count + ' RLE values');
    console.log('remain ' + datalen + ' bytes');
  }
}

function createLookupKey (sequence, key, valueType) {
  const keySize = key.size
  const internalKeySize = keySize + 8
  const internalKeySizeBuf = Buffer.from(varint.encode(internalKeySize))
  const buf = Buffer.concat([
    internalKeySizeBuf,
    key.buffer,
    sequence.toFixedSizeBuffer(),
    Buffer.from(varint.encode(valueType.value))
  ])
  return new Slice(buf)
}

function createLookupKey (sequence, key, valueType) {
  const keySize = key.size
  const internalKeySize = keySize + 8
  const internalKeySizeBuf = Buffer.from(varint.encode(internalKeySize))
  const buf = Buffer.concat([
    internalKeySizeBuf,
    key.buffer,
    sequence.toFixedSizeBuffer(),
    Buffer.from(varint.encode(valueType.value))
  ])
  return new Slice(buf)
}

serialize() {
        let bufferHex = ContentData.serializeNumber(this.version);
        bufferHex += ContentData.serializeNumber(this.type);

        bufferHex += Buffer.from(varint.encode(this.txIds.length)).toString('hex');

        this.txIds.forEach(function (txId) {
            let buff = Buffer.from(txId, 'hex');
            if (buff.length !== 32) {
                throw 'Invalid txId: ' + txId;
            }

            bufferHex += buff.toString('hex');
        });

        return Buffer.from(bufferHex, 'hex');
    }

switch (method) {
      case Method.Hello:
        output = serialize(this.config.types.Hello, body);
        break;
      case Method.Goodbye:
        output = serialize(this.config.types.Goodbye, body);
        break;
      case Method.BeaconBlocksByRange:
        output = serialize(this.config.types.BeaconBlocksByRangeRequest, body);
        break;
      case Method.BeaconBlocksByRoot:
        output = serialize(this.config.types.BeaconBlocksByRootRequest, body);
        break;
    }
    return Buffer.concat([
      Buffer.from(varint.encode(output.length)),
      output,
    ]);
  }
  private encodeResponse(method: Method, body: ResponseBody): Buffer {

return function(obj, buf, offset) {
					var len = varint.decode(buf, offset);
					offset += varint.decode.bytesRead;
					var end = offset + len;
					obj[key] = [];
					while (offset < end) {
						var next = {};
						obj[key].push(next);
						var itemLen = varint.decode(buf, offset);
						offset += varint.decode.bytesRead;
						offset = dec(next, buf, offset, offset, offset+itemLen);
					}
					return offset;
				};
			};

nameStorage.read(0, st.size, (err, buf) => {
          if (err) return cb(err, null)
          let len = 0

          try {
            len = varint.decode(buf, 0)
          } catch (err) {
            return cb(null, null)
          }

          const offset = varint.decode.bytes
          if (offset + len !== buf.length) return cb(null, null)
          const name = buf.slice(offset)
          return cb(null, name)
        })
      })

function decodeVarint (buf, offset) {
  try {
    return varint.decode(buf, offset)
  } catch (err) {
    return -1
  }
}

function unpackArray (buf) {
  var offset = 0
  var arr = []
  while (offset < buf.length) {
    arr.push(varint.decode(buf, offset))
    offset += varint.decode.bytes
  }
  return arr
}