style: use 'standard', minor formatting & syntax changes

Author: rvagg

.travis.yml

@@ -4,6 +4,8 @@ node_js:
   - '6'
   - '8'
   - '10'
+  - '12'
+  - master
 branches:
   only:
     - master

BufferList.js

@@ -1,10 +1,11 @@
 'use strict'
 
-var symbol = Symbol.for('BufferList')
+const symbol = Symbol.for('BufferList')
 
 function BufferList (buf) {
-  if (!(this instanceof BufferList))
+  if (!(this instanceof BufferList)) {
     return new BufferList(buf)
+  }
 
   BufferList._init.call(this, buf)
 }
@@ -14,80 +15,100 @@ BufferList._init = function _init (buf) {
 
   this._bufs = []
   this.length = 0
-  if (buf) this.append(buf)
+
+  if (buf) {
+    this.append(buf)
+  }
 }
 
 BufferList.prototype._new = function _new (buf) {
   return new BufferList(buf)
 }
 
 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 ]
+  if (offset === 0) {
+    return [0, 0]
+  }
+
+  let tot = 0
+
+  for (let i = 0; i < this._bufs.length; i++) {
+    const _t = tot + this._bufs[i].length
+    if (offset < _t || i === this._bufs.length - 1) {
+      return [i, offset - tot]
     }
     tot = _t
   }
 }
 
 BufferList.prototype._reverseOffset = function (blOffset) {
-  var bufferId = blOffset[0]
-  var offset = blOffset[1]
-  for (var i = 0; i < bufferId; i++) {
+  const bufferId = blOffset[0]
+  let offset = blOffset[1]
+
+  for (let i = 0; i < bufferId; i++) {
     offset += this._bufs[i].length
   }
+
   return offset
 }
 
 BufferList.prototype.get = function get (index) {
   if (index > this.length || index < 0) {
     return undefined
   }
-  var offset = this._offset(index)
+
+  const offset = this._offset(index)
+
   return this._bufs[offset[0]][offset[1]]
 }
 
 BufferList.prototype.slice = function slice (start, end) {
-  if (typeof start == 'number' && start < 0)
+  if (typeof start === 'number' && start < 0) {
     start += this.length
-  if (typeof end == 'number' && end < 0)
+  }
+
+  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)
+  if (typeof srcStart !== 'number' || srcStart < 0) {
     srcStart = 0
-  if (typeof srcEnd != 'number' || srcEnd > this.length)
+  }
+
+  if (typeof srcEnd !== 'number' || srcEnd > this.length) {
     srcEnd = this.length
-  if (srcStart >= this.length)
+  }
+
+  if (srcStart >= this.length) {
     return dst || Buffer.alloc(0)
-  if (srcEnd <= 0)
+  }
+
+  if (srcEnd <= 0) {
     return dst || Buffer.alloc(0)
+  }
 
-  var copy   = !!dst
-    , off    = this._offset(srcStart)
-    , len    = srcEnd - srcStart
-    , bytes  = len
-    , bufoff = (copy && dstStart) || 0
-    , start  = off[1]
-    , l
-    , i
+  const copy = !!dst
+  const off = this._offset(srcStart)
+  const len = srcEnd - srcStart
+  let bytes = len
+  let bufoff = (copy && dstStart) || 0
+  let start = off[1]
 
   // copy/slice everything
-  if (srcStart === 0 && srcEnd == this.length) {
-    if (!copy) { // slice, but full concat if multiple buffers
+  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++) {
+    for (let i = 0; i < this._bufs.length; i++) {
       this._bufs[i].copy(dst, bufoff)
       bufoff += this._bufs[i].length
     }
@@ -102,11 +123,13 @@ BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
       : this._bufs[off[0]].slice(start, start + bytes)
   }
 
-  if (!copy) // a slice, we need something to copy in to
+  if (!copy) {
+    // a slice, we need something to copy in to
     dst = Buffer.allocUnsafe(len)
+  }
 
-  for (i = off[0]; i < this._bufs.length; i++) {
-    l = this._bufs[i].length - start
+  for (let i = off[0]; i < this._bufs.length; i++) {
+    const l = this._bufs[i].length - start
 
     if (bytes > l) {
       this._bufs[i].copy(dst, bufoff, start)
@@ -118,8 +141,9 @@ BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
     bufoff += l
     bytes -= l
 
-    if (start)
+    if (start) {
       start = 0
+    }
   }
 
   return dst
@@ -129,25 +153,31 @@ BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
   start = start || 0
   end = typeof end !== 'number' ? this.length : end
 
-  if (start < 0)
+  if (start < 0) {
     start += this.length
-  if (end < 0)
+  }
+
+  if (end < 0) {
     end += this.length
+  }
 
   if (start === end) {
     return this._new()
   }
-  var startOffset = this._offset(start)
-    , endOffset = this._offset(end)
-    , buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
 
-  if (endOffset[1] == 0)
+  const startOffset = this._offset(start)
+  const endOffset = this._offset(end)
+  const 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])
+  } else {
+    buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])
+  }
 
