bare-buffer 2.6.0 → 2.7.1

package/global.js

@@ -0,0 +1 @@
+global.Buffer = require('.')

package/index.d.ts

@@ -0,0 +1,181 @@
+type BufferEncoding =
+  | 'ascii'
+  | 'base64'
+  | 'hex'
+  | 'ucs-2'
+  | 'ucs2'
+  | 'utf-16le'
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf8'
+
+declare class Buffer extends Uint8Array {
+  static Buffer: Buffer
+
+  static poolSize: number
+
+  compare(
+    target: Buffer,
+    targetStart?: number,
+    targetEnd?: number,
+    sourceStart?: number,
+    sourceEnd?: number
+  ): number
+
+  copy(
+    target: Buffer,
+    targetStart?: number,
+    sourceStart?: number,
+    sourceEnd?: number
+  ): number
+
+  equals(target: Buffer): boolean
+
+  fill(value: string, encoding?: BufferEncoding): this
+  fill(value: string, offset?: number, encoding?: BufferEncoding): this
+  fill(
+    value: string,
+    offset?: number,
+    end?: number,
+    encoding?: BufferEncoding
+  ): this
+  fill(value: Buffer | number | boolean, offset?: number, end?: number): this
+
+  includes(value: string, encoding?: BufferEncoding): boolean
+  includes(value: string, offset?: number, encoding?: BufferEncoding): boolean
+  includes(value: Buffer | number | boolean, offset?: number): boolean
+
+  indexOf(value: string, encoding?: BufferEncoding): number
+  indexOf(value: string, offset?: number, encoding?: BufferEncoding): number
+  indexOf(value: Buffer | number | boolean, offset?: number): number
+
+  lastIndexOf(value: string, encoding?: BufferEncoding): number
+  lastIndexOf(value: string, offset?: number, encoding?: BufferEncoding): number
+  lastIndexOf(value: Buffer | number | boolean, offset?: number): number
+
+  swap16(): this
+  swap32(): this
+  swap64(): this
+
+  toString(encoding?: BufferEncoding, start?: number, end?: number): string
+
+  readDoubleBE(offset?: number): number
+  readDoubleLE(offset?: number): number
+
+  readFloatBE(offset?: number): number
+  readFloatLE(offset?: number): number
+
+  readInt8(offset?: number): number
+
+  readInt16BE(offset?: number): number
+  readInt16LE(offset?: number): number
+
+  readInt32BE(offset?: number): number
+  readInt32LE(offset?: number): number
+
+  readBigInt64BE(offset?: number): bigint
+  readBigInt64LE(offset?: number): bigint
+
+  readUInt8(offset?: number): number
+  readUint8(offset?: number): number
+
+  readUInt16BE(offset?: number): number
+  readUint16BE(offset?: number): number
+  readUInt16LE(offset?: number): number
+  readUint16LE(offset?: number): number
+
+  readUInt32BE(offset?: number): number
+  readUint32BE(offset?: number): number
+  readUInt32LE(offset?: number): number
+  readUint32LE(offset?: number): number
+
+  readBigUInt64BE(offset?: number): bigint
+  readBigUint64BE(offset?: number): bigint
+  readBigUInt64LE(offset?: number): bigint
+  readBigUint64LE(offset?: number): bigint
+
+  write(string: string, encoding?: BufferEncoding): number
+  write(string: string, offset?: number, encoding?: BufferEncoding): number
+  write(
+    string: string,
+    offset?: number,
+    length?: number,
+    encoding?: BufferEncoding
+  ): number
+
+  writeDoubleBE(value: number, offset?: number): number
+  writeDoubleLE(value: number, offset?: number): number
+
+  writeFloatBE(value: number, offset?: number): number
+  writeFloatLE(value: number, offset?: number): number
+
+  writeInt8(value: number, offset?: number): number
+
+  writeInt16BE(value: number, offset?: number): number
+  writeInt16LE(value: number, offset?: number): number
+
+  writeInt32BE(value: number, offset?: number): number
+  writeInt32LE(value: number, offset?: number): number
+
+  writeBigInt64BE(value: bigint, offset?: number): number
+  writeBigInt64LE(value: bigint, offset?: number): number
+
+  writeUInt8(value: number, offset?: number): number
+  writeUint8(value: number, offset?: number): number
+
+  writeUInt16BE(value: number, offset?: number): number
+  writeUint16BE(value: number, offset?: number): number
+  writeUInt16LE(value: number, offset?: number): number
+  writeUint16LE(value: number, offset?: number): number
+
+  writeUInt32BE(value: number, offset?: number): number
+  writeUint32BE(value: number, offset?: number): number
+  writeUInt32LE(value: number, offset?: number): number
+  writeUint32LE(value: number, offset?: number): number
+
+  writeBigUint64BE(value: bigint, offset?: number): number
+  writeBigUInt64BE(value: bigint, offset?: number): number
+  writeBigUint64LE(value: bigint, offset?: number): number
+  writeBigUInt64LE(value: bigint, offset?: number): number
+}
+
+declare namespace Buffer {
+  export function isBuffer(value: unknown): value is Buffer
+
+  export function isEncoding(encoding: string): encoding is BufferEncoding
+
+  export function alloc(
+    size: number,
+    fill: string,
+    encoding?: BufferEncoding
+  ): Buffer
+  export function alloc(size: number, fill?: Buffer | number | boolean): Buffer
+
+  export function allocUnsafe(size: number): Buffer
+
+  export function allocUnsafeSlow(size: number): Buffer
+
+  export function byteLength(
+    string: ArrayBufferView | ArrayBufferLike | string,
+    encoding?: BufferEncoding
+  ): number
+
+  export function compare(a: Buffer, b: Buffer): number
+
+  export function concat(buffers: Buffer[], length?: number): Buffer
+
+  export function coerce(buffer: Buffer): Buffer
+
+  export function from(data: Iterable<number>): Buffer
+  export function from(data: ArrayLike<number>): Buffer
+  export function from(string: string, encoding?: BufferEncoding): Buffer
+  export function from(
+    arrayBuffer: ArrayBufferLike,
+    offset?: number,
+    length?: number
+  ): Buffer
+
+  export const constants: { MAX_LENGTH: number; MAX_STRING_LENGTH: number }
+}
+
+export = Buffer

