bare-buffer 2.7.0 → 3.0.0-0

package/binding.c

@@ -10,13 +10,8 @@
 
 static js_type_tag_t bare_buffer__tag = {0xfea3e944b70b0812, 0xe53bb5c343c040b6};
 
-static void
-bare_buffer_set_zero_fill_enabled_fast (js_ffi_receiver_t *receiver, uint32_t enabled) {
-  js_set_arraybuffer_zero_fill_enabled(enabled != 0);
-}
-
 static js_value_t *
-bare_buffer_set_zero_fill_enabled (js_env_t *env, js_callback_info_t *info) {
+bare_buffer_alloc (js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 1;
@@ -27,18 +22,38 @@ bare_buffer_set_zero_fill_enabled (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1);
 
-  uint32_t enabled;
-  err = js_get_value_uint32(env, argv[0], &enabled);
+  uint32_t len;
+  err = js_get_value_uint32(env, argv[0], &len);
   assert(err == 0);
 
-  js_set_arraybuffer_zero_fill_enabled(enabled != 0);
+  js_value_t *result;
+  err = js_create_arraybuffer(env, len, NULL, &result);
+  assert(err == 0);
 
-  return NULL;
+  return result;
 }
 
-static uint32_t
-bare_buffer_byte_length_utf8_fast (js_ffi_receiver_t *receiver, js_ffi_string_t *str) {
-  return utf8_length_from_latin1((const latin1_t *) str->data, str->len);
+static js_value_t *
+bare_buffer_alloc_unsafe (js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  uint32_t len;
+  err = js_get_value_uint32(env, argv[0], &len);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_unsafe_arraybuffer(env, len, NULL, &result);
+  assert(err == 0);
+
+  return result;
 }
 
 static js_value_t *
@@ -329,11 +344,6 @@ bare_buffer__compare (void *a, size_t a_len, void *b, size_t b_len) {
   return r < 0 ? -1 : 1;
 }
 
-static int32_t
-bare_buffer_compare_fast (js_ffi_receiver_t *recv, js_ffi_typedarray_t *a, js_ffi_typedarray_t *b) {
-  return bare_buffer__compare(a->data.u8, a->len, b->data.u8, b->len);
-}
-
 static js_value_t *
 bare_buffer_compare (js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -408,105 +418,34 @@ static js_value_t *
 bare_buffer_exports (js_env_t *env, js_value_t *exports) {
   int err;
 
-#define V(name, fn, ffi) \
+#define V(name, fn) \
   { \
     js_value_t *val; \
-    if (ffi) { \
-      err = js_create_function_with_ffi(env, name, -1, fn, NULL, ffi, &val); \
-    } else { \
-      err = js_create_function(env, name, -1, fn, NULL, &val); \
-    } \
+    err = js_create_function(env, name, -1, fn, NULL, &val); \
     assert(err == 0); \
     err = js_set_named_property(env, exports, name, val); \
     assert(err == 0); \
   }
 
-  {
-    js_ffi_type_info_t *return_info;
-    err = js_ffi_create_type_info(js_ffi_void, &return_info);
-    assert(err == 0);
-
-    js_ffi_type_info_t *arg_info[2];
-
-    err = js_ffi_create_type_info(js_ffi_receiver, &arg_info[0]);
-    assert(err == 0);
-
-    err = js_ffi_create_type_info(js_ffi_uint32, &arg_info[1]);
-    assert(err == 0);
-
-    js_ffi_function_info_t *function_info;
-    err = js_ffi_create_function_info(return_info, arg_info, 2, &function_info);
-    assert(err == 0);
-
-    js_ffi_function_t *ffi;
-    err = js_ffi_create_function(bare_buffer_set_zero_fill_enabled_fast, function_info, &ffi);
-    assert(err == 0);
-
-    V("setZeroFillEnabled", bare_buffer_set_zero_fill_enabled, ffi);
-  }
-
-  {
-    js_ffi_type_info_t *return_info;
-    err = js_ffi_create_type_info(js_ffi_int32, &return_info);
-    assert(err == 0);
-
-    js_ffi_type_info_t *arg_info[2];
-
-    err = js_ffi_create_type_info(js_ffi_receiver, &arg_info[0]);
-    assert(err == 0);
+  V("alloc", bare_buffer_alloc);
+  V("allocUnsafe", bare_buffer_alloc_unsafe);
 
-    err = js_ffi_create_type_info(js_ffi_string, &arg_info[1]);
-    assert(err == 0);
+  V("byteLengthUTF8", bare_buffer_byte_length_utf8);
+  V("toStringUTF8", bare_buffer_to_string_utf8);
+  V("writeUTF8", bare_buffer_write_utf8);
 
-    js_ffi_function_info_t *function_info;
-    err = js_ffi_create_function_info(return_info, arg_info, 2, &function_info);
-    assert(err == 0);
+  V("toStringUTF16LE", bare_buffer_to_string_utf16le);
+  V("writeUTF16LE", bare_buffer_write_utf16le);
 
-    js_ffi_function_t *ffi;
-    err = js_ffi_create_function(bare_buffer_byte_length_utf8_fast, function_info, &ffi);
-    assert(err == 0);
+  V("toStringBase64", bare_buffer_to_string_base64);
+  V("writeBase64", bare_buffer_write_base64);
 
-    V("byteLengthUTF8", bare_buffer_byte_length_utf8, ffi);
-  }
-
-  V("toStringUTF8", bare_buffer_to_string_utf8, NULL);
-  V("writeUTF8", bare_buffer_write_utf8, NULL);
-  V("toStringUTF16LE", bare_buffer_to_string_utf16le, NULL);
-  V("writeUTF16LE", bare_buffer_write_utf16le, NULL);
-  V("toStringBase64", bare_buffer_to_string_base64, NULL);
-  V("writeBase64", bare_buffer_write_base64, NULL);
-  V("toStringHex", bare_buffer_to_string_hex, NULL);
-  V("writeHex", bare_buffer_write_hex, NULL);
-
-  {
-    js_ffi_type_info_t *return_info;
-    err = js_ffi_create_type_info(js_ffi_int32, &return_info);
-    assert(err == 0);
-
-    js_ffi_type_info_t *arg_info[3];
-
-    err = js_ffi_create_type_info(js_ffi_receiver, &arg_info[0]);
-    assert(err == 0);
-
-    err = js_ffi_create_type_info(js_ffi_uint8array, &arg_info[1]);
-    assert(err == 0);
-
-    err = js_ffi_create_type_info(js_ffi_uint8array, &arg_info[2]);
-    assert(err == 0);
-
-    js_ffi_function_info_t *function_info;
-    err = js_ffi_create_function_info(return_info, arg_info, 3, &function_info);
-    assert(err == 0);
-
-    js_ffi_function_t *ffi;
-    err = js_ffi_create_function(bare_buffer_compare_fast, function_info, &ffi);
-    assert(err == 0);
-
-    V("compare", bare_buffer_compare, ffi);
-  }
+  V("toStringHex", bare_buffer_to_string_hex);
+  V("writeHex", bare_buffer_write_hex);
 
-  V("tag", bare_buffer_tag, NULL)
-  V("isTagged", bare_buffer_is_tagged, NULL)
+  V("compare", bare_buffer_compare);
+  V("tag", bare_buffer_tag);
+  V("isTagged", bare_buffer_is_tagged);
 #undef V
 
   return exports;

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 {
+  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 { Buffer }
+
+  export let poolSize: number
+
+  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

@@ -21,6 +21,44 @@ module.exports = exports = class Buffer extends Uint8Array {
     poolSize = Math.max(0, value)
   }
 
+  constructor(arrayBuffer, offset, length, opts = {}) {
+    if (typeof arrayBuffer === 'number') {
+      opts = offset || {}
+
+      const { uninitialized = false } = opts
+
+      offset = 0
+      length = arrayBuffer
+
+      if (length > constants.MAX_LENGTH) {
+        throw new RangeError(
+          `Buffer length must be at most ${constants.MAX_LENGTH}`
+        )
+      }
+
+      arrayBuffer = uninitialized
+        ? binding.allocUnsafe(length)
+        : binding.alloc(length)
+    } else {
+      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 === 'length' && length !== null) {
+        opts = length
+        length = arrayBuffer.byteLength - offset
+      }
+    }
+
+    super(arrayBuffer, offset, length)
+  }
+
   [Symbol.species]() {
     return Buffer
   }
@@ -147,12 +185,18 @@ module.exports = exports = class Buffer extends Uint8Array {
   }
 
   indexOf(value, offset = 0, encoding) {
-    if (typeof value === 'number') return super.indexOf(value & 0xff, 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 value === 'boolean') value = +value
+
     if (typeof value === 'number') {
       return super.lastIndexOf(value & 0xff, offset)
     }
@@ -204,7 +248,7 @@ 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)
 
@@ -528,12 +572,7 @@ exports.alloc = function alloc(size, fill, encoding) {
 }
 
 exports.allocUnsafe = function allocUnsafe(size) {
-  binding.setZeroFillEnabled(0)
-  try {
-    return new Buffer(size)
-  } finally {
-    binding.setZeroFillEnabled(1)
-  }
+  return new Buffer(size, { uninitialized: true })
 }
 
 exports.allocUnsafeSlow = function allocUnsafeSlow(size) {

package/lib/constants.js

@@ -1,4 +1,4 @@
 module.exports = {
-  MAX_LENGTH: 2 ** 32, // 4 GiB
+  MAX_LENGTH: 2 ** 32 - 1, // 4 GiB
   MAX_STRING_LENGTH: 2 ** 28 - 16 // ~512 MiB, lowest common limit
 }

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "bare-buffer",
-  "version": "2.7.0",
+  "version": "3.0.0-0",
   "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",
@@ -19,7 +23,7 @@
   ],
   "addon": true,
   "scripts": {
-    "test": "prettier . --check && bare test/all.js"
+    "test": "prettier . --check && bare test.js"
   },
   "repository": {
     "type": "git",
@@ -31,6 +35,9 @@
     "url": "https://github.com/holepunchto/bare-buffer/issues"
   },
   "homepage": "https://github.com/holepunchto/bare-buffer#readme",
+  "engines": {
+    "bare": ">=1.13.0"
+  },
   "devDependencies": {
     "brittle": "^3.1.1",
     "cmake-bare": "^1.1.6",