-  if (startOffset[1] != 0)
+  if (startOffset[1] !== 0) {
     buffers[0] = buffers[0].slice(startOffset[1])
+  }
 
   return this._new(buffers)
 }
@@ -168,23 +198,21 @@ BufferList.prototype.consume = function consume (bytes) {
       break
     }
   }
+
   return this
 }
 
-
 BufferList.prototype.duplicate = function duplicate () {
-  var i = 0
-    , copy = this._new()
+  const copy = this._new()
 
-  for (; i < this._bufs.length; i++)
+  for (let i = 0; i < this._bufs.length; i++) {
     copy.append(this._bufs[i])
+  }
 
   return copy
 }
 
 BufferList.prototype.append = function append (buf) {
-  var i = 0
-
   if (buf == null) {
     return this
   }
@@ -193,17 +221,20 @@ BufferList.prototype.append = function append (buf) {
     // append a view of the underlying ArrayBuffer
     this._appendBuffer(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength))
   } else if (Array.isArray(buf)) {
-    for (; i < buf.length; i++)
+    for (let i = 0; i < buf.length; i++) {
       this.append(buf[i])
+    }
   } else if (this._isBufferList(buf)) {
     // unwrap argument into individual BufferLists
-    for (; i < buf._bufs.length; i++)
+    for (let i = 0; i < buf._bufs.length; i++) {
       this.append(buf._bufs[i])
+    }
   } else {
     // coerce number arguments to strings, since Buffer(number) does
     // uninitialized memory allocation
-    if (typeof buf == 'number')
+    if (typeof buf === 'number') {
       buf = buf.toString()
+    }
 
     this._appendBuffer(Buffer.from(buf))
   }
@@ -221,6 +252,7 @@ BufferList.prototype.indexOf = function (search, offset, encoding) {
     encoding = offset
     offset = undefined
   }
+
   if (typeof search === 'function' || Array.isArray(search)) {
     throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.')
   } else if (typeof search === 'number') {
@@ -236,6 +268,7 @@ BufferList.prototype.indexOf = function (search, offset, encoding) {
   }
 
   offset = Number(offset || 0)
+
   if (isNaN(offset)) {
     offset = 0
   }
@@ -252,39 +285,48 @@ BufferList.prototype.indexOf = function (search, offset, encoding) {
     return offset > this.length ? this.length : offset
   }
 
-  var blOffset = this._offset(offset)
-  var blIndex = blOffset[0] // index of which internal buffer we're working on
-  var buffOffset = blOffset[1] // offset of the internal buffer we're working on
+  const blOffset = this._offset(offset)
+  let blIndex = blOffset[0] // index of which internal buffer we're working on
+  let buffOffset = blOffset[1] // offset of the internal buffer we're working on
 
   // scan over each buffer
-  for (blIndex; blIndex < this._bufs.length; blIndex++) {
-    var buff = this._bufs[blIndex]
+  for (; blIndex < this._bufs.length; blIndex++) {
+    const buff = this._bufs[blIndex]
+
     while (buffOffset < buff.length) {
-      var availableWindow = buff.length - buffOffset
+      const availableWindow = buff.length - buffOffset
+
       if (availableWindow >= search.length) {
-        var nativeSearchResult = buff.indexOf(search, buffOffset)
+        const nativeSearchResult = buff.indexOf(search, buffOffset)
+
         if (nativeSearchResult !== -1) {
           return this._reverseOffset([blIndex, nativeSearchResult])
         }
+
         buffOffset = buff.length - search.length + 1 // end of native search window
       } else {
-        var revOffset = this._reverseOffset([blIndex, buffOffset])
+        const revOffset = this._reverseOffset([blIndex, buffOffset])
+
         if (this._match(revOffset, search)) {
           return revOffset
         }
+
         buffOffset++
       }
     }
+
     buffOffset = 0
   }
+
   return -1
 }
 
 BufferList.prototype._match = function (offset, search) {
   if (this.length - offset < search.length) {
     return false
   }
-  for (var searchOffset = 0; searchOffset < search.length; searchOffset++) {
+
+  for (let searchOffset = 0; searchOffset < search.length; searchOffset++) {
     if (this.get(offset + searchOffset) !== search[searchOffset]) {
       return false
     }
@@ -293,28 +335,28 @@ BufferList.prototype._match = function (offset, search) {
 }
 
 ;(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
-    , 'readIntBE'    : null
-    , 'readIntLE'    : null
-    , 'readUIntBE'   : null
-    , 'readUIntLE'   : null
-  }
-
-  for (var m in methods) {
+  const 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,
+    readIntBE: null,
+    readIntLE: null,
+    readUIntBE: null,
+    readUIntLE: null
+  }
+
+  for (const m in methods) {
     (function (m) {
       if (methods[m] === null) {
         BufferList.prototype[m] = function (offset, byteLength) {