package/index.js

@@ -8,24 +8,24 @@ const binding = require('./binding')
 
 let poolSize = 0
 
-const Buffer = module.exports = exports = class Buffer extends Uint8Array {
+module.exports = exports = class Buffer extends Uint8Array {
   static {
     binding.tag(this)
   }
 
-  static get poolSize () {
+  static get poolSize() {
     return poolSize
   }
 
-  static set poolSize (value) {
+  static set poolSize(value) {
     poolSize = Math.max(0, value)
   }
 
-  [Symbol.species] () {
+  [Symbol.species]() {
     return Buffer
   }
 
-  copy (target, targetStart = 0, sourceStart = 0, sourceEnd = this.byteLength) {
+  copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.byteLength) {
     let source = this
 
     if (targetStart < 0) targetStart = 0
@@ -39,14 +39,18 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
     if (sourceEnd <= sourceStart) return 0
     if (sourceEnd > source.byteLength) sourceEnd = source.byteLength
 
-    if (sourceEnd - sourceStart > targetLength) sourceEnd = sourceStart + targetLength
+    if (sourceEnd - sourceStart > targetLength) {
+      sourceEnd = sourceStart + targetLength
+    }
 
     const sourceLength = sourceEnd - sourceStart
 
     if (source === target) {
       target.copyWithin(targetStart, sourceStart, sourceEnd)
     } else {
-      if (sourceStart !== 0 || sourceEnd !== source.byteLength) source = source.subarray(sourceStart, sourceEnd)
+      if (sourceStart !== 0 || sourceEnd !== source.byteLength) {
+        source = source.subarray(sourceStart, sourceEnd)
+      }
 
       target.set(source, targetStart)
     }
@@ -54,7 +58,7 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
     return sourceLength
   }
 
-  equals (target) {
+  equals(target) {
     const source = this
 
     if (source === target) return true
@@ -64,7 +68,13 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
     return binding.compare(source, target) === 0
   }
 
-  compare (target, targetStart = 0, targetEnd = target.byteLength, sourceStart = 0, sourceEnd = this.byteLength) {
+  compare(
+    target,
+    targetStart = 0,
+    targetEnd = target.byteLength,
+    sourceStart = 0,
+    sourceEnd = this.byteLength
+  ) {
     let source = this
 
     if (source === target) return 0
@@ -83,14 +93,18 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
     if (sourceEnd < sourceStart) sourceEnd = sourceStart
     if (sourceEnd > source.byteLength) sourceEnd = source.byteLength
 
-    if (sourceStart !== 0 || sourceEnd !== source.byteLength) source = source.subarray(sourceStart, sourceEnd)
+    if (sourceStart !== 0 || sourceEnd !== source.byteLength) {
+      source = source.subarray(sourceStart, sourceEnd)
+    }
 
-    if (targetStart !== 0 || targetEnd !== target.byteLength) target = target.subarray(targetStart, targetEnd)
+    if (targetStart !== 0 || targetEnd !== target.byteLength) {
+      target = target.subarray(targetStart, targetEnd)
+    }
 
     return binding.compare(source, target)
   }
 
-  fill (value, offset = 0, end = this.byteLength, encoding = 'utf8') {
+  fill(value, offset = 0, end = this.byteLength, encoding = 'utf8') {
     if (typeof value === 'string') {
       // fill(string, encoding)
       if (typeof offset === 'string') {
@@ -98,7 +112,7 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
         offset = 0
         end = this.byteLength
 
-      // fill(string, offset, encoding)
+        // fill(string, offset, encoding)
       } else if (typeof end === 'string') {
         encoding = end
         end = this.byteLength
@@ -128,36 +142,48 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
     return this
   }
 
-  includes (value, offset, encoding) {
+  includes(value, offset, encoding) {
     return this.indexOf(value, offset, encoding) !== -1
   }
 
-  indexOf (value, offset = 0, encoding) {
-    if (typeof value === 'number') return super.indexOf(value & 0xff, offset)
+  indexOf(value, offset = 0, encoding) {
+    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 value === 'number') return super.lastIndexOf(value & 0xff, offset)
+  lastIndexOf(value, offset = this.byteLength - 1, encoding) {
+    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 () {
+  swap16() {
     const length = this.byteLength
 
-    if (length % 2 !== 0) throw new RangeError('Buffer size must be a multiple of 16-bits')
+    if (length % 2 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 16-bits')
+    }
 
     for (let i = 0; i < length; i += 2) swap(this, i, i + 1)
 
     return this
   }
 
-  swap32 () {
+  swap32() {
     const length = this.byteLength
 
-    if (length % 4 !== 0) throw new RangeError('Buffer size must be a multiple of 32-bits')
+    if (length % 4 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 32-bits')
+    }
 
     for (let i = 0; i < length; i += 4) {
       swap(this, i, i + 3)
@@ -167,10 +193,12 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
     return this
   }
 
-  swap64 () {
+  swap64() {
     const length = this.byteLength
 
-    if (length % 8 !== 0) throw new RangeError('Buffer size must be a multiple of 64-bits')
+    if (length % 8 !== 0) {
+      throw new RangeError('Buffer size must be a multiple of 64-bits')
+    }
 
     for (let i = 0; i < length; i += 8) {
       swap(this, i, i + 7)
@@ -182,7 +210,7 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
     return this
   }
 
-  toString (encoding, start = 0, end = this.byteLength) {
+  toString(encoding = 'utf8', start = 0, end = this.byteLength) {
     // toString()
     if (arguments.length === 0) return utf8.toString(this)
 
@@ -197,12 +225,19 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
 
     let buffer = this
 
-    if (start !== 0 || end !== this.byteLength) buffer = buffer.subarray(start, end)
+    if (start !== 0 || end !== this.byteLength) {
+      buffer = buffer.subarray(start, end)
+    }
 
     return codecFor(encoding).toString(buffer)
   }
 
-  write (string, offset = 0, length = this.byteLength - offset, encoding = 'utf8') {
+  write(
+    string,
+    offset = 0,
+    length = this.byteLength - offset,
+    encoding = 'utf8'
+  ) {
     // write(string)
     if (arguments.length === 1) return utf8.write(this, string)
 
@@ -212,7 +247,7 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
       offset = 0
       length = this.byteLength
 
-    // write(string, offset, encoding)
+      // write(string, offset, encoding)
     } else if (typeof length === 'string') {
       encoding = length
       length = this.byteLength - offset
@@ -230,91 +265,213 @@ const Buffer = module.exports = exports = class Buffer extends Uint8Array {
 
     let buffer = this
 
-    if (start !== 0 || end !== this.byteLength) buffer = buffer.subarray(start, end)
+    if (start !== 0 || end !== this.byteLength) {
+      buffer = buffer.subarray(start, end)
+    }
 
     return codecFor(encoding).write(buffer, string)
   }
 
-  readBigInt64BE (offset = 0) { return viewOf(this).getBigInt64(offset, false) }
-  readBigInt64LE (offset = 0) { return viewOf(this).getBigInt64(offset, true) }
+  readBigInt64BE(offset = 0) {
+    return viewOf(this).getBigInt64(offset, false)
+  }
+  readBigInt64LE(offset = 0) {
+    return viewOf(this).getBigInt64(offset, true)
+  }
 
-  readBigUint64BE (offset = 0) { return viewOf(this).getBigUint64(offset, false) }
-  readBigUint64LE (offset = 0) { return viewOf(this).getBigUint64(offset, true) }
+  readBigUint64BE(offset = 0) {
+    return viewOf(this).getBigUint64(offset, false)
+  }
+  readBigUint64LE(offset = 0) {
+    return viewOf(this).getBigUint64(offset, true)
+  }
 
-  readDoubleBE (offset = 0) { return viewOf(this).getFloat64(offset, false) }
-  readDoubleLE (offset = 0) { return viewOf(this).getFloat64(offset, true) }
+  readDoubleBE(offset = 0) {
+    return viewOf(this).getFloat64(offset, false)
+  }
+  readDoubleLE(offset = 0) {
+    return viewOf(this).getFloat64(offset, true)
+  }
 
-  readFloatBE (offset = 0) { return viewOf(this).getFloat32(offset, false) }
-  readFloatLE (offset = 0) { return viewOf(this).getFloat32(offset, true) }
+  readFloatBE(offset = 0) {
+    return viewOf(this).getFloat32(offset, false)
+  }
+  readFloatLE(offset = 0) {
+    return viewOf(this).getFloat32(offset, true)
+  }
 
-  readInt8 (offset = 0) { return viewOf(this).getInt8(offset) }
+  readInt8(offset = 0) {
+    return viewOf(this).getInt8(offset)
+  }
 
-  readInt16BE (offset = 0) { return viewOf(this).getInt16(offset, false) }
-  readInt16LE (offset = 0) { return viewOf(this).getInt16(offset, true) }
+  readInt16BE(offset = 0) {
+    return viewOf(this).getInt16(offset, false)
+  }
+  readInt16LE(offset = 0) {
+    return viewOf(this).getInt16(offset, true)
+  }
 
-  readInt32BE (offset = 0) { return viewOf(this).getInt32(offset, false) }
-  readInt32LE (offset = 0) { return viewOf(this).getInt32(offset, true) }
+  readInt32BE(offset = 0) {
+    return viewOf(this).getInt32(offset, false)
+  }
+  readInt32LE(offset = 0) {
+    return viewOf(this).getInt32(offset, true)
+  }
 
-  readUint8 (offset = 0) { return viewOf(this).getUint8(offset) }
+  readUint8(offset = 0) {
+    return viewOf(this).getUint8(offset)
+  }
 
-  readUint16BE (offset = 0) { return viewOf(this).getUint16(offset, false) }
-  readUint16LE (offset = 0) { return viewOf(this).getUint16(offset, true) }
+  readUint16BE(offset = 0) {
+    return viewOf(this).getUint16(offset, false)
+  }
+  readUint16LE(offset = 0) {
+    return viewOf(this).getUint16(offset, true)
+  }
 
-  readUint32BE (offset = 0) { return viewOf(this).getUint32(offset, false) }
-  readUint32LE (offset = 0) { return viewOf(this).getUint32(offset, true) }
+  readUint32BE(offset = 0) {
+    return viewOf(this).getUint32(offset, false)
+  }
+  readUint32LE(offset = 0) {
+    return viewOf(this).getUint32(offset, true)
+  }
 
-  readBigUInt64BE (...args) { return this.readBigUint64BE(...args) }
-  readBigUInt64LE (...args) { return this.readBigUint64LE(...args) }
+  readBigUInt64BE(...args) {
+    return this.readBigUint64BE(...args)
+  }
+  readBigUInt64LE(...args) {
+    return this.readBigUint64LE(...args)
+  }
 
-  readUInt8 (...args) { return this.readUint8(...args) }
+  readUInt8(...args) {
+    return this.readUint8(...args)
+  }
 
-  readUInt16BE (...args) { return this.readUint16BE(...args) }
-  readUInt16LE (...args) { return this.readUint16LE(...args) }
+  readUInt16BE(...args) {
+    return this.readUint16BE(...args)
+  }
+  readUInt16LE(...args) {
+    return this.readUint16LE(...args)
+  }
 
-  readUInt32BE (...args) { return this.readUint32BE(...args) }
-  readUInt32LE (...args) { return this.readUint32LE(...args) }
+  readUInt32BE(...args) {
+    return this.readUint32BE(...args)
+  }
+  readUInt32LE(...args) {
+    return this.readUint32LE(...args)
+  }
 
-  writeBigInt64BE (value, offset = 0) { viewOf(this).setBigInt64(offset, value, false); return offset + 8 }
-  writeBigInt64LE (value, offset = 0) { viewOf(this).setBigInt64(offset, value, true); return offset + 8 }
+  writeBigInt64BE(value, offset = 0) {
+    viewOf(this).setBigInt64(offset, value, false)
+    return offset + 8
+  }
+  writeBigInt64LE(value, offset = 0) {
+    viewOf(this).setBigInt64(offset, value, true)
+    return offset + 8
+  }
 
-  writeBigUint64BE (value, offset = 0) { viewOf(this).setBigUint64(offset, value, false); return offset + 8 }
-  writeBigUint64LE (value, offset = 0) { viewOf(this).setBigUint64(offset, value, true); return offset + 8 }
+  writeBigUint64BE(value, offset = 0) {
+    viewOf(this).setBigUint64(offset, value, false)
+    return offset + 8
+  }
+  writeBigUint64LE(value, offset = 0) {
+    viewOf(this).setBigUint64(offset, value, true)
+    return offset + 8
+  }
 
-  writeDoubleBE (value, offset = 0) { viewOf(this).setFloat64(offset, value, false); return offset + 8 }
-  writeDoubleLE (value, offset = 0) { viewOf(this).setFloat64(offset, value, true); return offset + 8 }
+  writeDoubleBE(value, offset = 0) {
+    viewOf(this).setFloat64(offset, value, false)
+    return offset + 8
+  }
+  writeDoubleLE(value, offset = 0) {
+    viewOf(this).setFloat64(offset, value, true)
+    return offset + 8
+  }
 
-  writeFloatBE (value, offset = 0) { viewOf(this).setFloat32(offset, value, false); return offset + 4 }
-  writeFloatLE (value, offset = 0) { viewOf(this).setFloat32(offset, value, true); return offset + 4 }
+  writeFloatBE(value, offset = 0) {
+    viewOf(this).setFloat32(offset, value, false)
+    return offset + 4
+  }
+  writeFloatLE(value, offset = 0) {
+    viewOf(this).setFloat32(offset, value, true)
+    return offset + 4
+  }
 
-  writeInt8 (value, offset = 0) { viewOf(this).setInt8(offset, value); return offset + 1 }
+  writeInt8(value, offset = 0) {
+    viewOf(this).setInt8(offset, value)
+    return offset + 1
+  }
 
-  writeInt16BE (value, offset = 0) { viewOf(this).setInt16(offset, value, false); return offset + 2 }
-  writeInt16LE (value, offset = 0) { viewOf(this).setInt16(offset, value, true); return offset + 2 }
+  writeInt16BE(value, offset = 0) {
+    viewOf(this).setInt16(offset, value, false)
+    return offset + 2
+  }
+  writeInt16LE(value, offset = 0) {
+    viewOf(this).setInt16(offset, value, true)
+    return offset + 2
+  }
 
-  writeInt32BE (value, offset = 0) { viewOf(this).setInt32(offset, value, false); return offset + 4 }
-  writeInt32LE (value, offset = 0) { viewOf(this).setInt32(offset, value, true); return offset + 4 }
+  writeInt32BE(value, offset = 0) {
+    viewOf(this).setInt32(offset, value, false)
+    return offset + 4
+  }
+  writeInt32LE(value, offset = 0) {
+    viewOf(this).setInt32(offset, value, true)
+    return offset + 4
+  }
 
-  writeUint8 (value, offset = 0) { viewOf(this).setUint8(offset, value, true); return offset + 1 }
+  writeUint8(value, offset = 0) {
+    viewOf(this).setUint8(offset, value, true)
+    return offset + 1
+  }
 
-  writeUint16BE (value, offset = 0) { viewOf(this).setUint16(offset, value, false); return offset + 2 }
-  writeUint16LE (value, offset = 0) { viewOf(this).setUint16(offset, value, true); return offset + 2 }
+  writeUint16BE(value, offset = 0) {
+    viewOf(this).setUint16(offset, value, false)
+    return offset + 2
+  }
+  writeUint16LE(value, offset = 0) {
+    viewOf(this).setUint16(offset, value, true)
+    return offset + 2
+  }
 
-  writeUint32LE (value, offset = 0) { viewOf(this).setUint32(offset, value, true); return offset + 4 }
-  writeUint32BE (value, offset = 0) { viewOf(this).setUint32(offset, value, false); return offset + 4 }
+  writeUint32LE(value, offset = 0) {
+    viewOf(this).setUint32(offset, value, true)
+    return offset + 4
+  }
+  writeUint32BE(value, offset = 0) {
+    viewOf(this).setUint32(offset, value, false)
+    return offset + 4
+  }
 
-  writeBigUInt64BE (...args) { return this.writeBigUint64BE(...args) }
-  writeBigUInt64LE (...args) { return this.writeBigUint64LE(...args) }
+  writeBigUInt64BE(...args) {
+    return this.writeBigUint64BE(...args)
+  }
+  writeBigUInt64LE(...args) {
+    return this.writeBigUint64LE(...args)
+  }
 
-  writeUInt8 (...args) { return this.writeUint8(...args) }
+  writeUInt8(...args) {
+    return this.writeUint8(...args)
+  }
 
-  writeUInt16BE (...args) { return this.writeUint16BE(...args) }
-  writeUInt16LE (...args) { return this.writeUint16LE(...args) }
+  writeUInt16BE(...args) {
+    return this.writeUint16BE(...args)
+  }
+  writeUInt16LE(...args) {
+    return this.writeUint16LE(...args)
+  }
 
-  writeUInt32BE (...args) { return this.writeUint32BE(...args) }
-  writeUInt32LE (...args) { return this.writeUint32LE(...args) }
+  writeUInt32BE(...args) {
+    return this.writeUint32BE(...args)
+  }
+  writeUInt32LE(...args) {
+    return this.writeUint32LE(...args)
+  }
 }
 
-exports.Buffer = exports
+const Buffer = exports
+
+exports.Buffer = Buffer // For Node.js compatibility
 
 exports.constants = constants
 
@@ -326,7 +483,7 @@ codecs.hex = hex
 codecs.utf8 = codecs['utf-8'] = utf8
 codecs.utf16le = codecs.ucs2 = codecs['utf-16le'] = codecs['ucs-2'] = utf16le
 
-function codecFor (encoding = 'utf8') {
+function codecFor(encoding = 'utf8') {
   if (encoding in codecs) return codecs[encoding]
 
   encoding = encoding.toLowerCase()
@@ -338,7 +495,7 @@ function codecFor (encoding = 'utf8') {
 
 const views = new WeakMap()
 
-function viewOf (buffer) {
+function viewOf(buffer) {
   let view = views.get(buffer)
   if (view === undefined) {
     view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength)
@@ -347,7 +504,7 @@ function viewOf (buffer) {
   return view
 }
 
-exports.isBuffer = function isBuffer (value) {
+exports.isBuffer = function isBuffer(value) {
   if (typeof value !== 'object' || value === null) return false
 
   let constructor = value.constructor
@@ -361,7 +518,7 @@ exports.isBuffer = function isBuffer (value) {
   return false
 }
 
-exports.isEncoding = function isEncoding (encoding) {
+exports.isEncoding = function isEncoding(encoding) {
   try {
     codecFor(encoding)
     return true
@@ -370,13 +527,13 @@ exports.isEncoding = function isEncoding (encoding) {
   }
 }
 
-exports.alloc = function alloc (size, fill, encoding) {
+exports.alloc = function alloc(size, fill, encoding) {
   const buffer = new Buffer(size)
   if (fill !== undefined) buffer.fill(fill, 0, buffer.byteLength, encoding)
   return buffer
 }
 
-exports.allocUnsafe = function allocUnsafe (size) {
+exports.allocUnsafe = function allocUnsafe(size) {
   binding.setZeroFillEnabled(0)
   try {
     return new Buffer(size)
@@ -385,11 +542,11 @@ exports.allocUnsafe = function allocUnsafe (size) {
   }
 }
 
-exports.allocUnsafeSlow = function allocUnsafeSlow (size) {
+exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
   return exports.allocUnsafe(size)
 }
 
-exports.byteLength = function byteLength (string, encoding) {
+exports.byteLength = function byteLength(string, encoding) {
   if (typeof string === 'string') {
     return codecFor(encoding).byteLength(string)
   }
@@ -397,11 +554,11 @@ exports.byteLength = function byteLength (string, encoding) {
   return string.byteLength
 }
 
-exports.compare = function compare (a, b) {
+exports.compare = function compare(a, b) {
   return binding.compare(a, b)
 }
 
-exports.concat = function concat (buffers, length) {
+exports.concat = function concat(buffers, length) {
   if (length === undefined) {
     length = buffers.reduce((length, buffer) => length + buffer.byteLength, 0)
   }
@@ -424,12 +581,12 @@ exports.concat = function concat (buffers, length) {
   return result
 }
 
-exports.coerce = function coerce (buffer) {
+exports.coerce = function coerce(buffer) {
   if (exports.isBuffer(buffer)) return buffer
   return new Buffer(buffer.buffer, buffer.byteOffset, buffer.byteLength)
 }
 
-exports.from = function from (value, encodingOrOffset, length) {
+exports.from = function from(value, encodingOrOffset, length) {
   // from(string, encoding)
   if (typeof value === 'string') return fromString(value, encodingOrOffset)
 
@@ -443,37 +600,37 @@ exports.from = function from (value, encodingOrOffset, length) {
   return fromArrayBuffer(value, encodingOrOffset, length)
 }
 
-function fromString (string, encoding) {
+function fromString(string, encoding) {
   const codec = codecFor(encoding)
   const buffer = new Buffer(codec.byteLength(string))
   codec.write(buffer, string)
   return buffer
 }
 
-function fromArray (array) {
+function fromArray(array) {
   const buffer = new Buffer(array.length)
   buffer.set(array)
   return buffer
 }
 
-function fromBuffer (buffer) {
+function fromBuffer(buffer) {
   const copy = new Buffer(buffer.byteLength)
   copy.set(buffer)
   return copy
 }
 
-function fromArrayBuffer (arrayBuffer, offset, length) {
+function fromArrayBuffer(arrayBuffer, offset, length) {
   return new Buffer(arrayBuffer, offset, length)
 }
 
-function bidirectionalIndexOf (buffer, value, offset, encoding, first) {
+function bidirectionalIndexOf(buffer, value, offset, encoding, first) {
   if (buffer.byteLength === 0) return -1
 
   if (typeof offset === 'string') {
     encoding = offset
     offset = 0
   } else if (offset === undefined) {
-    offset = first ? 0 : (buffer.byteLength - 1)
+    offset = first ? 0 : buffer.byteLength - 1
   } else if (offset < 0) {
     offset += buffer.byteLength
   }
@@ -524,7 +681,7 @@ function bidirectionalIndexOf (buffer, value, offset, encoding, first) {
   return -1
 }
 
-function swap (buffer, n, m) {
+function swap(buffer, n, m) {
   const i = buffer[n]
   buffer[n] = buffer[m]
   buffer[m] = i

package/lib/ascii.js

@@ -1,8 +1,8 @@
-exports.byteLength = function byteLength (string) {
+exports.byteLength = function byteLength(string) {
   return string.length
 }
 
-exports.toString = function toString (buffer) {
+exports.toString = function toString(buffer) {
   const len = buffer.byteLength
 
   let result = ''
@@ -14,7 +14,7 @@ exports.toString = function toString (buffer) {
   return result
 }
 
-exports.write = function write (buffer, string) {
+exports.write = function write(buffer, string) {
   const len = buffer.byteLength
 
   for (let i = 0; i < len; i++) {

package/lib/base64.js

@@ -1,6 +1,6 @@
 const binding = require('../binding')
 
-exports.byteLength = function byteLength (string) {
+exports.byteLength = function byteLength(string) {
   let len = string.length
 
   if (string.charCodeAt(len - 1) === 0x3d) len--

package/lib/hex.js

@@ -1,6 +1,6 @@
 const binding = require('../binding')
 
-exports.byteLength = function byteLength (string) {
+exports.byteLength = function byteLength(string) {
   return string.length >>> 1
 }
 

package/lib/utf16le.js

@@ -1,6 +1,6 @@
 const binding = require('../binding')
 
-exports.byteLength = function byteLength (string) {
+exports.byteLength = function byteLength(string) {
   return string.length * 2
 }
 

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "bare-buffer",
-  "version": "2.6.0",
+  "version": "2.7.1",
   "description": "Native buffers for JavaScript",
   "exports": {
-    ".": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
     "./package": "./package.json",
+    "./global": "./global.js",
     "./constants": "./lib/constants.js"
   },
   "files": [
     "index.js",
+    "index.d.ts",
+    "global.js",
     "binding.c",
     "binding.js",
     "CMakeLists.txt",
@@ -17,7 +23,7 @@
   ],
   "addon": true,
   "scripts": {
-    "test": "standard && bare test/all.js"
+    "test": "prettier . --check && bare test/all.js"
   },
   "repository": {
     "type": "git",
@@ -33,6 +39,7 @@
     "brittle": "^3.1.1",
     "cmake-bare": "^1.1.6",
     "cmake-fetch": "^1.0.0",
-    "standard": "^17.0.0"
+    "prettier": "^3.3.3",
+    "prettier-config-standard": "^7.0.0"
   }
 }