bare-buffer 3.1.4 → 3.3.0

package/CMakeLists.txt

@@ -6,7 +6,7 @@ find_package(cmake-fetch REQUIRED PATHS node_modules/cmake-fetch)
 project(bare_buffer C)
 
 fetch_package("github:holepunchto/libutf#9509b28")
-fetch_package("github:holepunchto/libbase64#cded073")
+fetch_package("github:holepunchto/libbase64#86afd29")
 fetch_package("github:holepunchto/libhex#1dfad95")
 
 add_bare_module(bare_buffer)

package/binding.c

@@ -21,7 +21,7 @@ bare_buffer__memcmp(void *a, size_t a_len, void *b, size_t b_len) {
 }
 
 static void
-bare_buffer__on_free_string(js_env_t *env, void *data, void *finalize_hint) {
+bare_buffer__on_finalize_string(js_env_t *env, void *data, void *finalize_hint) {
   free(data);
 }
 
@@ -37,8 +37,8 @@ bare_buffer_alloc(js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1);
 
-  uint32_t len;
-  err = js_get_value_uint32(env, argv[0], &len);
+  int64_t len;
+  err = js_get_value_int64(env, argv[0], &len);
   assert(err == 0);
 
   js_value_t *result;
@@ -60,8 +60,8 @@ bare_buffer_alloc_unsafe(js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 1);
 
-  uint32_t len;
-  err = js_get_value_uint32(env, argv[0], &len);
+  int64_t len;
+  err = js_get_value_int64(env, argv[0], &len);
   assert(err == 0);
 
   js_value_t *result;
@@ -71,7 +71,7 @@ bare_buffer_alloc_unsafe(js_env_t *env, js_callback_info_t *info) {
   return result;
 }
 
-static uint32_t
+static int64_t
 bare_buffer_typed_byte_length_utf8(js_value_t *receiver, js_value_t *str, js_typed_callback_info_t *info) {
   int err;
 
@@ -83,7 +83,7 @@ bare_buffer_typed_byte_length_utf8(js_value_t *receiver, js_value_t *str, js_typ
   err = js_get_value_string_utf8(env, str, NULL, 0, &str_len);
   assert(err == 0);
 
-  return (uint32_t) str_len;
+  return str_len;
 }
 
 static js_value_t *
@@ -103,7 +103,7 @@ bare_buffer_byte_length_utf8(js_env_t *env, js_callback_info_t *info) {
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_uint32(env, (uint32_t) str_len, &result);
+  err = js_create_int64(env, str_len, &result);
   assert(err == 0);
 
   return result;
@@ -113,76 +113,89 @@ static js_value_t *
 bare_buffer_to_string_utf8(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 3);
 
   utf8_t *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &buf, &buf_len, NULL, NULL);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
+
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_string_utf8(env, buf, buf_len, &result);
+  err = js_create_string_utf8(env, &buf[offset], len, &result);
   assert(err == 0);
 
   return result;
 }
 
-static uint32_t
-bare_buffer_typed_write_utf8(js_value_t *receiver, js_value_t *typedarray, js_value_t *string, js_typed_callback_info_t *info) {
+static int64_t
+bare_buffer_typed_write_utf8(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_value_t *string,
+  js_typed_callback_info_t *info
+) {
   int err;
 
   js_env_t *env;
   err = js_get_typed_callback_info(info, &env, NULL);
   assert(err == 0);
 
-  js_handle_scope_t *scope;
-  err = js_open_handle_scope(env, &scope);
-  assert(err == 0);
-
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, typedarray, NULL, &buf, &buf_len, NULL, NULL);
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   size_t str_len;
-  err = js_get_value_string_utf8(env, string, buf, buf_len, &str_len);
-  assert(err == 0);
-
-  err = js_close_handle_scope(env, scope);
+  err = js_get_value_string_utf8(env, string, &buf[offset], len, &str_len);
   assert(err == 0);
 
-  return (uint32_t) str_len;
+  return str_len;
 }
 
 static js_value_t *
 bare_buffer_write_utf8(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  size_t argc = 4;
+  js_value_t *argv[4];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 2);
+  assert(argc == 4);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, &buf, &buf_len, NULL, NULL);
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
+
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   size_t str_len;
-  err = js_get_value_string_utf8(env, argv[1], buf, buf_len, &str_len);
+  err = js_get_value_string_utf8(env, argv[3], &buf[offset], len, &str_len);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_uint32(env, (uint32_t) str_len, &result);
+  err = js_create_int64(env, str_len, &result);
   assert(err == 0);
 
   return result;
