bl 6.1.6 → 7.0.1

package/BufferList.js

@@ -1,421 +1,503 @@
-'use strict'
+import { Buffer } from 'node:buffer'
+
+/**
+ * @typedef {Buffer | BufferList | Uint8Array | Array<Buffer | BufferList | Uint8Array | string | number> | string | number} BufferListAcceptedTypes
+ */
 
-const { Buffer } = require('buffer')
 const symbol = Symbol.for('BufferList')
 
-function BufferList (buf) {
-  if (!(this instanceof BufferList)) {
-    return new BufferList(buf)
+export class BufferList {
+  /** @param {BufferListAcceptedTypes} [buf] */
+  constructor (buf) {
+    /** @type {Buffer[]} */
+    this._bufs = []
+    /** @type {number} */
+    this.length = 0
+    Object.defineProperty(this, symbol, { value: true })
+    if (buf) {
+      this.append(buf)
+    }
   }
 
-  BufferList._init.call(this, buf)
-}
-
-BufferList._init = function _init (buf) {
-  Object.defineProperty(this, symbol, { value: true })
-
-  this._bufs = []
-  this.length = 0
-
-  if (buf) {
-    this.append(buf)
+  /** @param {BufferListAcceptedTypes} [buf] */
+  _new (buf) {
+    return new BufferList(buf)
   }
-}
 
-BufferList.prototype._new = function _new (buf) {
-  return new BufferList(buf)
-}
-
-BufferList.prototype._offset = function _offset (offset) {
-  if (offset === 0) {
-    return [0, 0]
-  }
+  /**
+   * @param {number} offset
+   * @returns {[number, number]}
+   */
+  _offset (offset) {
+    if (offset === 0 || this._bufs.length === 0) {
+      return [0, 0]
+    }
 
-  let tot = 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]
+    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
     }
-    tot = _t
-  }
-}
-
-BufferList.prototype._reverseOffset = function (blOffset) {
-  const bufferId = blOffset[0]
-  let offset = blOffset[1]
 
-  for (let i = 0; i < bufferId; i++) {
-    offset += this._bufs[i].length
+    return [0, 0]
   }
 
-  return offset
-}
+  /**
+   * @param {[number, number]} blOffset
+   * @returns {number}
+   */
+  _reverseOffset (blOffset) {
+    const bufferId = blOffset[0]
+    let offset = blOffset[1]
 
-BufferList.prototype.getBuffers = function getBuffers () {
-  return this._bufs
-}
+    for (let i = 0; i < bufferId; i++) {
+      offset += this._bufs[i].length
+    }
 
-BufferList.prototype.get = function get (index) {
-  if (index > this.length || index < 0) {
-    return undefined
+    return offset
   }
 
-  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) {
-    start += this.length
+  /** @returns {Buffer[]} */
+  getBuffers () {
+    return this._bufs
   }
 
-  if (typeof end === 'number' && end < 0) {
-    end += this.length
-  }
+  /**
+   * @param {number} index
+   * @returns {number | undefined}
+   */
+  get (index) {
+    if (index > this.length || index < 0) {
+      return undefined
+    }
 
-  return this.copy(null, 0, start, end)
-}
+    const offset = this._offset(index)
 
-BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
-  if (typeof srcStart !== 'number' || srcStart < 0) {
-    srcStart = 0
+    return this._bufs[offset[0]][offset[1]]
   }
 
-  if (typeof srcEnd !== 'number' || srcEnd > this.length) {
-    srcEnd = this.length
-  }
+  /**
+   * @param {number} [start]
+   * @param {number} [end]
+   * @returns {Buffer}
+   */
+  slice (start, end) {
+    if (typeof start === 'number' && start < 0) {
+      start += this.length
+    }
 
-  if (srcStart >= this.length) {
-    return dst || Buffer.alloc(0)
-  }
+    if (typeof end === 'number' && end < 0) {
+      end += this.length
+    }
 
-  if (srcEnd <= 0) {
-    return dst || Buffer.alloc(0)
+    return this.copy(null, 0, start, end)
   }
 
-  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
-      return this._bufs.length === 1
-        ? this._bufs[0]
-        : Buffer.concat(this._bufs, this.length)
+  /**
+   * @param {Buffer | null} dst
+   * @param {number} [dstStart]
+   * @param {number} [srcStart]
+   * @param {number} [srcEnd]
+   * @returns {Buffer}
+   */
+  copy (dst, dstStart, srcStart, srcEnd) {
+    if (typeof srcStart !== 'number' || srcStart < 0) {
+      srcStart = 0
     }
 
-    // copy, need to copy individual buffers
-    for (let i = 0; i < this._bufs.length; i++) {
-      this._bufs[i].copy(dst, bufoff)
-      bufoff += this._bufs[i].length
+    if (typeof srcEnd !== 'number' || srcEnd > this.length) {
+      srcEnd = this.length
     }
 
-    return dst
-  }
+    if (srcStart >= this.length) {
+      return dst || Buffer.alloc(0)
+    }
 
-  // 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 (srcEnd <= 0) {
+      return dst || Buffer.alloc(0)
+    }
 
-  if (!copy) {
-    // a slice, we need something to copy in to
-    dst = Buffer.allocUnsafe(len)
-  }
+    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
+        return this._bufs.length === 1
+          ? this._bufs[0]
+          : Buffer.concat(/** @type {any} */ (this._bufs), this.length)
+      }
 
-  for (let i = off[0]; i < this._bufs.length; i++) {
-    const l = this._bufs[i].length - start
+      // copy, need to copy individual buffers
+      const d = /** @type {any} */ (dst)
+      for (let i = 0; i < this._bufs.length; i++) {
+        this._bufs[i].copy(d, bufoff)
+        bufoff += this._bufs[i].length
+      }
 
-    if (bytes > l) {
-      this._bufs[i].copy(dst, bufoff, start)
-      bufoff += l
-    } else {
-      this._bufs[i].copy(dst, bufoff, start, start + bytes)
-      bufoff += l
-      break
+      return d
     }
 
-    bytes -= l
+    // easy, cheap case where it's a subset of one of the buffers
+    if (bytes <= this._bufs[off[0]].length - start) {
+      if (!copy) {
+        return this._bufs[off[0]].slice(start, start + bytes)
+      }
+      this._bufs[off[0]].copy(/** @type {any} */ (dst), dstStart, start, start + bytes)
+      return /** @type {Buffer} */ (dst)
+    }
 
-    if (start) {
-      start = 0
+    if (!copy) {
+      // a slice, we need something to copy in to
+      dst = Buffer.allocUnsafe(len)
     }
-  }
 
-  // safeguard so that we don't return uninitialized memory
-  if (dst.length > bufoff) return dst.slice(0, bufoff)
+    const target = /** @type {any} */ (dst)
 
-  return dst
-}
+    for (let i = off[0]; i < this._bufs.length; i++) {
+      const l = this._bufs[i].length - start
 
-BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
-  start = start || 0
-  end = typeof end !== 'number' ? this.length : end
+      if (bytes > l) {
+        this._bufs[i].copy(target, bufoff, start)
+        bufoff += l
+      } else {
+        this._bufs[i].copy(target, bufoff, start, start + bytes)
+        bufoff += l
+        break
+      }
 
-  if (start < 0) {
-    start += this.length
-  }
+      bytes -= l
 
-  if (end < 0) {
-    end += this.length
-  }
+      if (start) {
+        start = 0
+      }
+    }
+
+    // safeguard so that we don't return uninitialized memory
+    if (target.length > bufoff) return target.slice(0, bufoff)
 
-  if (start === end) {
-    return this._new()
+    return target
   }
 
-  const startOffset = this._offset(start)
-  const endOffset = this._offset(end)
-  const buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
+  /**
+   * @param {number} [start]
+   * @param {number} [end]
+   * @returns {BufferList}
+   */
+  shallowSlice (start, end) {
+    start = start || 0
+    end = typeof end !== 'number' ? this.length : end
 
-  if (endOffset[1] === 0) {
-    buffers.pop()
-  } else {
-    buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])
-  }
+    if (start < 0) {
+      start += this.length
+    }
 
-  if (startOffset[1] !== 0) {
-    buffers[0] = buffers[0].slice(startOffset[1])
-  }
+    if (end < 0) {
+      end += this.length
+    }
 
-  return this._new(buffers)
-}
+    if (start === end) {
+      return this._new()
+    }
 
-BufferList.prototype.toString = function toString (encoding, start, end) {
-  return this.slice(start, end).toString(encoding)
-}
+    const startOffset = this._offset(start)
+    const endOffset = this._offset(end)
+    const buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
 
-BufferList.prototype.consume = function consume (bytes) {
-  // first, normalize the argument, in accordance with how Buffer does it
-  bytes = Math.trunc(bytes)
-  // do nothing if not a positive number
-  if (Number.isNaN(bytes) || bytes <= 0) return this
-
-  while (this._bufs.length) {
-    if (bytes >= this._bufs[0].length) {
-      bytes -= this._bufs[0].length
-      this.length -= this._bufs[0].length
-      this._bufs.shift()
+    if (endOffset[1] === 0) {
+      buffers.pop()
     } else {
-      this._bufs[0] = this._bufs[0].slice(bytes)
-      this.length -= bytes
-      break
+      buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])
     }
-  }
 
-  return this
-}
+    if (startOffset[1] !== 0) {
+      buffers[0] = buffers[0].slice(startOffset[1])
+    }
 
