text: var DuplexStream = require('readable-stream/duplex')
      , util = require('util')
  
  
  function BufferList(callback) {
      if (!(this instanceof BufferList))
          return new BufferList(callback)
  
      this._bufs = []
      this.length = 0
  
      if (typeof callback == 'function') {
          this._callback = callback
  
          var piper = function piper(err) {
              if (this._callback) {
                  this._callback(err)
                  this._callback = null
              }
          }.bind(this)
  
          this.on('pipe', function onPipe(src) {
              src.on('error', piper)
          })
          this.on('unpipe', function onUnpipe(src) {
              src.removeListener('error', piper)
          })
      } else {
          this.append(callback)
      }
  
      DuplexStream.call(this)
  }
  
  
  util.inherits(BufferList, DuplexStream)
  
  
  BufferList.prototype._offset = function _offset(offset) {
      var tot = 0, i = 0, _t
      if (offset === 0) return [0, 0]
      for (; i < this._bufs.length; i++) {
          _t = tot + this._bufs[i].length
          if (offset < _t || i == this._bufs.length - 1)
              return [i, offset - tot]
          tot = _t
      }
  }
  
  
  BufferList.prototype.append = function append(buf) {
      var i = 0
  
      if (Buffer.isBuffer(buf)) {
          this._appendBuffer(buf);
      } else if (Array.isArray(buf)) {
          for (; i < buf.length; i++)
              this.append(buf[i])
      } else if (buf instanceof BufferList) {
          // unwrap argument into individual BufferLists
          for (; i < buf._bufs.length; i++)
              this.append(buf._bufs[i])
      } else if (buf != null) {
          // coerce number arguments to strings, since Buffer(number) does
          // uninitialized memory allocation
          if (typeof buf == 'number')
              buf = buf.toString()
  
          this._appendBuffer(new Buffer(buf));
      }
  
      return this
  }
  
  
  BufferList.prototype._appendBuffer = function appendBuffer(buf) {
      this._bufs.push(buf)
      this.length += buf.length
  }
  
  
  BufferList.prototype._write = function _write(buf, encoding, callback) {
      this._appendBuffer(buf)
  
      if (typeof callback == 'function')
          callback()
  }
  
  
  BufferList.prototype._read = function _read(size) {
      if (!this.length)
          return this.push(null)
  
      size = Math.min(size, this.length)
      this.push(this.slice(0, size))
      this.consume(size)
  }
  
  
  BufferList.prototype.end = function end(chunk) {
      DuplexStream.prototype.end.call(this, chunk)
  
      if (this._callback) {
          this._callback(null, this.slice())
          this._callback = null
      }
  }
  
  
  BufferList.prototype.get = function get(index) {
      return this.slice(index, index + 1)[0]
  }
  
  
  BufferList.prototype.slice = function slice(start, end) {
      if (typeof start == 'number' && start < 0)
          start += this.length
      if (typeof end == 'number' && end < 0)
          end += this.length
      return this.copy(null, 0, start, end)
  }
  
  
  BufferList.prototype.copy = function copy(dst, dstStart, srcStart, srcEnd) {
      if (typeof srcStart != 'number' || srcStart < 0)
          srcStart = 0
      if (typeof srcEnd != 'number' || srcEnd > this.length)
          srcEnd = this.length
      if (srcStart >= this.length)
          return dst || new Buffer(0)
      if (srcEnd <= 0)
          return dst || new Buffer(0)
  
      var copy = !!dst
          , off = this._offset(srcStart)
          , len = srcEnd - srcStart
          , bytes = len
          , bufoff = (copy && dstStart) || 0
          , start = off[1]
          , l
          , i
  
      // copy/slice everything
      if (srcStart === 0 && srcEnd == this.length) {
          if (!copy) { // slice, but full concat if multiple buffers
              return this._bufs.length === 1
                  ? this._bufs[0]
                  : Buffer.concat(this._bufs, this.length)
          }
  
          // copy, need to copy individual buffers
          for (i = 0; i < this._bufs.length; i++) {
              this._bufs[i].copy(dst, bufoff)
              bufoff += this._bufs[i].length
          }
  
          return dst
      }
  
      // easy, cheap case where it's a subset of one of the buffers
      if (bytes <= this._bufs[off[0]].length - start) {
          return copy
              ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
              : this._bufs[off[0]].slice(start, start + bytes)
      }
  
      if (!copy) // a slice, we need something to copy in to
          dst = new Buffer(len)
  
      for (i = off[0]; i < this._bufs.length; i++) {
          l = this._bufs[i].length - start
  
          if (bytes > l) {
              this._bufs[i].copy(dst, bufoff, start)
          } else {
              this._bufs[i].copy(dst, bufoff, start, start + bytes)
              break
          }
  
          bufoff += l
          bytes -= l
  
          if (start)
              start = 0
      }
  
      return dst
  }
  
  BufferList.prototype.shallowSlice = function shallowSlice(start, end) {
      start = start || 0
      end = end || this.length
  
      if (start < 0)
          start += this.length
      if (end < 0)
          end += this.length
  
      var startOffset = this._offset(start)
          , endOffset = this._offset(end)
          , buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
  
      if (endOffset[1] == 0)
          buffers.pop()
      else
          buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])
  
      if (startOffset[1] != 0)
          buffers[0] = buffers[0].slice(startOffset[1])
  
      return new BufferList(buffers)
  }
  
  BufferList.prototype.toString = function toString(encoding, start, end) {
      return this.slice(start, end).toString(encoding)
  }
  
  BufferList.prototype.consume = function consume(bytes) {
      while (this._bufs.length) {
          if (bytes >= this._bufs[0].length) {
              bytes -= this._bufs[0].length
              this.length -= this._bufs[0].length
              this._bufs.shift()
          } else {
              this._bufs[0] = this._bufs[0].slice(bytes)
              this.length -= bytes
              break
          }
      }
      return this
  }
  
  
  BufferList.prototype.duplicate = function duplicate() {
      var i = 0
          , copy = new BufferList()
  
      for (; i < this._bufs.length; i++)
          copy.append(this._bufs[i])
  
      return copy
  }
  
  
  BufferList.prototype.destroy = function destroy() {
      this._bufs.length = 0
      this.length = 0
      this.push(null)
  }
  
  
  ;(function () {
      var methods = {
          'readDoubleBE': 8
          , 'readDoubleLE': 8
          , 'readFloatBE': 4
          , 'readFloatLE': 4
          , 'readInt32BE': 4
          , 'readInt32LE': 4
          , 'readUInt32BE': 4
          , 'readUInt32LE': 4
          , 'readInt16BE': 2
          , 'readInt16LE': 2
          , 'readUInt16BE': 2
          , 'readUInt16LE': 2
          , 'readInt8': 1
          , 'readUInt8': 1
      }
  
      for (var m in methods) {
          (function (m) {
              BufferList.prototype[m] = function (offset) {
                  return this.slice(offset, offset + methods[m])[m](0)
              }
          }(m))
      }
  }())
  
  
  module.exports = BufferList
  