@@ -192,86 +205,102 @@ static js_value_t *
 bare_buffer_to_string_utf16le(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 3);
 
   utf16_t *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &buf, &buf_len, NULL, NULL);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
   assert(err == 0);
 
-  buf_len /= sizeof(utf16_t);
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
+  assert(err == 0);
+
+  offset /= sizeof(utf16_t);
+  len /= sizeof(utf16_t);
 
   js_value_t *result;
-  err = js_create_string_utf16le(env, buf, buf_len, &result);
+  err = js_create_string_utf16le(env, &buf[offset], len, &result);
   assert(err == 0);
 
   return result;
 }
 
-static uint32_t
-bare_buffer_typed_write_utf16le(js_value_t *receiver, js_value_t *typedarray, js_value_t *string, js_typed_callback_info_t *info) {
+static int64_t
+bare_buffer_typed_write_utf16le(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_value_t *string,
+  js_typed_callback_info_t *info
+) {
   int err;
 
   js_env_t *env;
   err = js_get_typed_callback_info(info, &env, NULL);
   assert(err == 0);
 
-  js_handle_scope_t *scope;
-  err = js_open_handle_scope(env, &scope);
-  assert(err == 0);
-
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, typedarray, NULL, &buf, &buf_len, NULL, NULL);
+  utf16_t *buf;
+  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
-  buf_len /= sizeof(utf16_t);
+  offset /= sizeof(utf16_t);
+  len /= sizeof(utf16_t);
 
   size_t str_len;
-  err = js_get_value_string_utf16le(env, string, buf, buf_len, &str_len);
+  err = js_get_value_string_utf16le(env, string, &buf[offset], len, &str_len);
   assert(err == 0);
 
   str_len *= sizeof(utf16_t);
 
-  err = js_close_handle_scope(env, scope);
-  assert(err == 0);
-
-  return (uint32_t) str_len;
+  return str_len;
 }
 
 static js_value_t *
 bare_buffer_write_utf16le(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  size_t argc = 4;
+  js_value_t *argv[4];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 2);
+  assert(argc == 4);
+
+  utf16_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, &buf, &buf_len, NULL, NULL);
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
   assert(err == 0);
 
-  buf_len /= sizeof(utf16_t);
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
+  assert(err == 0);
+
+  offset /= sizeof(utf16_t);
+  len /= sizeof(utf16_t);
 
   size_t str_len;
-  err = js_get_value_string_utf16le(env, argv[1], buf, buf_len, &str_len);
+  err = js_get_value_string_utf16le(env, argv[3], &buf[offset], len, &str_len);
   assert(err == 0);
 
   str_len *= sizeof(utf16_t);
 
   js_value_t *result;
-  err = js_create_uint32(env, (uint32_t) str_len, &result);
+  err = js_create_int64(env, str_len, &result);
   assert(err == 0);
 
   return result;
@@ -281,128 +310,189 @@ static js_value_t *
 bare_buffer_to_string_latin1(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 3);
 
   latin1_t *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, (void **) &buf, &buf_len, NULL, NULL);
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
+
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_string_latin1(env, buf, buf_len, &result);
+  err = js_create_string_latin1(env, &buf[offset], len, &result);
   assert(err == 0);
 
   return result;
 }
 
-static uint32_t
-bare_buffer_typed_write_latin1(js_value_t *receiver, js_value_t *typedarray, js_value_t *string, js_typed_callback_info_t *info) {
+static int64_t
+bare_buffer_typed_write_latin1(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_value_t *string,
+  js_typed_callback_info_t *info
+) {
   int err;
 
   js_env_t *env;
   err = js_get_typed_callback_info(info, &env, NULL);
   assert(err == 0);
 
-  js_handle_scope_t *scope;
-  err = js_open_handle_scope(env, &scope);
+  latin1_t *buf;
+  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
+  assert(err == 0);
+
+  size_t str_len;
+  err = js_get_value_string_latin1(env, string, &buf[offset], len, &str_len);
+  assert(err == 0);
+
+  return str_len;
+}
+
+static js_value_t *
+bare_buffer_write_latin1(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 4;
+  js_value_t *argv[4];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 4);
+
+  latin1_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
   assert(err == 0);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, typedarray, NULL, &buf, &buf_len, NULL, NULL);
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   size_t str_len;
-  err = js_get_value_string_latin1(env, string, buf, buf_len, &str_len);
+  err = js_get_value_string_latin1(env, argv[3], &buf[offset], len, &str_len);
   assert(err == 0);
 