-BufferList.prototype.duplicate = function duplicate () {
-  const copy = this._new()
+    return this._new(buffers)
+  }
+
+  /**
+   * @param {BufferEncoding} [encoding]
+   * @param {number} [start]
+   * @param {number} [end]
+   * @returns {string}
+   */
+  toString (encoding, start, end) {
+    return this.slice(start, end).toString(encoding)
+  }
+
+  /**
+   * @param {number} bytes
+   * @returns {this}
+   */
+  consume (bytes) {
+    // first, normalize the argument, in accordance with how Buffer does it
+    bytes = Math.trunc(bytes)
+    // do nothing if not a positive number
+    if (Number.isNaN(bytes) || bytes <= 0) return this
+
+    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
+      }
+    }
 
-  for (let i = 0; i < this._bufs.length; i++) {
-    copy.append(this._bufs[i])
+    return this
   }
 
-  return copy
-}
+  /** @returns {BufferList} */
+  duplicate () {
+    const copy = this._new()
 
-BufferList.prototype.append = function append (buf) {
-  return this._attach(buf, BufferList.prototype._appendBuffer)
-}
+    for (let i = 0; i < this._bufs.length; i++) {
+      copy.append(this._bufs[i])
+    }
 
-BufferList.prototype.prepend = function prepend (buf) {
-  return this._attach(buf, BufferList.prototype._prependBuffer, true)
-}
+    return copy
+  }
 
