module buffer
1. function buffer.Buffer (arg, encodingOrOffset, length)
2. function buffer.SlowBuffer (length)
3. number buffer.INSPECT_MAX_BYTES
4. number buffer.kMaxLength
5. object buffer.Buffer.prototype
module buffer.Buffer
1. boolean buffer.Buffer.TYPED_ARRAY_SUPPORT
2. function buffer.Buffer (arg, encodingOrOffset, length)
3. function buffer.Buffer.alloc (size, fill, encoding)
4. function buffer.Buffer.allocUnsafe (size)
5. function buffer.Buffer.allocUnsafeSlow (size)
6. function buffer.Buffer.byteLength (string, encoding)
7. function buffer.Buffer.compare (a, b)
8. function buffer.Buffer.concat (list, length)
9. function buffer.Buffer.from (value, encodingOrOffset, length)
10. function buffer.Buffer.isBuffer (b)
11. function buffer.Buffer.isEncoding (encoding)
12. number buffer.Buffer.poolSize
module buffer.Buffer.prototype

module buffer

function buffer.Buffer (arg, encodingOrOffset, length)

description and source-code

function Buffer(arg, encodingOrOffset, length) {
  // Common case.
  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new Error(
        'If encoding is specified then the first argument must be a string'
      )
    }
    return allocUnsafe(arg)
  }
  return from(arg, encodingOrOffset, length)
}

example usage
```
n/a
```

function buffer.SlowBuffer (length)

description and source-code

function SlowBuffer(length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return Buffer.alloc(+length)
}

example usage
```
n/a
```

module buffer.Buffer

function buffer.Buffer (arg, encodingOrOffset, length)

description and source-code

function Buffer(arg, encodingOrOffset, length) {
  // Common case.
  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new Error(
        'If encoding is specified then the first argument must be a string'
      )
    }
    return allocUnsafe(arg)
  }
  return from(arg, encodingOrOffset, length)
}

example usage
```
n/a
```

function buffer.Buffer.alloc (size, fill, encoding)

description and source-code

alloc = function (size, fill, encoding) {
  return alloc(size, fill, encoding)
}

example usage

...
  return length | 0
}

function SlowBuffer (length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return Buffer.alloc(+length)
}

Buffer.isBuffer = function isBuffer (b) {
  return b != null && b._isBuffer === true
}