-  err = js_close_handle_scope(env, scope);
+  js_value_t *result;
+  err = js_create_int64(env, str_len, &result);
   assert(err == 0);
 
-  return (uint32_t) str_len;
+  return result;
 }
 
 static js_value_t *
-bare_buffer_write_latin1(js_env_t *env, js_callback_info_t *info) {
+bare_buffer_to_string_base64(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 2);
+  assert(argc == 3);
+
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, &buf, &buf_len, NULL, NULL);
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   size_t str_len;
-  err = js_get_value_string_latin1(env, argv[1], buf, buf_len, &str_len);
+  err = base64_encode_utf8(&buf[offset], len, NULL, &str_len);
+  assert(err == 0);
+
+  utf8_t *str = malloc(str_len);
+  err = base64_encode_utf8(&buf[offset], len, str, &str_len);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_uint32(env, (uint32_t) str_len, &result);
+  err = js_create_external_string_latin1(env, str, str_len, bare_buffer__on_finalize_string, NULL, &result, NULL);
   assert(err == 0);
 
   return result;
 }
 
 static js_value_t *
-bare_buffer_to_string_base64(js_env_t *env, js_callback_info_t *info) {
+bare_buffer_to_string_base64url(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 3);
+
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, &buf, &buf_len, NULL, NULL);
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   size_t str_len;
-  err = base64_encode_utf8(buf, buf_len, NULL, &str_len);
+  err = base64url_encode_utf8(&buf[offset], len, NULL, &str_len);
   assert(err == 0);
 
   utf8_t *str = malloc(str_len);
-  err = base64_encode_utf8(buf, buf_len, str, &str_len);
+  err = base64url_encode_utf8(&buf[offset], len, str, &str_len);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_external_string_latin1(env, str, str_len, bare_buffer__on_free_string, NULL, &result, NULL);
+  err = js_create_external_string_latin1(env, str, str_len, bare_buffer__on_finalize_string, NULL, &result, NULL);
   assert(err == 0);
 
   return result;
 }
 
-static uint32_t
-bare_buffer_typed_write_base64(js_value_t *receiver, js_value_t *typedarray, js_value_t *string, js_typed_callback_info_t *info) {
+static int64_t
+bare_buffer_typed_write_base64(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_value_t *string,
+  js_typed_callback_info_t *info
+) {
   int err;
 
   js_env_t *env;
   err = js_get_typed_callback_info(info, &env, NULL);
   assert(err == 0);
 
-  js_handle_scope_t *scope;
-  err = js_open_handle_scope(env, &scope);
-  assert(err == 0);
-
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, typedarray, NULL, &buf, &buf_len, NULL, NULL);
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   js_string_encoding_t encoding;
@@ -413,38 +503,52 @@ bare_buffer_typed_write_base64(js_value_t *receiver, js_value_t *typedarray, js_
   err = js_get_string_view(env, string, &encoding, &str, &str_len, &str_view);
   assert(err == 0);
 
+  size_t written = len;
+
   if (encoding == js_utf16le) {
-    err = base64_decode_utf16le(str, str_len, buf, &buf_len);
-    assert(err == 0);
+    err = base64_decode_utf16le(str, str_len, &buf[offset], &written);
   } else {
-    err = base64_decode_utf8(str, str_len, buf, &buf_len);
+    err = base64_decode_utf8(str, str_len, &buf[offset], &written);
+  }
+
+  if (err != 0) {
+    err = js_throw_error(env, NULL, "Invalid input");
+    assert(err == 0);
+
+    err = js_release_string_view(env, str_view);
     assert(err == 0);
+
+    return 0;
   }
 
   err = js_release_string_view(env, str_view);
   assert(err == 0);
 
-  err = js_close_handle_scope(env, scope);
-  assert(err == 0);
-
-  return buf_len;
+  return written;
 }
 
 static js_value_t *
 bare_buffer_write_base64(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  size_t argc = 4;
+  js_value_t *argv[4];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 2);
+  assert(argc == 4);
+
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, &buf, &buf_len, NULL, NULL);
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   js_string_encoding_t encoding;
@@ -452,22 +556,32 @@ bare_buffer_write_base64(js_env_t *env, js_callback_info_t *info) {
   size_t str_len;
 
   js_string_view_t *str_view;
-  err = js_get_string_view(env, argv[1], &encoding, &str, &str_len, &str_view);
+  err = js_get_string_view(env, argv[3], &encoding, &str, &str_len, &str_view);
   assert(err == 0);
 
+  size_t written = len;
+
   if (encoding == js_utf16le) {
-    err = base64_decode_utf16le(str, str_len, buf, &buf_len);
-    assert(err == 0);
+    err = base64_decode_utf16le(str, str_len, &buf[offset], &written);
   } else {
-    err = base64_decode_utf8(str, str_len, buf, &buf_len);
+    err = base64_decode_utf8(str, str_len, &buf[offset], &written);
+  }
+
+  if (err != 0) {
+    err = js_throw_error(env, NULL, "Invalid input");
     assert(err == 0);
+
+    err = js_release_string_view(env, str_view);
+    assert(err == 0);
+
+    return NULL;
   }
 
   err = js_release_string_view(env, str_view);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_uint32(env, (uint32_t) buf_len, &result);
+  err = js_create_int64(env, written, &result);
   assert(err == 0);
 
   return result;
@@ -477,49 +591,58 @@ static js_value_t *
 bare_buffer_to_string_hex(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 3);
+
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, &buf, &buf_len, NULL, NULL);
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   size_t str_len;
-  err = hex_encode_utf8(buf, buf_len, NULL, &str_len);
+  err = hex_encode_utf8(&buf[offset], len, NULL, &str_len);
   assert(err == 0);
 
   utf8_t *str = malloc(str_len);
