@ohos-ports/bare-buffer 3.7.1-beta.0

package/index.js

@@ -0,0 +1,1339 @@
+const constants = require('./lib/constants')
+const ascii = require('./lib/ascii')
+const base64 = require('./lib/base64')
+const base64url = require('./lib/base64url')
+const hex = require('./lib/hex')
+const utf8 = require('./lib/utf8')
+const utf16le = require('./lib/utf16le')
+const latin1 = require('./lib/latin1')
+const binding = require('./binding')
+const checked = require('./lib/checked')
+
+const kind = Symbol.for('bare.buffer.kind')
+
+const SWAP_MIN_LENGTH = 128
+
+let poolSize = 65536
+let pool = null
+let poolLength = 0
+let poolOffset = 0
+
+class Buffer extends Uint8Array {
+  static get [kind]() {
+    return 0 // Compatibility version
+  }
+
+  static get poolSize() {
+    return poolSize
+  }
+
+  static set poolSize(value) {
+    assertSize(value, 'Pool size')
+
+    poolSize = value
+  }
+
+  constructor(arrayBuffer, offset, length, opts = {}) {
+    if (typeof arrayBuffer === 'number') {
+      opts = offset || {}
+
+      const { uninitialized = false } = opts
+
+      offset = 0
+      length = arrayBuffer
+
+      if (Number.isInteger(length) === false || length < 0 || length > constants.MAX_LENGTH) {
+        throw new RangeError(
+          `Buffer length must be an integer between 0 and ${constants.MAX_LENGTH}`
+        )
+      }
+
+      arrayBuffer = uninitialized ? binding.allocUnsafe(length) : binding.alloc(length)
+    } else {
+      if (typeof offset === 'number') assertInteger(offset, 'Offset')
+      if (typeof length === 'number') assertInteger(length, 'Length')
+
+      if (length > constants.MAX_LENGTH) {
+        throw new RangeError(`Buffer length must be at most ${constants.MAX_LENGTH}`)
+      }
+
+      if (typeof offset === 'object' && offset !== null) {
+        opts = offset
+        offset = 0
+        length = arrayBuffer.byteLength
+      } else if (typeof length === 'object' && length !== null) {
+        opts = length
+        length = arrayBuffer.byteLength - offset
+      }
+    }
+
+    super(arrayBuffer, offset, length)
+  }
+
+  get [kind]() {
+    return Buffer[kind]
+  }
+
+  copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.byteLength) {
+    const source = this
+
+    assertView(target, 'Target')
+
+    assertSize(targetStart, 'Target start')
+    assertSize(sourceStart, 'Source start')
+    assertSize(sourceEnd, 'Source end')
+
+    if (target.BYTES_PER_ELEMENT !== 1) {
+      target = new Uint8Array(target.buffer, target.byteOffset, target.byteLength)
+    }
+
+    const sourceLength = source.byteLength
+    const targetLength = target.byteLength
+
+    if (sourceStart > sourceLength) {
+      throw new RangeError(`Source start must be at most ${sourceLength}`)
+    }
+
+    if (targetStart >= targetLength) return 0
+
+    if (sourceEnd > sourceLength) sourceEnd = sourceLength
+    if (sourceEnd <= sourceStart) return 0
+
+    const room = targetLength - targetStart
+
+    if (sourceEnd - sourceStart > room) sourceEnd = sourceStart + room
+
+    const length = sourceEnd - sourceStart
+
+    if (source === target) {
+      target.copyWithin(targetStart, sourceStart, sourceEnd)
+    } else if (sourceStart === 0 && sourceEnd === sourceLength) {
+      target.set(source, targetStart)
+    } else {
+      target.set(
+        new Uint8Array(source.buffer, source.byteOffset + sourceStart, length),
+        targetStart
+      )
+    }
+
+    return length
+  }
+
+  equals(target) {
+    const source = this
+
+    if (source === target) return true
+
+    assertView(target, 'Target')
+
+    const sourceLength = source.byteLength
+    const targetLength = target.byteLength
+
+    if (sourceLength !== targetLength) return false
+
+    return (
+      checked(
+        binding.compare(
+          source.buffer,
+          source.byteOffset,
+          sourceLength,
+          target.buffer,
+          target.byteOffset,
+          targetLength
+        )
+      ) === 0
+    )
+  }
+
+  compare(
+    target,
+    targetStart = 0,
+    targetEnd = target.byteLength,
+    sourceStart = 0,
+    sourceEnd = this.byteLength
+  ) {
+    const source = this
+
+    if (source === target) return 0
+
+    assertView(target, 'Target')
+
+    const sourceLength = source.byteLength
+    const targetLength = target.byteLength
+
+    if (arguments.length === 1) {
+      targetStart = 0
+      targetEnd = targetLength
+      sourceStart = 0
+      sourceEnd = sourceLength
+    } else {
+      assertInteger(targetStart, 'Target start')
+      assertInteger(targetEnd, 'Target end')
+      assertInteger(sourceStart, 'Source start')
+      assertInteger(sourceEnd, 'Source end')
+
+      if (targetStart < 0) targetStart = 0
+      if (targetStart > targetLength) targetStart = targetLength
+
+      if (targetEnd < targetStart) targetEnd = targetStart
+      if (targetEnd > targetLength) targetEnd = targetLength
+
+      if (sourceStart < 0) sourceStart = 0
+      if (sourceStart > sourceLength) sourceStart = sourceLength
+
+      if (sourceEnd < sourceStart) sourceEnd = sourceStart
+      if (sourceEnd > sourceLength) sourceEnd = sourceLength
+    }
+
+    return checked(
+      binding.compare(
+        source.buffer,
+        source.byteOffset + sourceStart,
+        sourceEnd - sourceStart,
+        target.buffer,
+        target.byteOffset + targetStart,
+        targetEnd - targetStart
+      )
+    )
+  }
+
+  fill(value, offset = 0, end = this.byteLength, encoding = 'utf8') {
+    if (typeof value === 'string') {
+      if (typeof offset === 'string') {
+        // fill(string, encoding)
+        encoding = offset
+        offset = 0
+        end = this.byteLength
+      } else if (typeof end === 'string') {
+        // fill(string, offset, encoding)
+        encoding = end
+        end = this.byteLength
+      }
+    } else if (typeof value === 'number') {
+      value = value & 0xff
+    } else if (typeof value === 'boolean') {
+      value = +value
+    } else if (ArrayBuffer.isView(value)) {
+      if (value.BYTES_PER_ELEMENT !== 1) {
+        value = new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+      }
+    } else {
+      throw new TypeError(
+        `Fill value must be a number, a string or a view, received type ${typeof value}`
+      )
+    }
+
+    assertInteger(offset, 'Offset')
+    assertInteger(end, 'End')
+
+    const byteLength = this.byteLength
+
+    if (offset < 0) offset = 0
+    if (offset >= byteLength) return this
+
+    if (end <= offset) return this
+    if (end > byteLength) end = byteLength
+
+    if (typeof value === 'number') return super.fill(value, offset, end)
+
+    if (typeof value === 'string') value = exports.from(value, encoding)
+
+    const length = value.byteLength
+
+    if (length === 0) return super.fill(0, offset, end)
+    if (length === 1) return super.fill(value[0], offset, end)
+
+    return fillPattern(this, value, length, offset, end)
+  }
+
+  includes(value, offset, encoding) {
+    return this.indexOf(value, offset, encoding) !== -1
+  }
+
+  indexOf(value, offset = 0, encoding) {
+    if (typeof offset === 'number') assertInteger(offset, 'Offset')
+
+    if (typeof value === 'boolean') value = +value
+
+    if (typeof value === 'number') {
+      return super.indexOf(value & 0xff, offset)
+    }
+
+    return bidirectionalIndexOf(this, value, offset, encoding, true /* first */)
+  }
+
+  lastIndexOf(value, offset = this.byteLength - 1, encoding) {
+    if (typeof offset === 'number') assertInteger(offset, 'Offset')
+
+    if (typeof value === 'boolean') value = +value
+
+    if (typeof value === 'number') {
+      return super.lastIndexOf(value & 0xff, offset)
+    }
+
+    return bidirectionalIndexOf(this, value, offset, encoding, false /* last */)
+  }
+
+  swap16() {
+    const length = this.byteLength
+
+    if (length % 2 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 16-bits')
+    }
+
+    if (length < SWAP_MIN_LENGTH) {
+      for (let i = 0; i < length; i += 2) swap(this, i, i + 1)
+    } else {
+      checked(binding.swap16(this.buffer, this.byteOffset, length))
+    }
+
+    return this
+  }
+
+  swap32() {
+    const length = this.byteLength
+
+    if (length % 4 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 32-bits')
+    }
+
+    if (length < SWAP_MIN_LENGTH) {
+      for (let i = 0; i < length; i += 4) {
+        swap(this, i, i + 3)
+        swap(this, i + 1, i + 2)
+      }
+    } else {
+      checked(binding.swap32(this.buffer, this.byteOffset, length))
+    }
+
+    return this
+  }
+
+  swap64() {
+    const length = this.byteLength
+
+    if (length % 8 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 64-bits')
+    }
+
+    if (length < SWAP_MIN_LENGTH) {
+      for (let i = 0; i < length; 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)
+      }
+    } else {
+      checked(binding.swap64(this.buffer, this.byteOffset, length))
+    }
+
+    return this
+  }
+
+  toString(encoding = 'utf8', start = 0, end = this.byteLength) {
+    // toString()
+    if (arguments.length === 0) return utf8.toString(this)
+
+    // toString(encoding)
+    if (arguments.length === 1) return codecFor(encoding).toString(this)
+
+    assertInteger(start, 'Start')
+    assertInteger(end, 'End')
+
+    const length = this.byteLength
+
+    if (start < 0) start = 0
+    if (start >= length) return ''
+
+    if (end <= start) return ''
+    if (end > length) end = length
+
+    return codecFor(encoding).toString(this, start, end)
+  }
+
+  toJSON() {
+    const length = this.byteLength
+    const data = new Array(length)
+
+    for (let i = 0; i < length; i++) data[i] = this[i]
+
+    return data
+  }
+
+  write(string, offset = 0, length = this.byteLength - offset, encoding = 'utf8') {
+    assertString(string, 'String')
+
+    // write(string)
+    if (arguments.length === 1) return utf8.write(this, string)
+
+    if (typeof offset === 'string') {
+      // write(string, encoding)
+      encoding = offset
+      offset = 0
+      length = this.byteLength
+    } else if (typeof length === 'string') {
+      // write(string, offset, encoding)
+      encoding = length
+      length = this.byteLength - offset
+    }
+
+    assertInteger(offset, 'Offset')
+    assertInteger(length, 'Length')
+
+    length = Math.min(length, exports.byteLength(string, encoding))
+
+    const byteLength = this.byteLength
+
+    let start = offset
+    if (start < 0) start = 0
+    if (start >= byteLength) return 0
+
+    let end = offset + length
+    if (end <= start) return 0
+    if (end > byteLength) end = byteLength
+
+    return codecFor(encoding).write(this, string, start, end)
+  }
+
+  readBigInt64BE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getBigInt64(offset, false)
+  }
+  readBigInt64LE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getBigInt64(offset, true)
+  }
+
+  readBigUint64BE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getBigUint64(offset, false)
+  }
+  readBigUint64LE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getBigUint64(offset, true)
+  }
+
+  readDoubleBE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getFloat64(offset, false)
+  }
+  readDoubleLE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getFloat64(offset, true)
+  }
+
+  readFloatBE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getFloat32(offset, false)
+  }
+  readFloatLE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    return viewOf(this).getFloat32(offset, true)
+  }
+
+  readInt8(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const value = this[offset]
+    if (value === undefined) boundsError()
+    return (value << 24) >> 24
+  }
+
+  readInt16BE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 1]
+    if (first === undefined || last === undefined) boundsError()
+    return (((first << 8) | last) << 16) >> 16
+  }
+  readInt16LE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 1]
+    if (first === undefined || last === undefined) boundsError()
+    return (((last << 8) | first) << 16) >> 16
+  }
+
+  readInt32BE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 3]
+    if (first === undefined || last === undefined) boundsError()
+    return (first << 24) | (this[offset + 1] << 16) | (this[offset + 2] << 8) | last
+  }
+  readInt32LE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 3]
+    if (first === undefined || last === undefined) boundsError()
+    return first | (this[offset + 1] << 8) | (this[offset + 2] << 16) | (last << 24)
+  }
+
+  readIntBE(offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return readInt48BE(this, offset)
+    if (byteLength === 5) return readInt40BE(this, offset)
+    if (byteLength === 3) return readInt24BE(this, offset)
+    if (byteLength === 4) return this.readInt32BE(offset)
+    if (byteLength === 2) return this.readInt16BE(offset)
+    if (byteLength === 1) return this.readInt8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  readIntLE(offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return readInt48LE(this, offset)
+    if (byteLength === 5) return readInt40LE(this, offset)
+    if (byteLength === 3) return readInt24LE(this, offset)
+    if (byteLength === 4) return this.readInt32LE(offset)
+    if (byteLength === 2) return this.readInt16LE(offset)
+    if (byteLength === 1) return this.readInt8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  readUint8(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const value = this[offset]
+    if (value === undefined) boundsError()
+    return value
+  }
+
+  readUint16BE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 1]
+    if (first === undefined || last === undefined) boundsError()
+    return (first << 8) | last
+  }
+  readUint16LE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 1]
+    if (first === undefined || last === undefined) boundsError()
+    return (last << 8) | first
+  }
+
+  readUint32BE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 3]
+    if (first === undefined || last === undefined) boundsError()
+    return first * 0x1000000 + ((this[offset + 1] << 16) | (this[offset + 2] << 8) | last)
+  }
+  readUint32LE(offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    const first = this[offset]
+    const last = this[offset + 3]
+    if (first === undefined || last === undefined) boundsError()
+    return last * 0x1000000 + ((this[offset + 2] << 16) | (this[offset + 1] << 8) | first)
+  }
+
+  readUintBE(offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return readUint48BE(this, offset)
+    if (byteLength === 5) return readUint40BE(this, offset)
+    if (byteLength === 3) return readUint24BE(this, offset)
+    if (byteLength === 4) return this.readUint32BE(offset)
+    if (byteLength === 2) return this.readUint16BE(offset)
+    if (byteLength === 1) return this.readUint8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  readUintLE(offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return readUint48LE(this, offset)
+    if (byteLength === 5) return readUint40LE(this, offset)
+    if (byteLength === 3) return readUint24LE(this, offset)
+    if (byteLength === 4) return this.readUint32LE(offset)
+    if (byteLength === 2) return this.readUint16LE(offset)
+    if (byteLength === 1) return this.readUint8(offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  writeBigInt64BE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setBigInt64(offset, value, false)
+    return offset + 8
+  }
+  writeBigInt64LE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setBigInt64(offset, value, true)
+    return offset + 8
+  }
+
+  writeBigUint64BE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setBigUint64(offset, value, false)
+    return offset + 8
+  }
+  writeBigUint64LE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setBigUint64(offset, value, true)
+    return offset + 8
+  }
+
+  writeDoubleBE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setFloat64(offset, value, false)
+    return offset + 8
+  }
+  writeDoubleLE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setFloat64(offset, value, true)
+    return offset + 8
+  }
+
+  writeFloatBE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setFloat32(offset, value, false)
+    return offset + 4
+  }
+  writeFloatLE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    viewOf(this).setFloat32(offset, value, true)
+    return offset + 4
+  }
+
+  writeInt8(value, offset = 0) {
+    return this.writeUint8(value, offset)
+  }
+
+  writeInt16BE(value, offset = 0) {
+    return this.writeUint16BE(value, offset)
+  }
+  writeInt16LE(value, offset = 0) {
+    return this.writeUint16LE(value, offset)
+  }
+
+  writeInt32BE(value, offset = 0) {
+    return this.writeUint32BE(value, offset)
+  }
+  writeInt32LE(value, offset = 0) {
+    return this.writeUint32LE(value, offset)
+  }
+
+  writeIntBE(value, offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return writeInt48BE(this, value, offset)
+    if (byteLength === 5) return writeInt40BE(this, value, offset)
+    if (byteLength === 3) return writeInt24BE(this, value, offset)
+    if (byteLength === 4) return this.writeInt32BE(value, offset)
+    if (byteLength === 2) return this.writeInt16BE(value, offset)
+    if (byteLength === 1) return this.writeInt8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  writeIntLE(value, offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return writeInt48LE(this, value, offset)
+    if (byteLength === 5) return writeInt40LE(this, value, offset)
+    if (byteLength === 3) return writeInt24LE(this, value, offset)
+    if (byteLength === 4) return this.writeInt32LE(value, offset)
+    if (byteLength === 2) return this.writeInt16LE(value, offset)
+    if (byteLength === 1) return this.writeInt8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  writeUint8(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (this[offset] === undefined) boundsError()
+    this[offset] = value
+    return offset + 1
+  }
+
+  writeUint16BE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (this[offset] === undefined || this[offset + 1] === undefined) boundsError()
+    this[offset] = value >>> 8
+    this[offset + 1] = value
+    return offset + 2
+  }
+  writeUint16LE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (this[offset] === undefined || this[offset + 1] === undefined) boundsError()
+    this[offset] = value
+    this[offset + 1] = value >>> 8
+    return offset + 2
+  }
+
+  writeUint32LE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (this[offset] === undefined || this[offset + 3] === undefined) boundsError()
+    this[offset] = value
+    this[offset + 1] = value >>> 8
+    this[offset + 2] = value >>> 16
+    this[offset + 3] = value >>> 24
+    return offset + 4
+  }
+  writeUint32BE(value, offset = 0) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (this[offset] === undefined || this[offset + 3] === undefined) boundsError()
+    this[offset] = value >>> 24
+    this[offset + 1] = value >>> 16
+    this[offset + 2] = value >>> 8
+    this[offset + 3] = value
+    return offset + 4
+  }
+
+  writeUintBE(value, offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return writeUint48BE(this, value, offset)
+    if (byteLength === 5) return writeUint40BE(this, value, offset)
+    if (byteLength === 3) return writeUint24BE(this, value, offset)
+    if (byteLength === 4) return this.writeUint32BE(value, offset)
+    if (byteLength === 2) return this.writeUint16BE(value, offset)
+    if (byteLength === 1) return this.writeUint8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+
+  writeUintLE(value, offset, byteLength) {
+    if (!Number.isInteger(offset)) offsetError(offset)
+    if (byteLength === 6) return writeUint48LE(this, value, offset)
+    if (byteLength === 5) return writeUint40LE(this, value, offset)
+    if (byteLength === 3) return writeUint24LE(this, value, offset)
+    if (byteLength === 4) return this.writeUint32LE(value, offset)
+    if (byteLength === 2) return this.writeUint16LE(value, offset)
+    if (byteLength === 1) return this.writeUint8(value, offset)
+    throw new RangeError(`Byte length must be between 1 and 6`)
+  }
+}
+
+for (const [alias, name] of [
+  ['readBigUInt64BE', 'readBigUint64BE'],
+  ['readBigUInt64LE', 'readBigUint64LE'],
+  ['readUInt8', 'readUint8'],
+  ['readUInt16BE', 'readUint16BE'],
+  ['readUInt16LE', 'readUint16LE'],
+  ['readUInt32BE', 'readUint32BE'],
+  ['readUInt32LE', 'readUint32LE'],
+  ['readUIntBE', 'readUintBE'],
+  ['readUIntLE', 'readUintLE'],
+  ['writeBigUInt64BE', 'writeBigUint64BE'],
+  ['writeBigUInt64LE', 'writeBigUint64LE'],
+  ['writeUInt8', 'writeUint8'],
+  ['writeUInt16BE', 'writeUint16BE'],
+  ['writeUInt16LE', 'writeUint16LE'],
+  ['writeUInt32BE', 'writeUint32BE'],
+  ['writeUInt32LE', 'writeUint32LE'],
+  ['writeUIntBE', 'writeUintBE'],
+  ['writeUIntLE', 'writeUintLE']
+]) {
+  Object.defineProperty(Buffer.prototype, alias, {
+    value: Buffer.prototype[name],
+    writable: true,
+    configurable: true
+  })
+}
+
+module.exports = exports = Buffer
+
+exports.Buffer = Buffer // For Node.js compatibility
+
+exports.constants = constants
+
+const codecs = Object.create(null)
+
+codecs.ascii = ascii
+codecs.base64 = base64
+codecs.base64url = base64url
+codecs.hex = hex
+codecs.utf8 = codecs['utf-8'] = utf8
+codecs.utf16le = codecs.ucs2 = codecs['utf-16le'] = codecs['ucs-2'] = utf16le
+codecs.latin1 = codecs.binary = latin1
+
+function codecFor(encoding) {
+  if (encoding === undefined) return utf8
+
+  let codec = codecs[encoding]
+  if (codec !== undefined) return codec
+
+  if (typeof encoding !== 'string') {
+    throw new TypeError(`Encoding must be a string, received type ${typeof encoding}`)
+  }
+
+  codec = codecs[encoding.toLowerCase()]
+  if (codec !== undefined) return codec
+
+  throw new Error(`Unknown encoding '${encoding}'`)
+}
+
+const views = new WeakMap()
+
+function viewOf(buffer) {
+  let view = views.get(buffer)
+  if (view === undefined) {
+    const store = buffer.buffer
+
+    view = new DataView(store, buffer.byteOffset, buffer.byteLength)
+
+    // A view of a store that can still change size covers the wrong range as
+    // soon as it does, or falls out of bounds entirely, so it is only worth
+    // remembering one of a store that cannot.
+    if (store.resizable !== true && store.growable !== true) {
+      views.set(buffer, view)
+    }
+  }
+  return view
+}
+
+exports.isBuffer = function isBuffer(value) {
+  if (value instanceof Buffer) return true
+
+  return typeof value === 'object' && value !== null && value[kind] === Buffer[kind]
+}
+
+exports.isEncoding = function isEncoding(encoding) {
+  try {
+    codecFor(encoding)
+    return true
+  } catch {
+    return false
+  }
+}
+
+exports.isASCII = function isASCII(buffer) {
+  return ascii.validate(buffer)
+}
+
+// for Node.js compatibily
+exports.isAscii = exports.isASCII
+
+exports.isUTF8 = function isUTF8(buffer) {
+  return utf8.validate(buffer)
+}
+
+// for Node.js compatibility
+exports.isUtf8 = exports.isUTF8
+
+exports.alloc = function alloc(size, fill, encoding) {
+  assertSize(size, 'Size')
+
+  if (fill !== undefined && fill !== 0) {
+    const buffer = new Buffer(size, { uninitialized: true })
+
+    return buffer.fill(fill, 0, buffer.byteLength, encoding)
+  }
+
+  return new Buffer(size)
+}
+
+exports.allocUnsafe = function allocUnsafe(size) {
+  assertSize(size, 'Size')
+
+  return allocate(size)
+}
+
+exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
+  assertSize(size, 'Size')
+
+  return new Buffer(size, { uninitialized: true })
+}
+
+function assertInteger(value, name) {
+  if (typeof value !== 'number') {
+    throw new TypeError(`${name} must be a number, received type ${typeof value}`)
+  }
+
+  if (Number.isInteger(value) === false) {
+    throw new RangeError(`${name} must be an integer`)
+  }
+}
+
+function assertString(value, name) {
+  if (typeof value !== 'string') {
+    throw new TypeError(`${name} must be a string, received type ${typeof value}`)
+  }
+}
+
+function assertView(value, name) {
+  if (ArrayBuffer.isView(value) === false) {
+    throw new TypeError(`${name} must be a view, received type ${typeof value}`)
+  }
+}
+
+function assertSize(size, name) {
+  if (typeof size !== 'number') {
+    throw new TypeError(`${name} must be a number, received type ${typeof size}`)
+  }
+
+  if (Number.isInteger(size) === false || size < 0 || size > constants.MAX_LENGTH) {
+    throw new RangeError(`${name} must be an integer between 0 and ${constants.MAX_LENGTH}`)
+  }
+}
+
+exports.byteLength = function byteLength(string, encoding) {
+  if (typeof string === 'string') {
+    return codecFor(encoding).byteLength(string)
+  }
+
+  return string.byteLength
+}
+
+exports.compare = function compare(a, b) {
+  assertView(a, 'First buffer')
+  assertView(b, 'Second buffer')
+
+  return checked(
+    binding.compare(a.buffer, a.byteOffset, a.byteLength, b.buffer, b.byteOffset, b.byteLength)
+  )
+}
+
+exports.concat = function concat(buffers, length) {
+  const n = buffers.length
+
+  for (let i = 0; i < n; i++) {
+    const buffer = buffers[i]
+
+    if (ArrayBuffer.isView(buffer) === false || buffer.BYTES_PER_ELEMENT !== 1) {
+      throw new TypeError(`buffers[${i}] must be a view of single bytes`)
+    }
+  }
+
+  if (length === undefined) {
+    length = 0
+    for (let i = 0; i < n; i++) length += buffers[i].byteLength
+  } else {
+    assertSize(length, 'Length')
+  }
+
+  const result = allocate(length)
+
+  let offset = 0
+
+  for (let i = 0; i < n; i++) {
+    const buffer = buffers[i]
+    const buffered = buffer.byteLength
+
+    if (offset + buffered > length) {
+      const remaining = length - offset
+
+      result.set(new Uint8Array(buffer.buffer, buffer.byteOffset, remaining), offset)
+
+      offset = length
+      break
+    }
+
+    result.set(buffer, offset)
+    offset += buffered
+  }
+
+  // Only the bytes the inputs did not reach need initializing.
+  if (offset < length) result.fill(0, offset, length)
+
+  return result
+}
+
+exports.coerce = function coerce(buffer) {
+  if (exports.isBuffer(buffer)) return buffer
+  return new Buffer(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+}
+
+exports.copyBytesFrom = function copyBytesFrom(view, offset = 0, length = view.length - offset) {
+  assertSize(offset, 'Offset')
+  assertSize(length, 'Length')
+
+  if (offset + length > view.length) {
+    throw new RangeError('View length is out of range')
+  }
+
+  if (offset !== 0 || length !== view.length) {
+    view = view.subarray(offset, offset + length)
+  }
+
+  return new Buffer(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength))
+}
+
+exports.from = function from(value, encodingOrOffset, length) {
+  // from(string, encoding)
+  if (typeof value === 'string') return fromString(value, encodingOrOffset)
+
+  // from(array)
+  if (Array.isArray(value)) return fromArray(value)
+
+  // from(buffer)
+  if (ArrayBuffer.isView(value)) return fromBuffer(value)
+
+  // from(arrayBuffer[, offset[, length]])
+  return fromArrayBuffer(value, encodingOrOffset, length)
+}
+
+function fromString(string, encoding) {
+  const codec = codecFor(encoding)
+  const length = codec.byteLength(string)
+  const buffer = allocate(length)
+  const written = codec.write(buffer, string, 0, length)
+
+  // Some codecs only know an upper bound before encoding, and the remainder is
+  // uninitialized rather than zeroed.
+  if (written < length) return buffer.subarray(0, written)
+
+  return buffer
+}
+
+function fromArray(array) {
+  const buffer = allocate(array.length)
+  buffer.set(array)
+  return buffer
+}
+
+function fromBuffer(buffer) {
+  // A view is copied element wise, each element truncated to a byte, so the
+  // copy is sized by element count and not by byte length. A view that is not
+  // array like, such as a DataView, reports no length and has nothing to copy.
+  const length = typeof buffer.length === 'number' ? buffer.length : 0
+
+  const copy = allocate(length)
+  copy.set(buffer)
+  return copy
+}
+
+function fromArrayBuffer(arrayBuffer, offset, length) {
+  if (offset !== undefined) assertInteger(offset, 'Offset')
+  if (length !== undefined) assertInteger(length, 'Length')
+
+  return new Buffer(arrayBuffer, offset, length)
+}
+
+function bidirectionalIndexOf(buffer, value, offset, encoding, first) {
+  if (typeof value !== 'string') assertView(value, 'Value')
+
+  const length = buffer.byteLength
+
+  if (length === 0) return -1
+
+  if (typeof offset === 'string') {
+    encoding = offset
+    offset = 0
+  } else if (offset === undefined) {
+    offset = first ? 0 : length - 1
+  } else if (offset < 0) {
+    offset += length
+  }
+
+  if (offset >= length) {
+    if (first) return -1
+    else offset = length - 1
+  } else if (offset < 0) {
+    if (first) offset = 0
+    else return -1
+  }
+
+  if (typeof value === 'string') value = exports.from(value, encoding)
+
+  const needleLength = value.byteLength
+
+  if (needleLength === 0) return -1
+
+  const last = length - needleLength
+
+  if (first) {
+    if (offset > last) return -1
+  } else {
+    if (offset > last) offset = last
+    if (offset < 0) return -1
+  }
+
+  // Confirming a match at the position the search starts from costs a handful
+  // of comparisons, and keeps prefix checks off the native path entirely.
+  let j = 0
+  while (j < needleLength && buffer[offset + j] === value[j]) j++
+  if (j === needleLength) return offset
+
+  if (first) {
+    if (offset === last) return -1
+
+    return checked(
+      binding.indexOf(
+        buffer.buffer,
+        buffer.byteOffset,
+        length,
+        value.buffer,
+        value.byteOffset,
+        needleLength,
+        offset + 1
+      )
+    )
+  }
+
+  if (offset === 0) return -1
+
+  return checked(
+    binding.lastIndexOf(
+      buffer.buffer,
+      buffer.byteOffset,
+      length,
+      value.buffer,
+      value.byteOffset,
+      needleLength,
+      offset - 1
+    )
+  )
+}
+
+// Writes the pattern once and then repeatedly doubles it in place, so the byte
+// wise work is proportional to the pattern rather than to the range. Each block
+// copied is a whole number of periods, which keeps the pattern aligned.
+function fillPattern(buffer, value, length, offset, end) {
+  const n = end - offset
+
+  // Below this the copies cost more than they save.
+  if (n < 64) {
+    for (let i = 0; i < n; i++) buffer[offset + i] = value[i % length]
+    return buffer
+  }
+
+  let filled = length < n ? length : n
+
+  for (let i = 0; i < filled; i++) buffer[offset + i] = value[i]
+
+  while (filled < n) {
+    const copy = filled < n - filled ? filled : n - filled
+
+    buffer.copyWithin(offset + filled, offset, offset + copy)
+
+    filled += copy
+  }
+
+  return buffer
+}
+
+function allocate(size) {
+  if (Number.isNaN(size) || size <= 0 || size >= poolSize / 2) {
+    return new Buffer(size, { uninitialized: true })
+  }
+
+  if (pool === null || poolLength !== poolSize || poolLength - poolOffset < size) {
+    pool = binding.allocUnsafe(poolSize)
+    poolLength = poolSize
+    poolOffset = 0
+  }
+
+  const buffer = new Buffer(pool, poolOffset, size)
+
+  // Keep the next buffer 8 byte aligned so the wider accessors are not needlessly
+  // reading across word boundaries.
+  poolOffset = (poolOffset + size + 7) & ~7
+
+  return buffer
+}
+
+function swap(buffer, n, m) {
+  const i = buffer[n]
+  buffer[n] = buffer[m]
+  buffer[m] = i
+}
+
+exports.atob = function atob(data) {
+  return Buffer.from(data, 'base64').toString('latin1')
+}
+
+exports.btoa = function btoa(data) {
+  if (typeof data !== 'string') data = String(data)
+
+  return Buffer.from(data, 'latin1').toString('base64')
+}
+
+exports.transcode = function transcode(buffer, from, to) {
+  return Buffer.from(buffer.toString(from), to)
+}
+
+function boundsError() {
+  throw new RangeError('Offset is outside the bounds of the buffer')
+}
+
+function offsetError(offset) {
+  if (typeof offset !== 'number') {
+    throw new TypeError(`Offset must be a number, received type ${typeof offset}`)
+  }
+
+  throw new RangeError('Offset must be an integer')
+}
+
+function readInt48BE(buffer, offset) {
+  const value = readUint48BE(buffer, offset)
+  return value >= 0x800000000000 ? value - 0x1000000000000 : value
+}
+
+function readInt48LE(buffer, offset) {
+  const value = readUint48LE(buffer, offset)
+  return value >= 0x800000000000 ? value - 0x1000000000000 : value
+}
+
+function readInt40BE(buffer, offset) {
+  const value = readUint40BE(buffer, offset)
+  return value >= 0x8000000000 ? value - 0x10000000000 : value
+}
+
+function readInt40LE(buffer, offset) {
+  const value = readUint40LE(buffer, offset)
+  return value >= 0x8000000000 ? value - 0x10000000000 : value
+}
+
+function readInt24BE(buffer, offset) {
+  const value = readUint24BE(buffer, offset)
+  return value & 0x800000 ? value - 0x1000000 : value
+}
+
+function readInt24LE(buffer, offset) {
+  const value = readUint24LE(buffer, offset)
+  return value & 0x800000 ? value - 0x1000000 : value
+}
+
+function readUint48BE(buffer, offset) {
+  const first = buffer[offset]
+  const last = buffer[offset + 5]
+  if (first === undefined || last === undefined) boundsError()
+  return (
+    (first * 0x100 + buffer[offset + 1]) * 0x100000000 +
+    ((buffer[offset + 2] << 24) >>> 0) +
+    (buffer[offset + 3] << 16) +
+    (buffer[offset + 4] << 8) +
+    last
+  )
+}
+
+function readUint48LE(buffer, offset) {
+  const first = buffer[offset]
+  const last = buffer[offset + 5]
+  if (first === undefined || last === undefined) boundsError()
+  return (
+    (buffer[offset + 4] + last * 0x100) * 0x100000000 +
+    ((buffer[offset + 3] << 24) >>> 0) +
+    (buffer[offset + 2] << 16) +
+    (buffer[offset + 1] << 8) +
+    first
+  )
+}
+
+function readUint40BE(buffer, offset) {
+  const first = buffer[offset]
+  const last = buffer[offset + 4]
+  if (first === undefined || last === undefined) boundsError()
+  return (
+    first * 0x100000000 +
+    ((buffer[offset + 1] << 24) >>> 0) +
+    (buffer[offset + 2] << 16) +
+    (buffer[offset + 3] << 8) +
+    last
+  )
+}
+
+function readUint40LE(buffer, offset) {
+  const first = buffer[offset]
+  const last = buffer[offset + 4]
+  if (first === undefined || last === undefined) boundsError()
+  return (
+    last * 0x100000000 +
+    ((buffer[offset + 3] << 24) >>> 0) +
+    (buffer[offset + 2] << 16) +
+    (buffer[offset + 1] << 8) +
+    first
+  )
+}
+
+function readUint24BE(buffer, offset) {
+  const first = buffer[offset]
+  const last = buffer[offset + 2]
+  if (first === undefined || last === undefined) boundsError()
+  return (first << 16) | (buffer[offset + 1] << 8) | last
+}
+
+function readUint24LE(buffer, offset) {
+  const first = buffer[offset]
+  const last = buffer[offset + 2]
+  if (first === undefined || last === undefined) boundsError()
+  return (last << 16) | (buffer[offset + 1] << 8) | first
+}
+
+function writeInt48BE(buffer, value, offset) {
+  if (value < 0) value += 0x1000000000000
+  return writeUint48BE(buffer, value, offset)
+}
+
+function writeInt48LE(buffer, value, offset) {
+  if (value < 0) value += 0x1000000000000
+  return writeUint48LE(buffer, value, offset)
+}
+
+function writeInt40BE(buffer, value, offset) {
+  if (value < 0) value += 0x10000000000
+  return writeUint40BE(buffer, value, offset)
+}
+
+function writeInt40LE(buffer, value, offset) {
+  if (value < 0) value += 0x10000000000
+  return writeUint40LE(buffer, value, offset)
+}
+
+function writeInt24BE(buffer, value, offset) {
+  if (value < 0) value += 0x1000000
+  return writeUint24BE(buffer, value, offset)
+}
+
+function writeInt24LE(buffer, value, offset) {
+  if (value < 0) value += 0x1000000
+  return writeUint24LE(buffer, value, offset)
+}
+
+function writeUint48BE(buffer, value, offset) {
+  if (buffer[offset] === undefined || buffer[offset + 5] === undefined) boundsError()
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  buffer[offset] = hi >>> 8
+  buffer[offset + 1] = hi
+  buffer[offset + 2] = lo >>> 24
+  buffer[offset + 3] = lo >>> 16
+  buffer[offset + 4] = lo >>> 8
+  buffer[offset + 5] = lo
+  return offset + 6
+}
+
+function writeUint48LE(buffer, value, offset) {
+  if (buffer[offset] === undefined || buffer[offset + 5] === undefined) boundsError()
+  const hi = Math.floor(value / 0x100000000)
+  const lo = value >>> 0
+  buffer[offset] = lo
+  buffer[offset + 1] = lo >>> 8
+  buffer[offset + 2] = lo >>> 16
+  buffer[offset + 3] = lo >>> 24
+  buffer[offset + 4] = hi
+  buffer[offset + 5] = hi >>> 8
+  return offset + 6
+}
+
+function writeUint40BE(buffer, value, offset) {
+  if (buffer[offset] === undefined || buffer[offset + 4] === undefined) boundsError()
+  const lo = value >>> 0
+  buffer[offset] = Math.floor(value / 0x100000000)
+  buffer[offset + 1] = lo >>> 24
+  buffer[offset + 2] = lo >>> 16
+  buffer[offset + 3] = lo >>> 8
+  buffer[offset + 4] = lo
+  return offset + 5
+}
+
+function writeUint40LE(buffer, value, offset) {
+  if (buffer[offset] === undefined || buffer[offset + 4] === undefined) boundsError()
+  const lo = value >>> 0
+  buffer[offset] = lo
+  buffer[offset + 1] = lo >>> 8
+  buffer[offset + 2] = lo >>> 16
+  buffer[offset + 3] = lo >>> 24
+  buffer[offset + 4] = Math.floor(value / 0x100000000)
+  return offset + 5
+}
+
+function writeUint24BE(buffer, value, offset) {
+  if (buffer[offset] === undefined || buffer[offset + 2] === undefined) boundsError()
+  buffer[offset] = value >>> 16
+  buffer[offset + 1] = value >>> 8
+  buffer[offset + 2] = value
+  return offset + 3
+}
+
+function writeUint24LE(buffer, value, offset) {
+  if (buffer[offset] === undefined || buffer[offset + 2] === undefined) boundsError()
+  buffer[offset] = value
+  buffer[offset + 1] = value >>> 8
+  buffer[offset + 2] = value >>> 16
+  return offset + 3
+}