Buffer.compare = function compare (a, b) {
...

function buffer.Buffer.allocUnsafe (size)

description and source-code

allocUnsafe = function (size) {
  return allocUnsafe(size)
}

example usage

...
if (length === undefined) {
  length = 0
  for (i = 0; i < list.length; ++i) {
    length += list[i].length
  }
}

var buffer = Buffer.allocUnsafe(length)
var pos = 0
for (i = 0; i < list.length; ++i) {
  var buf = list[i]
  if (!Buffer.isBuffer(buf)) {
    throw new TypeError('"list" argument must be an Array of Buffers')
  }
  buf.copy(buffer, pos)
...

function buffer.Buffer.allocUnsafeSlow (size)

description and source-code

allocUnsafeSlow = function (size) {
  return allocUnsafe(size)
}

example usage
```
n/a
```

function buffer.Buffer.byteLength (string, encoding)

description and source-code

function byteLength(string, encoding) {
  if (Buffer.isBuffer(string)) {
    return string.length
  }
  if (isArrayBufferView(string) || string instanceof ArrayBuffer) {
    return string.byteLength
  }
  if (typeof string !== 'string') {
    string = '' + string
  }

  var len = string.length
  if (len === 0) return 0

  // Use a for loop to avoid recursion
  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len
      case 'utf8':
      case 'utf-8':
      case undefined:
        return utf8ToBytes(string).length
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2
      case 'hex':
        return len >>> 1
      case 'base64':
        return base64ToBytes(string).length
      default:
        if (loweredCase) return utf8ToBytes(string).length // assume utf8
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}

example usage
```
n/a
```

function buffer.Buffer.compare (a, b)

description and source-code

function compare(a, b) {
  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    throw new TypeError('Arguments must be Buffers')
  }

  if (a === b) return 0

  var x = a.length
  var y = b.length

  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i]
      y = b[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

example usage

...
if (arguments.length === 0) return utf8Slice(this, 0, length)
return slowToString.apply(this, arguments)
}

Buffer.prototype.equals = function equals (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function inspect () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if (this.length > 0) {
  str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
...

function buffer.Buffer.concat (list, length)

description and source-code

function concat(list, length) {
  if (!Array.isArray(list)) {
    throw new TypeError('"list" argument must be an Array of Buffers')
  }

  if (list.length === 0) {
    return Buffer.alloc(0)
  }

  var i
  if (length === undefined) {
    length = 0
    for (i = 0; i < list.length; ++i) {
      length += list[i].length
    }
  }

  var buffer = Buffer.allocUnsafe(length)
  var pos = 0
  for (i = 0; i < list.length; ++i) {
    var buf = list[i]
    if (!Buffer.isBuffer(buf)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }
    buf.copy(buffer, pos)
    pos += buf.length
  }
  return buffer
}

example usage
```
n/a
```

function buffer.Buffer.from (value, encodingOrOffset, length)

description and source-code

from = function (value, encodingOrOffset, length) {
  return from(value, encodingOrOffset, length)
}

example usage

...
```

### convert arraybuffer to buffer

To convert an `ArrayBuffer` to a `Buffer`, use the `Buffer.from` function. Does not perform a copy, so it's super fast.

```js
var buffer = Buffer.from(arrayBuffer)
```

### convert buffer to arraybuffer

To convert a `Buffer` to an `ArrayBuffer`, use the `.buffer` property (which is present on all `Uint8Array` objects):

```js
...

function buffer.Buffer.isBuffer (b)

description and source-code

function isBuffer(b) {
  return b != null && b._isBuffer === true
}

example usage

...

  // Return an augmented `Uint8Array` instance
  buf.__proto__ = Buffer.prototype
  return buf
}

function fromObject (obj) {
  if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0
var buf = createBuffer(len)

if (buf.length === 0) {
  return buf
}
...

function buffer.Buffer.isEncoding (encoding)

description and source-code

function isEncoding(encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

example usage

...
}

function fromString (string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
  encoding = 'utf8'
}

if (!Buffer.isEncoding(encoding)) {
  throw new TypeError('"encoding" must be a valid string encoding')
}

var length = byteLength(string, encoding) | 0
var buf = createBuffer(length)

var actual = buf.write(string, encoding)
...

module buffer.Buffer.prototype

function buffer.Buffer.prototype.compare (target, start, end, thisStart, thisEnd)

description and source-code

function compare(target, start, end, thisStart, thisEnd) {
  if (!Buffer.isBuffer(target)) {
    throw new TypeError('Argument must be a Buffer')
  }

  if (start === undefined) {
    start = 0
  }
  if (end === undefined) {
    end = target ? target.length : 0
  }
  if (thisStart === undefined) {
    thisStart = 0
  }
  if (thisEnd === undefined) {
    thisEnd = this.length
  }

  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    throw new RangeError('out of range index')
  }

  if (thisStart >= thisEnd && start >= end) {
    return 0
  }
  if (thisStart >= thisEnd) {
    return -1
  }
  if (start >= end) {
    return 1
  }

  start >>>= 0
  end >>>= 0
  thisStart >>>= 0
  thisEnd >>>= 0

  if (this === target) return 0

  var x = thisEnd - thisStart
  var y = end - start
  var len = Math.min(x, y)

  var thisCopy = this.slice(thisStart, thisEnd)
  var targetCopy = target.slice(start, end)

  for (var i = 0; i < len; ++i) {
    if (thisCopy[i] !== targetCopy[i]) {
      x = thisCopy[i]
      y = targetCopy[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

example usage

...
if (arguments.length === 0) return utf8Slice(this, 0, length)
return slowToString.apply(this, arguments)
}

Buffer.prototype.equals = function equals (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function inspect () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if (this.length > 0) {
  str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
...

function buffer.Buffer.prototype.copy (target, targetStart, start, end)

description and source-code

function copy(target, targetStart, start, end) {
  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (targetStart >= target.length) targetStart = target.length
  if (!targetStart) targetStart = 0
  if (end > 0 && end < start) end = start

  // Copy 0 bytes; we're done
  if (end === start) return 0
  if (target.length === 0 || this.length === 0) return 0

  // Fatal error conditions
  if (targetStart < 0) {
    throw new RangeError('targetStart out of bounds')
  }
  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
  if (end < 0) throw new RangeError('sourceEnd out of bounds')

  // Are we oob?
  if (end > this.length) end = this.length
  if (target.length - targetStart < end - start) {
    end = target.length - targetStart + start
  }

  var len = end - start
  var i

  if (this === target && start < targetStart && targetStart < end) {
    // descending copy from end
    for (i = len - 1; i >= 0; --i) {
      target[i + targetStart] = this[i + start]
    }
  } else if (len < 1000) {
    // ascending copy from start
    for (i = 0; i < len; ++i) {
      target[i + targetStart] = this[i + start]
    }
  } else {
    Uint8Array.prototype.set.call(
      target,
      this.subarray(start, start + len),
      targetStart
    )
  }

  return len
}

example usage

...
  var len = checked(obj.length) | 0
  var buf = createBuffer(len)

  if (buf.length === 0) {
    return buf
  }

  obj.copy(buf, 0, 0, len)
  return buf
}

if (obj) {
  if (isArrayBufferView(obj) || 'length' in obj) {
    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
      return createBuffer(0)
...

function buffer.Buffer.prototype.equals (b)

description and source-code

function equals(b) {
  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
  if (this === b) return true
  return Buffer.compare(this, b) === 0
}

example usage
```
n/a
```

function buffer.Buffer.prototype.fill (val, start, end, encoding)

description and source-code

function fill(val, start, end, encoding) {
  // Handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start
      start = 0
      end = this.length
    } else if (typeof end === 'string') {
      encoding = end
      end = this.length
    }
    if (val.length === 1) {
      var code = val.charCodeAt(0)
      if (code < 256) {
        val = code
      }
    }
    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new TypeError('encoding must be a string')
    }
    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
  } else if (typeof val === 'number') {
    val = val & 255
  }

  // Invalid ranges are not set to a default, so can range check early.
  if (start < 0 || this.length < start || this.length < end) {
    throw new RangeError('Out of range index')
  }

  if (end <= start) {
    return this
  }

  start = start >>> 0
  end = end === undefined ? this.length : end >>> 0

  if (!val) val = 0

  var i
  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val
    }
  } else {
    var bytes = Buffer.isBuffer(val)
      ? val
      : new Buffer(val, encoding)
    var len = bytes.length
    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len]
    }
  }

  return this
}

example usage

...
   return createBuffer(size)
 }
 if (fill !== undefined) {
   // Only pay attention to encoding if it's a string. This
   // prevents accidentally sending in a number that would
   // be interpretted as a start offset.
   return typeof encoding === 'string'
     ? createBuffer(size).fill(fill, encoding)
     : createBuffer(size).fill(fill)
 }
 return createBuffer(size)
}