-  err = hex_encode_utf8(buf, buf_len, str, &str_len);
+  err = hex_encode_utf8(&buf[offset], len, str, &str_len);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_external_string_latin1(env, str, str_len, bare_buffer__on_free_string, NULL, &result, NULL);
+  err = js_create_external_string_latin1(env, str, str_len, bare_buffer__on_finalize_string, NULL, &result, NULL);
   assert(err == 0);
 
   return result;
 }
 
-static uint32_t
-bare_buffer_typed_write_hex(js_value_t *receiver, js_value_t *typedarray, js_value_t *string, js_typed_callback_info_t *info) {
+static int64_t
+bare_buffer_typed_write_hex(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_value_t *string,
+  js_typed_callback_info_t *info
+) {
   int err;
 
   js_env_t *env;
   err = js_get_typed_callback_info(info, &env, NULL);
   assert(err == 0);
 
-  js_handle_scope_t *scope;
-  err = js_open_handle_scope(env, &scope);
-  assert(err == 0);
-
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, typedarray, NULL, &buf, &buf_len, NULL, NULL);
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, handle, (void **) &buf, NULL);
   assert(err == 0);
 
   js_string_encoding_t encoding;
@@ -530,38 +653,52 @@ bare_buffer_typed_write_hex(js_value_t *receiver, js_value_t *typedarray, js_val
   err = js_get_string_view(env, string, &encoding, &str, &str_len, &str_view);
   assert(err == 0);
 
+  size_t written = len;
+
   if (encoding == js_utf16le) {
-    err = hex_decode_utf16le(str, str_len, buf, &buf_len);
-    assert(err == 0);
+    err = hex_decode_utf16le(str, str_len, &buf[offset], &written);
   } else {
-    err = hex_decode_utf8(str, str_len, buf, &buf_len);
+    err = hex_decode_utf8(str, str_len, &buf[offset], &written);
+  }
+
+  if (err != 0) {
+    err = js_throw_error(env, NULL, "Invalid input");
     assert(err == 0);
+
+    err = js_release_string_view(env, str_view);
+    assert(err == 0);
+
+    return 0;
   }
 
   err = js_release_string_view(env, str_view);
   assert(err == 0);
 
-  err = js_close_handle_scope(env, scope);
-  assert(err == 0);
-
-  return buf_len;
+  return written;
 }
 
 static js_value_t *
 bare_buffer_write_hex(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  size_t argc = 4;
+  js_value_t *argv[4];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 2);
+  assert(argc == 4);
 
