Byte buffer specialized for data in chunks with special cases for dropping bytes in the front, merging bytes in to various integer types and abandoning buffer without penalty for previous chunk merges.

indutny

obuf

OffsetBuffer.prototype.isEmpty = function isEmpty() {

OffsetBuffer.prototype.clone = function clone(size) {

OffsetBuffer.prototype.toChunks = function toChunks() {

    this.buffers[0] = this.buffers[0].slice(this.offset);

  for (var i = 0; off <= this.size && i < this.buffers.length; i++) {

      this.buffers[i] = this.buffers[i].slice(0, -(off - this.size));

  // If some buffers were skipped - trim length

OffsetBuffer.prototype.toString = function toString(enc) {

  return this.toChunks().map(function(c) {

OffsetBuffer.prototype.use = function use(buf, off, n) {

OffsetBuffer.prototype.push = function push(data) {

OffsetBuffer.prototype.has = function has(n) {

OffsetBuffer.prototype.skip = function skip(n) {

  // Fast case, skip bytes in a first buffer

  if (this.offset + n < this.buffers[0].length) {

  var left = n - (this.buffers[0].length - this.offset);

  for (var shift = 1; left > 0 && shift < this.buffers.length; shift++) {

  this.buffers = this.buffers.slice(shift);

OffsetBuffer.prototype.copy = function copy(target, targetOff, off, n) {

OffsetBuffer.prototype.peekUInt8 = function peekUInt8() {

OffsetBuffer.prototype.readUInt8 = function readUInt8() {

OffsetBuffer.prototype.readUInt16LE = function readUInt16LE() {

  // Fast case - first buffer has all bytes

    r = first.readUInt16LE(this.offset, true);

    r = first[this.offset] | (this.buffers[1][0] << 8);

  if (this.offset === this.buffers[0].length) {

    this.buffers = this.buffers.slice(shift);

OffsetBuffer.prototype.readUInt24LE = function readUInt24LE() {

  var firstHas = first.length - this.offset;

    r = first.readUInt16LE(this.offset, true) | (first[this.offset + 2] << 16);

    r = first.readUInt16LE(this.offset, true) | (this.buffers[1][0] << 16);

  // Slow case: First buffer has 1 of 3 bytes

OffsetBuffer.prototype.readUInt32LE = function readUInt32LE() {

    r = first.readUInt32LE(this.offset, true);

    r = (first.readUInt16LE(this.offset, true) |

         (first[this.offset + 2] << 16)) +

        (this.buffers[1][0] * 0x1000000);

    "url": "git@github.com:indutny/offset-buffer"

  "author": "Fedor Indutny <fedor@indutny.com>",

    "url": "https://github.com/indutny/offset-buffer/issues"

  "homepage": "https://github.com/indutny/offset-buffer",

    it('should return the first buffer itself', function() {

    it('should return the slice of the buffer ', function() {

      assert.equal(o.take(5).toString(), 'hello');

      assert.equal(o.take(1).toString(), ' ');

      assert.equal(o.take(5).toString(), 'world');

    it('should concat buffers', function() {

      assert.equal(o.take(11).toString(), 'hello world');

      assert.equal(o.take(1).toString(), '!');

      assert.equal(o.take(2).toString(), 'he');

      assert.equal(o.take(2).toString(), 'lo');

      assert.equal(o.take(2).toString(), 'wo');

      assert.equal(o.take(7).toString(), 'oh gosh');

    it('should return and not move by one byte', function() {

    it('should return and move by one byte', function() {

    it('should return and move by two bytes', function() {

      o.push(new Buffer([ 0x1, 0x2, 0x3 ]));

      o.push(new Buffer([ 0x4, 0x5, 0x6 ]));

      assert.equal(o.readUInt16LE(), 0x0201);

      assert.equal(o.readUInt16LE(), 0x0403);

      assert.equal(o.readUInt16LE(), 0x0605);

    it('should return and move by three bytes', function() {

      o.push(new Buffer([ 0x1, 0x2, 0x3, 0x4, 0x5 ]));

      assert.equal(o.readUInt24LE(), 0x030201);

      assert.equal(o.readUInt24LE(), 0x060504);

      assert.equal(o.readUInt24LE(), 0x090807);

    it('should return and move by four bytes', function() {

      o.push(new Buffer([ 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 ]));

      o.push(new Buffer([ 0x8, 0x9, 0xa ]));

      o.push(new Buffer([ 0xb, 0xc, 0xd ]));

      o.push(new Buffer([ 0xe, 0xf, 0x10 ]));

      assert.equal(o.readUInt32LE(), 0x04030201);

      assert.equal(o.readUInt32LE(), 0x08070605);

      assert.equal(o.readUInt32LE(), 0x0c0b0a09);

      assert.equal(o.readUInt32LE(), 0x100f0e0d);

      assert.equal(o.readUInt16BE(), 0x0102);

      assert.equal(o.readUInt16BE(), 0x0304);

      assert.equal(o.readUInt16BE(), 0x0506);

      assert.equal(o.readUInt24BE(), 0x010203);

      assert.equal(o.readUInt24BE(), 0x040506);

      assert.equal(o.readUInt24BE(), 0x070809);

      assert.equal(o.readUInt32BE(), 0x01020304);

      assert.equal(o.readUInt32BE(), 0x05060708);

      assert.equal(o.readUInt32BE(), 0x090a0b0c);

      assert.equal(o.readUInt32BE(), 0x0d0e0f10);

    it('should return positive values', function() {

      o.push(new Buffer([ 0xff, 0xff, 0xff, 0xff ]));

      assert.equal(o.readUInt32BE(), 0xffffffff);

    it('should properly check the amount of the remaining bytes', function() {

      assert.equal(o.readUInt16BE(), 0x0203);

		@@ -167,2 +167,6 @@ function OffsetBuffer() {

		OffsetBuffer.prototype.peekUInt8 = function peekUInt8() {
		return this.buffers[0][this.offset];
		};

		OffsetBuffer.prototype.readUInt8 = function readUInt8() {
		@@ -169,0 +173,0 @@ this.size -= 1;

		{
		"name": "obuf",
		"version": "0.1.1",
		"version": "1.0.0",
		"description": "",
		@@ -5,0 +5,0 @@ "main": "index.js",

		@@ -56,2 +56,13 @@ var assert = require('assert');

		describe('.peekUInt8', function() {
		it('should return and not move by one byte', function() {
		o.push(new Buffer([ 0x1, 0x2 ]));
		assert.equal(o.peekUInt8(), 1);
		assert.equal(o.readUInt8(), 1);
		assert.equal(o.peekUInt8(), 2);
		assert.equal(o.readUInt8(), 2);
		assert(o.isEmpty());
		});
		});

		describe('.readUInt8', function() {
		@@ -148,2 +159,14 @@ it('should return and move by one byte', function() {
		});

		describe('.has', function() {
		it('should properly check the amount of the remaining bytes', function() {
		o.push(new Buffer([ 1, 2, 3 ]));
		assert(o.has(3));
		assert.equal(o.readUInt8(), 0x01);
		assert(!o.has(3));
		assert(o.has(2));
		assert.equal(o.readUInt16BE(), 0x0203);
		assert(!o.has(1));
		});
		});
		});

Fixed alerts

Improved metrics