-BufferList.prototype._attach = function _attach (buf, attacher, prepend) {
-  if (buf == null) {
-    return this
+  /**
+   * @param {BufferListAcceptedTypes} buf
+   * @returns {this}
+   */
+  append (buf) {
+    return this._attach(buf, BufferList.prototype._appendBuffer)
   }
 
-  if (buf.buffer) {
-    // append/prepend a view of the underlying ArrayBuffer
-    attacher.call(this, Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength))
-  } else if (Array.isArray(buf)) {
-    const [starting, modifier] = prepend ? [buf.length - 1, -1] : [0, 1]
+  /**
+   * @param {BufferListAcceptedTypes} buf
+   * @returns {this}
+   */
+  prepend (buf) {
+    return this._attach(buf, BufferList.prototype._prependBuffer, true)
+  }
 
-    for (let i = starting; i >= 0 && i < buf.length; i += modifier) {
-      this._attach(buf[i], attacher, prepend)
+  /**
+   * @param {BufferListAcceptedTypes} buf
+   * @param {(this: BufferList, buf: Buffer) => void} attacher
+   * @param {boolean} [prepend]
+   * @returns {this}
+   */
+  _attach (buf, attacher, prepend) {
+    if (buf == null) {
+      return this
     }
-  } else if (this._isBufferList(buf)) {
-    // unwrap argument into individual BufferLists
-    const [starting, modifier] = prepend ? [buf._bufs.length - 1, -1] : [0, 1]
 
-    for (let i = starting; i >= 0 && i < buf._bufs.length; i += modifier) {
-      this._attach(buf._bufs[i], attacher, prepend)
-    }
-  } else {
-    // coerce number arguments to strings, since Buffer(number) does
-    // uninitialized memory allocation
-    if (typeof buf === 'number') {
-      buf = buf.toString()
-    }
+    if (typeof buf === 'object' && 'buffer' in buf) {
+      // append/prepend a view of the underlying ArrayBuffer
+      const view = /** @type {Uint8Array} */ (buf)
+      attacher.call(this, Buffer.from(view.buffer, view.byteOffset, view.byteLength))
+    } else if (Array.isArray(buf)) {
+      const [starting, modifier] = prepend ? [buf.length - 1, -1] : [0, 1]
 
-    attacher.call(this, Buffer.from(buf))
-  }
+      for (let i = starting; i >= 0 && i < buf.length; i += modifier) {
+        this._attach(buf[i], attacher, prepend)
+      }
+    } else if (this._isBufferList(buf)) {
+      // unwrap argument into individual BufferLists
+      const [starting, modifier] = prepend ? [buf._bufs.length - 1, -1] : [0, 1]
 
-  return this
-}
+      for (let i = starting; i >= 0 && i < buf._bufs.length; i += modifier) {
+        this._attach(buf._bufs[i], attacher, prepend)
+      }
+    } else {
+      // coerce number arguments to strings, since Buffer(number) does
+      // uninitialized memory allocation
+      if (typeof buf === 'number') {
+        buf = buf.toString()
+      }
 
-BufferList.prototype._appendBuffer = function appendBuffer (buf) {
-  this._bufs.push(buf)
-  this.length += buf.length
-}
+      attacher.call(this, Buffer.from(/** @type {string} */ (buf)))
+    }
 
-BufferList.prototype._prependBuffer = function prependBuffer (buf) {
-  this._bufs.unshift(buf)
-  this.length += buf.length
-}
+    return this
+  }
 
-BufferList.prototype.indexOf = function (search, offset, encoding) {
-  if (encoding === undefined && typeof offset === 'string') {
-    encoding = offset
-    offset = undefined
+  /** @param {Buffer} buf */
+  _appendBuffer (buf) {
+    this._bufs.push(buf)
+    this.length += buf.length
   }
 
-  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') {
-    search = Buffer.from([search])
-  } else if (typeof search === 'string') {
-    search = Buffer.from(search, encoding)
-  } else if (this._isBufferList(search)) {
-    search = search.slice()
-  } else if (Array.isArray(search.buffer)) {
-    search = Buffer.from(search.buffer, search.byteOffset, search.byteLength)
-  } else if (!Buffer.isBuffer(search)) {
-    search = Buffer.from(search)
+  /** @param {Buffer} buf */
+  _prependBuffer (buf) {
+    this._bufs.unshift(buf)
+    this.length += buf.length
   }
 
-  offset = Number(offset || 0)
+  /**
+   * @param {string | number | Buffer | BufferList | Uint8Array} search
+   * @param {number | string} [offset]
+   * @param {BufferEncoding} [encoding]
+   * @returns {number}
+   */
+  indexOf (search, offset, encoding) {
+    if (encoding === undefined && typeof offset === 'string') {
+      encoding = /** @type {BufferEncoding} */ (offset)
+      offset = undefined
+    }
 
-  if (isNaN(offset)) {
-    offset = 0
-  }
+    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') {
+      search = Buffer.from([search])
+    } else if (typeof search === 'string') {
+      search = Buffer.from(search, encoding)
+    } else if (this._isBufferList(search)) {
+      search = search.slice()
+    } else if (Array.isArray(/** @type {any} */ (search).buffer)) {
+      search = Buffer.from(/** @type {any} */ (search).buffer, /** @type {any} */ (search).byteOffset, /** @type {any} */ (search).byteLength)
+    } else if (!Buffer.isBuffer(search)) {
+      search = Buffer.from(/** @type {any} */ (search))
+    }
 
-  if (offset < 0) {
-    offset = this.length + offset
-  }
+    offset = Number(offset || 0)
 
-  if (offset < 0) {
-    offset = 0
-  }
+    if (isNaN(offset)) {
+      offset = 0
+    }
 
-  if (search.length === 0) {
-    return offset > this.length ? this.length : offset
-  }
+    if (offset < 0) {
+      offset = this.length + offset
+    }
 
-  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
+    if (offset < 0) {
+      offset = 0
+    }
 
-  // scan over each buffer
-  for (; blIndex < this._bufs.length; blIndex++) {
-    const buff = this._bufs[blIndex]
+    if (search.length === 0) {
+      return offset > this.length ? this.length : offset
+    }
 
-    while (buffOffset < buff.length) {
-      const availableWindow = buff.length - buffOffset
+    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
 
-      if (availableWindow >= search.length) {
-        const nativeSearchResult = buff.indexOf(search, buffOffset)
+    // scan over each buffer
+    for (; blIndex < this._bufs.length; blIndex++) {
+      const buff = this._bufs[blIndex]
 
-        if (nativeSearchResult !== -1) {
-          return this._reverseOffset([blIndex, nativeSearchResult])
-        }
+      while (buffOffset < buff.length) {
+        const availableWindow = buff.length - buffOffset
 
-        buffOffset = buff.length - search.length + 1 // end of native search window
-      } else {
-        const revOffset = this._reverseOffset([blIndex, buffOffset])
+        if (availableWindow >= search.length) {
+          const nativeSearchResult = buff.indexOf(/** @type {any} */ (search), buffOffset)
 
-        if (this._match(revOffset, search)) {
-          return revOffset
-        }
+          if (nativeSearchResult !== -1) {
+            return this._reverseOffset([blIndex, nativeSearchResult])
+          }
 
-        buffOffset++
-      }
-    }
+          buffOffset = buff.length - search.length + 1 // end of native search window
+        } else {
+          const revOffset = this._reverseOffset([blIndex, buffOffset])
 
-    buffOffset = 0
-  }
+          if (this._match(revOffset, search)) {
+            return revOffset
+          }
 
-  return -1
-}
+          buffOffset++
+        }
+      }
 
-BufferList.prototype._match = function (offset, search) {
-  if (this.length - offset < search.length) {
-    return false
+      buffOffset = 0
+    }
+
+    return -1
   }
 
-  for (let searchOffset = 0; searchOffset < search.length; searchOffset++) {
-    if (this.get(offset + searchOffset) !== search[searchOffset]) {
+  /**
+   * @param {number} offset
+   * @param {Buffer | Uint8Array} search
+   * @returns {boolean}
+   */
+  _match (offset, search) {
+    if (this.length - offset < search.length) {
       return false
     }
+
+    for (let searchOffset = 0; searchOffset < search.length; searchOffset++) {
+      if (this.get(offset + searchOffset) !== search[searchOffset]) {
+        return false
+      }
+    }
+    return true
   }
-  return true
-}
 
-;(function () {
-  const methods = {
-    readDoubleBE: 8,
-    readDoubleLE: 8,
-    readFloatBE: 4,
-    readFloatLE: 4,
-    readBigInt64BE: 8,
-    readBigInt64LE: 8,
-    readBigUInt64BE: 8,
-    readBigUInt64LE: 8,
-    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
+  // Used internally by the class and also as an indicator of this object being
+  // a `BufferList`. It's not possible to use `instanceof BufferList` in a browser
+  // environment because there could be multiple different copies of the
+  // BufferList class and some `BufferList`s might be `BufferList`s.
+  /**
+   * @param {any} b
+   * @returns {b is BufferList}
+   */
+  _isBufferList (b) {
+    return b instanceof BufferList || BufferList.isBufferList(b)
   }
 
-  for (const m in methods) {
-    (function (m) {
-      if (methods[m] === null) {
-        BufferList.prototype[m] = function (offset, byteLength) {
-          return this.slice(offset, offset + byteLength)[m](0, byteLength)
-        }
-      } else {
-        BufferList.prototype[m] = function (offset = 0) {
-          return this.slice(offset, offset + methods[m])[m](0)
-        }
-      }
-    }(m))
+  /**
+   * @param {any} b
+   * @returns {boolean}
+   */
+  static isBufferList (b) {
+    return b != null && b[symbol]
   }
-}())
-
-// Used internally by the class and also as an indicator of this object being
-// a `BufferList`. It's not possible to use `instanceof BufferList` in a browser
-// environment because there could be multiple different copies of the
-// BufferList class and some `BufferList`s might be `BufferList`s.
-BufferList.prototype._isBufferList = function _isBufferList (b) {
-  return b instanceof BufferList || BufferList.isBufferList(b)
 }
 
-BufferList.isBufferList = function isBufferList (b) {
-  return b != null && b[symbol]
+// Add all the Buffer read methods
+/** @type {Record<string, number | null>} */
+const methods = {
+  readDoubleBE: 8,
+  readDoubleLE: 8,
+  readFloatBE: 4,
+  readFloatLE: 4,
+  readBigInt64BE: 8,
+  readBigInt64LE: 8,
+  readBigUInt64BE: 8,
+  readBigUInt64LE: 8,
+  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) {
+  const size = methods[m]
+  if (size === null) {
+    /** @type {any} */ (BufferList.prototype)[m] = function (/** @type {number} */ offset, /** @type {number} */ byteLength) {
+      return /** @type {any} */ (this.slice(offset, offset + byteLength))[m](0, byteLength)
+    }
+  } else {
+    /** @type {any} */ (BufferList.prototype)[m] = function (/** @type {number} */ offset = 0) {
+      return /** @type {any} */ (this.slice(offset, offset + size))[m](0)
+    }
+  }
 }
 
-module.exports = BufferList
+export default BufferList