-  void *buf;
-  size_t buf_len;
-  err = js_get_typedarray_info(env, argv[0], NULL, &buf, &buf_len, NULL, NULL);
+  utf8_t *buf;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &buf, NULL);
+  assert(err == 0);
+
+  int64_t offset;
+  err = js_get_value_int64(env, argv[1], &offset);
+  assert(err == 0);
+
+  int64_t len;
+  err = js_get_value_int64(env, argv[2], &len);
   assert(err == 0);
 
   js_string_encoding_t encoding;
@@ -569,22 +706,32 @@ bare_buffer_write_hex(js_env_t *env, js_callback_info_t *info) {
   size_t str_len;
 
   js_string_view_t *str_view;
-  err = js_get_string_view(env, argv[1], &encoding, &str, &str_len, &str_view);
+  err = js_get_string_view(env, argv[3], &encoding, &str, &str_len, &str_view);
   assert(err == 0);
 
+  size_t written = len;
+
   if (encoding == js_utf16le) {
-    err = hex_decode_utf16le(str, str_len, buf, &buf_len);
-    assert(err == 0);
+    err = hex_decode_utf16le(str, str_len, &buf[offset], &written);
   } else {
-    err = hex_decode_utf8(str, str_len, buf, &buf_len);
+    err = hex_decode_utf8(str, str_len, &buf[offset], &written);
+  }
+
+  if (err != 0) {
+    err = js_throw_error(env, NULL, "Invalid input");
+    assert(err == 0);
+
+    err = js_release_string_view(env, str_view);
     assert(err == 0);
+
+    return NULL;
   }
 
   err = js_release_string_view(env, str_view);
   assert(err == 0);
 
   js_value_t *result;
-  err = js_create_uint32(env, (uint32_t) buf_len, &result);
+  err = js_create_int64(env, written, &result);
   assert(err == 0);
 
   return result;
@@ -594,11 +741,11 @@ static int32_t
 bare_buffer_typed_compare(
   js_value_t *receiver,
   js_value_t *a_handle,
-  uint32_t a_offset,
-  uint32_t a_len,
+  int64_t a_offset,
+  int64_t a_len,
   js_value_t *b_handle,
-  uint32_t b_offset,
-  uint32_t b_len,
+  int64_t b_offset,
+  int64_t b_len,
   js_typed_callback_info_t *info
 ) {
   int err;
@@ -607,12 +754,12 @@ bare_buffer_typed_compare(
   err = js_get_typed_callback_info(info, &env, NULL);
   assert(err == 0);
 
-  void *a;
-  err = js_get_arraybuffer_info(env, a_handle, &a, NULL);
+  uint8_t *a;
+  err = js_get_arraybuffer_info(env, a_handle, (void **) &a, NULL);
   assert(err == 0);
 
-  void *b;
-  err = js_get_arraybuffer_info(env, b_handle, &b, NULL);
+  uint8_t *b;
+  err = js_get_arraybuffer_info(env, b_handle, (void **) &b, NULL);
   assert(err == 0);
 
   return bare_buffer__memcmp(&a[a_offset], a_len, &b[b_offset], b_len);
@@ -630,28 +777,28 @@ bare_buffer_compare(js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 6);
 
-  void *a;
-  err = js_get_arraybuffer_info(env, argv[0], &a, NULL);
+  uint8_t *a;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &a, NULL);
   assert(err == 0);
 
-  uint32_t a_offset;
-  err = js_get_value_uint32(env, argv[1], &a_offset);
+  int64_t a_offset;
+  err = js_get_value_int64(env, argv[1], &a_offset);
   assert(err == 0);
 
-  uint32_t a_len;
-  err = js_get_value_uint32(env, argv[2], &a_len);
+  int64_t a_len;
+  err = js_get_value_int64(env, argv[2], &a_len);
   assert(err == 0);
 
-  void *b;
-  err = js_get_arraybuffer_info(env, argv[3], &b, NULL);
+  uint8_t *b;
+  err = js_get_arraybuffer_info(env, argv[3], (void **) &b, NULL);
   assert(err == 0);
 
-  uint32_t b_offset;
-  err = js_get_value_uint32(env, argv[4], &b_offset);
+  int64_t b_offset;
+  err = js_get_value_int64(env, argv[4], &b_offset);
   assert(err == 0);
 
-  uint32_t b_len;
-  err = js_get_value_uint32(env, argv[5], &b_len);
+  int64_t b_len;
+  err = js_get_value_int64(env, argv[5], &b_len);
   assert(err == 0);
 
   js_value_t *result;
@@ -665,6 +812,37 @@ static js_value_t *
 bare_buffer_exports(js_env_t *env, js_value_t *exports) {
   int err;
 
+  js_value_t *constants;
+  err = js_create_object(env, &constants);
+  assert(err == 0);
+
+  err = js_set_named_property(env, exports, "constants", constants);
+  assert(err == 0);
+
+  js_platform_t *platform;
+  err = js_get_env_platform(env, &platform);
+  assert(err == 0);
+
+  js_platform_limits_t limits = {
+    .version = 0,
+  };
+
+  err = js_get_platform_limits(platform, &limits);
+  assert(err == 0);
+
+#define V(name, value) \
+  { \
+    js_value_t *val; \
+    err = js_create_int64(env, value, &val); \
+    assert(err == 0); \
+    err = js_set_named_property(env, constants, name, val); \
+    assert(err == 0); \
+  }
+
+  V("MAX_LENGTH", limits.arraybuffer_length);
+  V("MAX_STRING_LENGTH", limits.string_length);
+#undef V
+
 #define V(name, untyped, signature, typed) \
   { \
     js_value_t *val; \
@@ -688,7 +866,7 @@ bare_buffer_exports(js_env_t *env, js_value_t *exports) {
     bare_buffer_byte_length_utf8,
     &((js_callback_signature_t) {
       .version = 0,
-      .result = js_uint32,
+      .result = js_int64,
       .args_len = 2,
       .args = (int[]) {
         js_object,
@@ -705,11 +883,13 @@ bare_buffer_exports(js_env_t *env, js_value_t *exports) {
     bare_buffer_write_utf8,
     &((js_callback_signature_t) {
       .version = 0,
-      .result = js_uint32,
-      .args_len = 3,
+      .result = js_int64,
+      .args_len = 5,
       .args = (int[]) {
         js_object,
         js_object,
+        js_int64,
+        js_int64,
         js_string,
       }
     }),
@@ -723,7 +903,7 @@ bare_buffer_exports(js_env_t *env, js_value_t *exports) {
     bare_buffer_write_utf16le,
     &((js_callback_signature_t) {
       .version = 0,
-      .result = js_uint32,
+      .result = js_int64,
       .args_len = 3,
       .args = (int[]) {
         js_object,
@@ -741,11 +921,13 @@ bare_buffer_exports(js_env_t *env, js_value_t *exports) {
     bare_buffer_write_latin1,
     &((js_callback_signature_t) {
       .version = 0,
-      .result = js_uint32,
-      .args_len = 3,
+      .result = js_int64,
+      .args_len = 5,
       .args = (int[]) {
         js_object,
         js_object,
+        js_int64,
+        js_int64,
         js_string,
       }
     }),
@@ -753,17 +935,20 @@ bare_buffer_exports(js_env_t *env, js_value_t *exports) {
   );
 
   V("toStringBase64", bare_buffer_to_string_base64, NULL, NULL);
+  V("toStringBase64URL", bare_buffer_to_string_base64url, NULL, NULL);
 
   V(
     "writeBase64",
     bare_buffer_write_base64,
     &((js_callback_signature_t) {
       .version = 0,
-      .result = js_uint32,
-      .args_len = 3,
+      .result = js_int64,
+      .args_len = 5,
       .args = (int[]) {
         js_object,
         js_object,
+        js_int64,
+        js_int64,
         js_string,
       }
     }),
@@ -777,11 +962,13 @@ bare_buffer_exports(js_env_t *env, js_value_t *exports) {
     bare_buffer_write_hex,
     &((js_callback_signature_t) {
       .version = 0,
-      .result = js_uint32,
-      .args_len = 3,
+      .result = js_int64,
+      .args_len = 5,
       .args = (int[]) {
         js_object,
         js_object,
+        js_int64,
+        js_int64,
         js_string,
       }
     }),
@@ -798,11 +985,11 @@ bare_buffer_exports(js_env_t *env, js_value_t *exports) {
       .args = (int[]) {
         js_object,
         js_object,
-        js_uint32,
-        js_uint32,
+        js_int64,
+        js_int64,
         js_object,
-        js_uint32,
-        js_uint32,
+        js_int64,
+        js_int64,
       }
     }),
     bare_buffer_typed_compare

package/index.js

@@ -1,6 +1,7 @@
 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')
@@ -536,6 +537,7 @@ 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
@@ -548,7 +550,7 @@ function codecFor(encoding = 'utf8') {
 
   if (encoding in codecs) return codecs[encoding]
 
-  throw new Error(`Unknown encoding: ${encoding}`)
+  throw new Error(`Unknown encoding '${encoding}'`)
 }
 
 const views = new WeakMap()

package/lib/base64.js

@@ -9,6 +9,19 @@ exports.byteLength = function byteLength(string) {
   return (len * 3) >>> 2
 }
 
-exports.toString = binding.toStringBase64
+exports.toString = function toString(buffer) {
+  return binding.toStringBase64(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  )
+}
 
-exports.write = binding.writeBase64
+exports.write = function write(buffer, string) {
+  return binding.writeBase64(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength,
+    string
+  )
+}

package/lib/base64url.js

@@ -0,0 +1,27 @@
+const binding = require('../binding')
+
+exports.byteLength = function byteLength(string) {
+  let len = string.length
+
+  if (string.charCodeAt(len - 1) === 0x3d) len--
+  if (len > 1 && string.charCodeAt(len - 1) === 0x3d) len--
+
+  return (len * 3) >>> 2
+}
+
+exports.toString = function toString(buffer) {
+  return binding.toStringBase64URL(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  )
+}
+
+exports.write = function write(buffer, string) {
+  return binding.writeBase64(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength,
+    string
+  )
+}

package/lib/constants.js

@@ -1,4 +1,3 @@
-module.exports = {
-  MAX_LENGTH: 2 ** 32 - 1, // 4 GiB
-  MAX_STRING_LENGTH: 2 ** 28 - 16 // ~512 MiB, lowest common limit
-}
+const binding = require('../binding')
+
+module.exports = binding.constants

package/lib/hex.js

@@ -4,6 +4,19 @@ exports.byteLength = function byteLength(string) {
   return string.length >>> 1
 }
 
-exports.toString = binding.toStringHex
+exports.toString = function toString(buffer) {
+  return binding.toStringHex(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  )
+}
 
-exports.write = binding.writeHex
+exports.write = function write(buffer, string) {
+  return binding.writeHex(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength,
+    string
+  )
+}

package/lib/latin1.js

@@ -4,6 +4,19 @@ exports.byteLength = function byteLength(string) {
   return string.length
 }
 
-exports.toString = binding.toStringLatin1
+exports.toString = function toString(buffer) {
+  return binding.toStringLatin1(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  )
+}
 
-exports.write = binding.writeLatin1
+exports.write = function write(buffer, string) {
+  return binding.writeLatin1(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength,
+    string
+  )
+}

package/lib/utf16le.js

@@ -4,6 +4,19 @@ exports.byteLength = function byteLength(string) {
   return string.length * 2
 }
 
-exports.toString = binding.toStringUTF16LE
+exports.toString = function toString(buffer) {
+  return binding.toStringUTF16LE(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  )
+}
 
-exports.write = binding.writeUTF16LE
+exports.write = function write(buffer, string) {
+  return binding.writeUTF16LE(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength,
+    string
+  )
+}

package/lib/utf8.js

@@ -1,7 +1,22 @@
 const binding = require('../binding')
 
-exports.byteLength = binding.byteLengthUTF8
+exports.byteLength = function byteLength(string) {
+  return binding.byteLengthUTF8(string)
+}
 
-exports.toString = binding.toStringUTF8
+exports.toString = function toString(buffer) {
+  return binding.toStringUTF8(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength
+  )
+}
 
-exports.write = binding.writeUTF8
+exports.write = function write(buffer, string) {
+  return binding.writeUTF8(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength,
+    string
+  )
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-buffer",
-  "version": "3.1.4",
+  "version": "3.3.0",
   "description": "Native buffers for JavaScript",
   "exports": {
     "./package": "./package.json",
@@ -43,7 +43,7 @@
   },
   "homepage": "https://github.com/holepunchto/bare-buffer#readme",
   "engines": {
-    "bare": ">=1.13.0"
+    "bare": ">=1.20.0"
   },
   "devDependencies": {
     "brittle": "^3.1.1",