/**
* Creates a new filled Buffer instance.
...

function buffer.Buffer.prototype.includes (val, byteOffset, encoding)

description and source-code

function includes(val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

example usage
```
n/a
```

function buffer.Buffer.prototype.indexOf (val, byteOffset, encoding)

description and source-code

function indexOf(val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

example usage

...
    }
  }

  return -1
}

Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
...

function buffer.Buffer.prototype.inspect ()

description and source-code

function inspect() {
  var str = ''
  var max = exports.INSPECT_MAX_BYTES
  if (this.length > 0) {
    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
    if (this.length > max) str += ' ... '
  }
  return '<Buffer ' + str + '>'
}

example usage
```
n/a
```

function buffer.Buffer.prototype.lastIndexOf (val, byteOffset, encoding)

description and source-code

function lastIndexOf(val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readDoubleBE (offset, noAssert)

description and source-code

function readDoubleBE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, false, 52, 8)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readDoubleLE (offset, noAssert)

description and source-code

function readDoubleLE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, true, 52, 8)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readFloatBE (offset, noAssert)

description and source-code

function readFloatBE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, false, 23, 4)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readFloatLE (offset, noAssert)

description and source-code

function readFloatLE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, true, 23, 4)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readInt16BE (offset, noAssert)

description and source-code

function readInt16BE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset + 1] | (this[offset] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readInt16LE (offset, noAssert)

description and source-code

function readInt16LE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset] | (this[offset + 1] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readInt32BE (offset, noAssert)

description and source-code

function readInt32BE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] << 24) |
    (this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    (this[offset + 3])
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readInt32LE (offset, noAssert)

description and source-code

function readInt32LE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset]) |
    (this[offset + 1] << 8) |
    (this[offset + 2] << 16) |
    (this[offset + 3] << 24)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readInt8 (offset, noAssert)

description and source-code

function readInt8(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  if (!(this[offset] & 0x80)) return (this[offset])
  return ((0xff - this[offset] + 1) * -1)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readIntBE (offset, byteLength, noAssert)

description and source-code

function readIntBE(offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var i = byteLength
  var mul = 1
  var val = this[offset + --i]
  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readIntLE (offset, byteLength, noAssert)

description and source-code

function readIntLE(offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readUInt16BE (offset, noAssert)

description and source-code

function readUInt16BE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return (this[offset] << 8) | this[offset + 1]
}

example usage

...
  }
}

function read (buf, i) {
  if (indexSize === 1) {
    return buf[i]
  } else {
    return buf.readUInt16BE(i * indexSize)
  }
}

var i
if (dir) {
  var foundIndex = -1
  for (i = byteOffset; i < arrLength; i++) {
...

function buffer.Buffer.prototype.readUInt16LE (offset, noAssert)

description and source-code

function readUInt16LE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return this[offset] | (this[offset + 1] << 8)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readUInt32BE (offset, noAssert)

description and source-code

function readUInt32BE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] * 0x1000000) +
    ((this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    this[offset + 3])
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readUInt32LE (offset, noAssert)

description and source-code

function readUInt32LE(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return ((this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16)) +
      (this[offset + 3] * 0x1000000)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readUInt8 (offset, noAssert)

description and source-code

function readUInt8(offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  return this[offset]
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readUIntBE (offset, byteLength, noAssert)

description and source-code

function readUIntBE(offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    checkOffset(offset, byteLength, this.length)
  }

  var val = this[offset + --byteLength]
  var mul = 1
  while (byteLength > 0 && (mul *= 0x100)) {
    val += this[offset + --byteLength] * mul
  }

  return val
}

example usage
```
n/a
```

function buffer.Buffer.prototype.readUIntLE (offset, byteLength, noAssert)

description and source-code

function readUIntLE(offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }

  return val
}

example usage
```
n/a
```

function buffer.Buffer.prototype.slice (start, end)

description and source-code

function slice(start, end) {
  var len = this.length
  start = ~~start
  end = end === undefined ? len : ~~end

  if (start < 0) {
    start += len
    if (start < 0) start = 0
  } else if (start > len) {
    start = len
  }

  if (end < 0) {
    end += len
    if (end < 0) end = 0
  } else if (end > len) {
    end = len
  }

  if (end < start) end = start

  var newBuf = this.subarray(start, end)
  // Return an augmented `Uint8Array` instance
  newBuf.__proto__ = Buffer.prototype
  return newBuf
}

example usage

...

var actual = buf.write(string, encoding)

if (actual !== length) {
  // Writing a hex string, for example, that contains invalid characters will
  // cause everything after the first invalid character to be ignored. (e.g.
  // 'abxxcd' will be treated as 'ab')
  buf = buf.slice(0, actual)
}

return buf
}

function fromArrayLike (array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0
...

function buffer.Buffer.prototype.swap16 ()

description and source-code

function swap16() {
  var len = this.length
  if (len % 2 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 16-bits')
  }
  for (var i = 0; i < len; i += 2) {
    swap(this, i, i + 1)
  }
  return this
}

example usage
```
n/a
```

function buffer.Buffer.prototype.swap32 ()

description and source-code

function swap32() {
  var len = this.length
  if (len % 4 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 32-bits')
  }
  for (var i = 0; i < len; i += 4) {
    swap(this, i, i + 3)
    swap(this, i + 1, i + 2)
  }
  return this
}

example usage
```
n/a
```

function buffer.Buffer.prototype.swap64 ()

description and source-code

function swap64() {
  var len = this.length
  if (len % 8 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 64-bits')
  }
  for (var i = 0; i < len; i += 8) {
    swap(this, i, i + 7)
    swap(this, i + 1, i + 6)
    swap(this, i + 2, i + 5)
    swap(this, i + 3, i + 4)
  }
  return this
}

example usage
```
n/a
```

function buffer.Buffer.prototype.toJSON ()

description and source-code

function toJSON() {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
}

example usage
```
n/a
```

function buffer.Buffer.prototype.toString ()

description and source-code

function toString() {
  var length = this.length
  if (length === 0) return ''
  if (arguments.length === 0) return utf8Slice(this, 0, length)
  return slowToString.apply(this, arguments)
}

example usage

...
}

function checked (length) {
// Note: cannot use `length < K_MAX_LENGTH` here because that fails when
// length is NaN (which is otherwise coerced to zero.)
if (length >= K_MAX_LENGTH) {
  throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                       'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes
')
}
return length | 0
}

function SlowBuffer (length) {
if (+length != length) { // eslint-disable-line eqeqeq
  length = 0
...

function buffer.Buffer.prototype.write (string, offset, length, encoding)

description and source-code

function write(string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset >>> 0
    if (isFinite(length)) {
      length = length >>> 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  } else {
    throw new Error(
      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
    )
  }

  var remaining = this.length - offset
  if (length === undefined || length > remaining) length = remaining

  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    throw new RangeError('Attempt to write outside buffer bounds')
  }

  if (!encoding) encoding = 'utf8'

  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexWrite(this, string, offset, length)

      case 'utf8':
      case 'utf-8':
        return utf8Write(this, string, offset, length)

      case 'ascii':
        return asciiWrite(this, string, offset, length)

      case 'latin1':
      case 'binary':
        return latin1Write(this, string, offset, length)

      case 'base64':
        // Warning: maxLength not taken into account in base64Write
        return base64Write(this, string, offset, length)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2Write(this, string, offset, length)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}

example usage

...
if (!Buffer.isEncoding(encoding)) {
  throw new TypeError('"encoding" must be a valid string encoding')
}

var length = byteLength(string, encoding) | 0
var buf = createBuffer(length)

var actual = buf.write(string, encoding)

if (actual !== length) {
  // Writing a hex string, for example, that contains invalid characters will
  // cause everything after the first invalid character to be ignored. (e.g.
  // 'abxxcd' will be treated as 'ab')
  buf = buf.slice(0, actual)
}
...

function buffer.Buffer.prototype.writeDoubleBE (value, offset, noAssert)

description and source-code

function writeDoubleBE(value, offset, noAssert) {
  return writeDouble(this, value, offset, false, noAssert)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeDoubleLE (value, offset, noAssert)

description and source-code

function writeDoubleLE(value, offset, noAssert) {
  return writeDouble(this, value, offset, true, noAssert)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeFloatBE (value, offset, noAssert)

description and source-code

function writeFloatBE(value, offset, noAssert) {
  return writeFloat(this, value, offset, false, noAssert)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeFloatLE (value, offset, noAssert)

description and source-code

function writeFloatLE(value, offset, noAssert) {
  return writeFloat(this, value, offset, true, noAssert)
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeInt16BE (value, offset, noAssert)

description and source-code

function writeInt16BE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeInt16LE (value, offset, noAssert)

description and source-code

function writeInt16LE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeInt32BE (value, offset, noAssert)

description and source-code

function writeInt32BE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (value < 0) value = 0xffffffff + value + 1
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeInt32LE (value, offset, noAssert)

description and source-code

function writeInt32LE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  this[offset + 2] = (value >>> 16)
  this[offset + 3] = (value >>> 24)
  return offset + 4
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeInt8 (value, offset, noAssert)

description and source-code

function writeInt8(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
  if (value < 0) value = 0xff + value + 1
  this[offset] = (value & 0xff)
  return offset + 1
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeIntBE (value, offset, byteLength, noAssert)

description and source-code

function writeIntBE(value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    var limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = byteLength - 1
  var mul = 1
  var sub = 0
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeIntLE (value, offset, byteLength, noAssert)

description and source-code

function writeIntLE(value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    var limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = 0
  var mul = 1
  var sub = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeUInt16BE (value, offset, noAssert)

description and source-code

function writeUInt16BE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeUInt16LE (value, offset, noAssert)

description and source-code

function writeUInt16LE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeUInt32BE (value, offset, noAssert)

description and source-code

function writeUInt32BE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeUInt32LE (value, offset, noAssert)

description and source-code

function writeUInt32LE(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset + 3] = (value >>> 24)
  this[offset + 2] = (value >>> 16)
  this[offset + 1] = (value >>> 8)
  this[offset] = (value & 0xff)
  return offset + 4
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeUInt8 (value, offset, noAssert)

description and source-code

function writeUInt8(value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
  this[offset] = (value & 0xff)
  return offset + 1
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeUIntBE (value, offset, byteLength, noAssert)

description and source-code

function writeUIntBE(value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var i = byteLength - 1
  var mul = 1
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

example usage
```
n/a
```

function buffer.Buffer.prototype.writeUIntLE (value, offset, byteLength, noAssert)

description and source-code

function writeUIntLE(value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var mul = 1
  var i = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

example usage
```
n/a
```

api documentation for buffer (v5.0.6)

Node.js Buffer API, for the browser

table of contents