appium-mac2-driver 4.5.1 → 4.6.0

package/node_modules/bare-buffer/binding.c

@@ -0,0 +1,2041 @@
+#include <assert.h>
+#include <bare.h>
+#include <base64.h>
+#include <hex.h>
+#include <js.h>
+#include <stdatomic.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <utf.h>
+
+// Results up to this length are encoded on the stack, so that the common case
+// of a short hex or base64 string involves neither an allocation nor the
+// bookkeeping of an external string.
+#define BARE_BUFFER_STACK_STRING_MAX 1024
+
+// A buffer may be viewed at any byte offset, so the code units of a UTF-16
+// string are not necessarily aligned within its backing store. Spans that are
+// not are staged through an aligned copy.
+#define BARE_BUFFER_STACK_UTF16_MAX (BARE_BUFFER_STACK_STRING_MAX / sizeof(utf16_t))
+
+// A typed callback cannot raise, so an argument it rejects is reported as a
+// result no successful call can produce and JavaScript raises on it. There is
+// one sentinel per error the untyped callback raises directly, so that the
+// error does not change once V8 takes the fast path.
+#define BARE_BUFFER_OUT_OF_BOUNDS  INT32_MIN
+#define BARE_BUFFER_INVALID_BUFFER (INT32_MIN + 1)
+#define BARE_BUFFER_INVALID_STRING (INT32_MIN + 2)
+
+static inline bool
+bare_buffer__is_aligned(const void *data) {
+  return ((uintptr_t) data & (sizeof(utf16_t) - 1)) == 0;
+}
+
+static _Atomic size_t bare_buffer__max_arraybuffer_length;
+static _Atomic size_t bare_buffer__max_string_length;
+
+static inline void
+bare_buffer__read_limits(js_env_t *env) {
+  int err;
+
+  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);
+
+  atomic_store_explicit(&bare_buffer__max_arraybuffer_length, limits.arraybuffer_length, memory_order_relaxed);
+  atomic_store_explicit(&bare_buffer__max_string_length, limits.string_length, memory_order_relaxed);
+}
+
+static inline size_t
+bare_buffer__arraybuffer_limit(void) {
+  return atomic_load_explicit(&bare_buffer__max_arraybuffer_length, memory_order_relaxed);
+}
+
+static inline size_t
+bare_buffer__string_limit(void) {
+  return atomic_load_explicit(&bare_buffer__max_string_length, memory_order_relaxed);
+}
+
+// Nothing between here and the raising helpers below raises an error. A typed
+// callback is entered without a handle scope and V8 does not support reporting
+// errors from one, so raising there aborts the process. An argument that does
+// not check out is reported to the caller instead, and a condition that has to
+// reach JavaScript is returned as a negative count for the caller to raise.
+
+static inline bool
+bare_buffer__is_buffer(js_env_t *env, js_value_t *value) {
+  int err;
+
+  bool is_arraybuffer;
+  err = js_is_arraybuffer(env, value, &is_arraybuffer);
+  assert(err == 0);
+
+  if (is_arraybuffer) return true;
+
+  bool is_shared;
+  err = js_is_sharedarraybuffer(env, value, &is_shared);
+  assert(err == 0);
+
+  return is_shared;
+}
+
+static inline int
+bare_buffer__get_info(js_env_t *env, js_value_t *buffer, void **data, size_t *len) {
+  int err;
+
+  bool is_arraybuffer;
+  err = js_is_arraybuffer(env, buffer, &is_arraybuffer);
+  assert(err == 0);
+
+  if (is_arraybuffer) {
+    err = js_get_arraybuffer_info(env, buffer, data, len);
+    assert(err == 0);
+
+    return 0;
+  }
+
+  bool is_shared;
+  err = js_is_sharedarraybuffer(env, buffer, &is_shared);
+  assert(err == 0);
+
+  if (is_shared) {
+    err = js_get_sharedarraybuffer_info(env, buffer, data, len);
+    assert(err == 0);
+
+    return 0;
+  }
+
+  return -1;
+}
+
+static inline bool
+bare_buffer__is_string(js_env_t *env, js_value_t *value) {
+  int err;
+
+  bool is_string;
+  err = js_is_string(env, value, &is_string);
+  assert(err == 0);
+
+  return is_string;
+}
+
+// Returns 0, or the sentinel for the argument that did not check out.
+static inline int
+bare_buffer__slice(js_env_t *env, js_value_t *buffer, int64_t offset, int64_t len, void **data) {
+  int err;
+
+  void *base;
+  size_t byte_len;
+  err = bare_buffer__get_info(env, buffer, &base, &byte_len);
+  if (err < 0) return BARE_BUFFER_INVALID_BUFFER;
+
+  if (offset < 0 || len < 0 || (uint64_t) offset + (uint64_t) len > byte_len) {
+    return BARE_BUFFER_OUT_OF_BOUNDS;
+  }
+
+  // A detached or zero length store has no address, and the string and codec
+  // APIs read a null destination as a request for the length a write would need
+  // rather than as a write of no bytes.
+  static uint8_t nowhere;
+
+  // Only an empty store lacks an address, so the bounds check above has already
+  // narrowed the span to nothing and the single byte is never reached.
+  assert(base != NULL || len == 0);
+
+  *data = base == NULL ? &nowhere : (uint8_t *) base + offset;
+
+  return 0;
+}
+
+static inline int
+bare_buffer__alloc(size_t len, void **result) {
+  void *data = malloc(len);
+
+  if (data == NULL) return -1;
+
+  *result = data;
+
+  return 0;
+}
+
+static int64_t
+bare_buffer__write_utf8(js_env_t *env, js_value_t *string, utf8_t *buf, int64_t len) {
+  int err;
+
+  size_t str_len;
+  err = js_get_value_string_utf8(env, string, NULL, 0, &str_len);
+  assert(err == 0);
+
+  size_t written;
+
+  if (str_len <= (size_t) len) {
+    err = js_get_value_string_utf8(env, string, buf, str_len, &written);
+    assert(err == 0);
+
+    return written;
+  }
+
+  // A truncated write stops on a code point boundary, so it leaves at most the
+  // three bytes of an incomplete sequence. Keeping those is enough to undo the
+  // null terminator, which can only land among them.
+  size_t tail_at = (size_t) len - (len < 3 ? (size_t) len : 3);
+
+  utf8_t tail[3];
+  memcpy(tail, &buf[tail_at], (size_t) len - tail_at);
+
+  err = js_get_value_string_utf8(env, string, buf, len, &written);
+  assert(err == 0);
+
+  if (written < (size_t) len && written >= tail_at) {
+    memcpy(&buf[written], &tail[written - tail_at], (size_t) len - written);
+  }
+
+  return written;
+}
+
+static int64_t
+bare_buffer__write_latin1(js_env_t *env, js_value_t *string, latin1_t *buf, int64_t len) {
+  int err;
+
+  size_t str_len;
+  err = js_get_value_string_latin1(env, string, NULL, 0, &str_len);
+  assert(err == 0);
+
+  if (str_len > (size_t) len) str_len = len;
+
+  size_t written;
+  err = js_get_value_string_latin1(env, string, buf, str_len, &written);
+  assert(err == 0);
+
+  return written;
+}
+
+static int64_t
+bare_buffer__write_utf16le(js_env_t *env, js_value_t *string, uint8_t *bytes, int64_t len) {
+  int err;
+
+  size_t str_len;
+  err = js_get_value_string_utf16le(env, string, NULL, 0, &str_len);
+  assert(err == 0);
+
+  size_t capacity = (size_t) len / sizeof(utf16_t);
+
+  if (str_len > capacity) str_len = capacity;
+
+  size_t written;
+
+  if (bare_buffer__is_aligned(bytes)) {
+    err = js_get_value_string_utf16le(env, string, (utf16_t *) bytes, str_len, &written);
+    assert(err == 0);
+
+    return written * sizeof(utf16_t);
+  }
+
+  utf16_t stack[BARE_BUFFER_STACK_UTF16_MAX];
+  utf16_t *str = stack;
+
+  if (str_len > BARE_BUFFER_STACK_UTF16_MAX) {
+    err = bare_buffer__alloc(str_len * sizeof(utf16_t), (void **) &str);
+    if (err < 0) return -1;
+  }
+
+  err = js_get_value_string_utf16le(env, string, str, str_len, &written);
+  assert(err == 0);
+
+  memcpy(bytes, str, written * sizeof(utf16_t));
+
+  if (str != stack) free(str);
+
+  return written * sizeof(utf16_t);
+}
+
+static int64_t
+bare_buffer__write_base64(js_env_t *env, js_value_t *string, utf8_t *buf, int64_t len) {
+  int err;
+
+  js_string_encoding_t encoding;
+  const void *str;
+  size_t str_len;
+
+  js_string_view_t *str_view;
+  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, &written);
+  } else {
+    err = base64_decode_utf8(str, str_len, buf, &written);
+  }
+
+  int64_t decoded = err == 0 ? (int64_t) written : -1;
+
+  err = js_release_string_view(env, str_view);
+  assert(err == 0);
+
+  return decoded;
+}
+
+static int64_t
+bare_buffer__write_hex(js_env_t *env, js_value_t *string, utf8_t *buf, int64_t len) {
+  int err;
+
+  js_string_encoding_t encoding;
+  const void *str;
+  size_t str_len;
+
+  js_string_view_t *str_view;
+  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, &written);
+  } else {
+    err = hex_decode_utf8(str, str_len, buf, &written);
+  }
+
+  int64_t decoded = err == 0 ? (int64_t) written : -1;
+
+  err = js_release_string_view(env, str_view);
+  assert(err == 0);
+
+  return decoded;
+}
+
+static bool
+bare_buffer__check_buffer(js_env_t *env, js_value_t *value) {
+  int err;
+
+  if (bare_buffer__is_buffer(env, value)) return true;
+
+  err = js_throw_type_error(env, NULL, "Buffer must be an array buffer");
+  assert(err == 0);
+
+  return false;
+}
+
+static bool
+bare_buffer__check_number(js_env_t *env, js_value_t *value, const char *message) {
+  int err;
+
+  bool is_number;
+  err = js_is_number(env, value, &is_number);
+  assert(err == 0);
+
+  if (!is_number) {
+    err = js_throw_type_error(env, NULL, message);
+    assert(err == 0);
+  }
+
+  return is_number;
+}
+
+static bool
+bare_buffer__check_string(js_env_t *env, js_value_t *value, const char *message) {
+  int err;
+
+  if (bare_buffer__is_string(env, value)) return true;
+
+  err = js_throw_type_error(env, NULL, message);
+  assert(err == 0);
+
+  return false;
+}
+
+static js_value_t *
+bare_buffer__view_out_of_bounds(js_env_t *env) {
+  int err;
+
+  err = js_throw_range_error(env, NULL, "View is out of bounds of its backing store");
+  assert(err == 0);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_buffer__out_of_memory(js_env_t *env) {
+  int err;
+
+  err = js_throw_error(env, NULL, "Out of memory");
+  assert(err == 0);
+
+  return NULL;
+}
+
+static js_value_t *
+bare_buffer__invalid_string_length(js_env_t *env) {
+  int err;
+
+  err = js_throw_range_error(env, NULL, "Invalid string length");
+  assert(err == 0);
+
+  return NULL;
+}
+
+static inline int64_t
+bare_buffer__to_int64(js_env_t *env, js_value_t *value) {
+  int err;
+
+  int64_t result;
+  err = js_get_value_int64(env, value, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_buffer_alloc(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);
+
+  if (!bare_buffer__check_number(env, argv[0], "Length must be a number")) return NULL;
+
+  int64_t len = bare_buffer__to_int64(env, argv[0]);
+
+  if (len < 0) {
+    err = js_throw_range_error(env, NULL, "Length must not be negative");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  if ((uint64_t) len > bare_buffer__arraybuffer_limit()) {
+    err = js_throw_range_error(env, NULL, "Length must not exceed the maximum array buffer length");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  js_value_t *result;
+  err = js_create_arraybuffer(env, len, NULL, &result);
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+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);
+
+  if (!bare_buffer__check_number(env, argv[0], "Length must be a number")) return NULL;
+
+  int64_t len = bare_buffer__to_int64(env, argv[0]);
+
+  if (len < 0) {
+    err = js_throw_range_error(env, NULL, "Length must not be negative");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  if ((uint64_t) len > bare_buffer__arraybuffer_limit()) {
+    err = js_throw_range_error(env, NULL, "Length must not exceed the maximum array buffer length");
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  js_value_t *result;
+  err = js_create_unsafe_arraybuffer(env, len, NULL, &result);
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+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;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__is_string(env, str)) return BARE_BUFFER_INVALID_STRING;
+
+  size_t str_len;
+  err = js_get_value_string_utf8(env, str, NULL, 0, &str_len);
+  assert(err == 0);
+
+  return str_len;
+}
+
+static js_value_t *
+bare_buffer_byte_length_utf8(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);
+
+  if (!bare_buffer__check_string(env, argv[0], "String must be a string")) return NULL;
+
+  size_t str_len;
+  err = js_get_value_string_utf8(env, argv[0], NULL, 0, &str_len);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_int64(env, str_len, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_buffer_to_string_utf8(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err < 0) return bare_buffer__view_out_of_bounds(env);
+
+  js_value_t *result;
+  err = js_create_string_utf8(env, buf, len, &result);
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+static int32_t
+bare_buffer_typed_validate_utf8(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  return utf8_validate(buf, len);
+}
+
+static js_value_t *
+bare_buffer_validate_utf8(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int32_t valid = err == 0 ? utf8_validate(buf, len) : err;
+
+  js_value_t *result;
+  err = js_create_int32(env, valid, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+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);
+
+  if (!bare_buffer__is_buffer(env, handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_string(env, string)) return BARE_BUFFER_INVALID_STRING;
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  return bare_buffer__write_utf8(env, string, buf, len);
+}
+
+static js_value_t *
+bare_buffer_write_utf8(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);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_string(env, argv[3], "String must be a string")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int64_t written = err == 0 ? bare_buffer__write_utf8(env, argv[3], buf, len) : err;
+
+  js_value_t *result;
+  err = js_create_int64(env, written, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_buffer_to_string_utf16le(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  uint8_t *bytes;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &bytes);
+  if (err < 0) return bare_buffer__view_out_of_bounds(env);
+
+  size_t str_len = (size_t) len / sizeof(utf16_t);
+
+  if (str_len > bare_buffer__string_limit()) {
+    return bare_buffer__invalid_string_length(env);
+  }
+
+  js_value_t *result;
+
+  if (bare_buffer__is_aligned(bytes)) {
+    err = js_create_string_utf16le(env, (utf16_t *) bytes, str_len, &result);
+    if (err < 0) return NULL;
+
+    return result;
+  }
+
+  utf16_t stack[BARE_BUFFER_STACK_UTF16_MAX];
+  utf16_t *str = stack;
+
+  if (str_len > BARE_BUFFER_STACK_UTF16_MAX) {
+    err = bare_buffer__alloc(str_len * sizeof(utf16_t), (void **) &str);
+    if (err < 0) return bare_buffer__out_of_memory(env);
+  }
+
+  memcpy(str, bytes, str_len * sizeof(utf16_t));
+
+  err = js_create_string_utf16le(env, str, str_len, &result);
+
+  if (str != stack) free(str);
+
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+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);
+
+  if (!bare_buffer__is_buffer(env, handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_string(env, string)) return BARE_BUFFER_INVALID_STRING;
+
+  uint8_t *bytes;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &bytes);
+  if (err != 0) return err;
+
+  return bare_buffer__write_utf16le(env, string, bytes, len);
+}
+
+static js_value_t *
+bare_buffer_write_utf16le(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);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_string(env, argv[3], "String must be a string")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  uint8_t *bytes;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &bytes);
+
+  int64_t written = err == 0 ? bare_buffer__write_utf16le(env, argv[3], bytes, len) : err;
+
+  js_value_t *result;
+  err = js_create_int64(env, written, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_buffer_to_string_latin1(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  latin1_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err < 0) return bare_buffer__view_out_of_bounds(env);
+
+  js_value_t *result;
+  err = js_create_string_latin1(env, buf, len, &result);
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+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);
+
+  if (!bare_buffer__is_buffer(env, handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_string(env, string)) return BARE_BUFFER_INVALID_STRING;
+
+  latin1_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  return bare_buffer__write_latin1(env, string, buf, 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);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_string(env, argv[3], "String must be a string")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  latin1_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int64_t written = err == 0 ? bare_buffer__write_latin1(env, argv[3], buf, len) : err;
+
+  js_value_t *result;
+  err = js_create_int64(env, written, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_buffer_to_string_base64(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err < 0) return bare_buffer__view_out_of_bounds(env);
+
+  size_t str_len;
+  err = base64_encode_utf8(buf, len, NULL, &str_len);
+  assert(err == 0);
+
+  if (str_len > bare_buffer__string_limit()) {
+    return bare_buffer__invalid_string_length(env);
+  }
+
+  utf8_t stack[BARE_BUFFER_STACK_STRING_MAX];
+  utf8_t *str = stack;
+
+  if (str_len > sizeof(stack)) {
+    err = bare_buffer__alloc(str_len, (void **) &str);
+    if (err < 0) return bare_buffer__out_of_memory(env);
+  }
+
+  err = base64_encode_utf8(buf, len, str, &str_len);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_string_latin1(env, str, str_len, &result);
+
+  if (str != stack) free(str);
+
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+static js_value_t *
+bare_buffer_to_string_base64url(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err < 0) return bare_buffer__view_out_of_bounds(env);
+
+  size_t str_len;
+  err = base64url_encode_utf8(buf, len, NULL, &str_len);
+  assert(err == 0);
+
+  if (str_len > bare_buffer__string_limit()) {
+    return bare_buffer__invalid_string_length(env);
+  }
+
+  utf8_t stack[BARE_BUFFER_STACK_STRING_MAX];
+  utf8_t *str = stack;
+
+  if (str_len > sizeof(stack)) {
+    err = bare_buffer__alloc(str_len, (void **) &str);
+    if (err < 0) return bare_buffer__out_of_memory(env);
+  }
+
+  err = base64url_encode_utf8(buf, len, str, &str_len);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_string_latin1(env, str, str_len, &result);
+
+  if (str != stack) free(str);
+
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+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);
+
+  if (!bare_buffer__is_buffer(env, handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_string(env, string)) return BARE_BUFFER_INVALID_STRING;
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  return bare_buffer__write_base64(env, string, buf, len);
+}
+
+static js_value_t *
+bare_buffer_write_base64(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);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_string(env, argv[3], "String must be a string")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int64_t decoded = err == 0 ? bare_buffer__write_base64(env, argv[3], buf, len) : err;
+
+  js_value_t *result;
+  err = js_create_int64(env, decoded, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static js_value_t *
+bare_buffer_to_string_hex(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err < 0) return bare_buffer__view_out_of_bounds(env);
+
+  size_t str_len;
+  err = hex_encode_utf8(buf, len, NULL, &str_len);
+  assert(err == 0);
+
+  if (str_len > bare_buffer__string_limit()) {
+    return bare_buffer__invalid_string_length(env);
+  }
+
+  utf8_t stack[BARE_BUFFER_STACK_STRING_MAX];
+  utf8_t *str = stack;
+
+  if (str_len > sizeof(stack)) {
+    err = bare_buffer__alloc(str_len, (void **) &str);
+    if (err < 0) return bare_buffer__out_of_memory(env);
+  }
+
+  err = hex_encode_utf8(buf, len, str, &str_len);
+  assert(err == 0);
+
+  js_value_t *result;
+  err = js_create_string_latin1(env, str, str_len, &result);
+
+  if (str != stack) free(str);
+
+  if (err < 0) return NULL;
+
+  return result;
+}
+
+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);
+
+  if (!bare_buffer__is_buffer(env, handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_string(env, string)) return BARE_BUFFER_INVALID_STRING;
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  return bare_buffer__write_hex(env, string, buf, len);
+}
+
+static js_value_t *
+bare_buffer_write_hex(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);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_string(env, argv[3], "String must be a string")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  utf8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int64_t decoded = err == 0 ? bare_buffer__write_hex(env, argv[3], buf, len) : err;
+
+  js_value_t *result;
+  err = js_create_int64(env, decoded, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static int32_t
+bare_buffer_typed_validate_ascii(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  ascii_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  return ascii_validate(buf, len);
+}
+
+static js_value_t *
+bare_buffer_validate_ascii(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  ascii_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int32_t valid = err == 0 ? ascii_validate(buf, len) : err;
+
+  js_value_t *result;
+  err = js_create_int32(env, valid, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static inline void
+bare_buffer__swap16(uint8_t *data, size_t len) {
+  for (size_t i = 0; i + 1 < len; i += 2) {
+    uint8_t a = data[i];
+    data[i] = data[i + 1];
+    data[i + 1] = a;
+  }
+}
+
+static inline void
+bare_buffer__swap32(uint8_t *data, size_t len) {
+  for (size_t i = 0; i + 3 < len; i += 4) {
+    uint8_t a = data[i];
+    uint8_t b = data[i + 1];
+    data[i] = data[i + 3];
+    data[i + 1] = data[i + 2];
+    data[i + 2] = b;
+    data[i + 3] = a;
+  }
+}
+
+static inline void
+bare_buffer__swap64(uint8_t *data, size_t len) {
+  for (size_t i = 0; i + 7 < len; i += 8) {
+    for (size_t j = 0; j < 4; j++) {
+      uint8_t a = data[i + j];
+      data[i + j] = data[i + 7 - j];
+      data[i + 7 - j] = a;
+    }
+  }
+}
+
+static const uint8_t *
+bare_buffer__memrchr(const uint8_t *data, uint8_t c, size_t len) {
+  const size_t chunk_len = 512;
+
+  while (len > 0) {
+    size_t take = len < chunk_len ? len : chunk_len;
+
+    const uint8_t *chunk = &data[len - take];
+
+    // When matches are dense the last one is within a few bytes of the end,
+    // which is far cheaper to find by looking than by narrowing.
+    size_t probe = take < 8 ? take : 8;
+
+    for (size_t i = 0; i < probe; i++) {
+      if (chunk[take - 1 - i] == c) return &chunk[take - 1 - i];
+    }
+
+    if (memchr(chunk, c, take - probe) != NULL) {
+      size_t lo = 0;
+      size_t hi = take - probe;
+
+      while (hi - lo > 1) {
+        size_t mid = lo + (hi - lo) / 2;
+
+        if (memchr(&chunk[mid], c, hi - mid) != NULL) lo = mid;
+        else hi = mid;
+      }
+
+      return &chunk[lo];
+    }
+
+    len -= take;
+  }
+
+  return NULL;
+}
+
+static int64_t
+bare_buffer__index_of(const uint8_t *data, size_t len, const uint8_t *needle, size_t needle_len, int64_t start) {
+  if (needle_len == 0 || needle_len > len) return -1;
+
+  // Compared before narrowing, so that a start past the end cannot wrap into a
+  // valid position on a target where size_t is narrower than int64_t.
+  if (start < 0 || (uint64_t) start > len - needle_len) return -1;
+
+  size_t from = (size_t) start;
+
+  if (needle_len == 1) {
+    const uint8_t *at = memchr(&data[from], needle[0], len - from);
+
+    return at == NULL ? -1 : (int64_t) (at - data);
+  }
+
+  size_t end = len - needle_len + 1;
+  size_t i = from;
+  size_t rejected = 0;
+
+  while (i < end) {
+    const uint8_t *at = memchr(&data[i], needle[0], end - i);
+
+    if (at == NULL) return -1;
+
+    i = (size_t) (at - data);
+
+    if (memcmp(&data[i + 1], &needle[1], needle_len - 1) == 0) return (int64_t) i;
+
+    i++;
+
+    if (++rejected == 32) break;
+  }
+
+  if (i >= end) return -1;
+
+  size_t skip[256];
+
+  for (size_t j = 0; j < 256; j++) {
+    skip[j] = needle_len;
+  }
+
+  for (size_t j = 0; j < needle_len - 1; j++) {
+    skip[needle[j]] = needle_len - 1 - j;
+  }
+
+  size_t last = needle_len - 1;
+
+  while (i < end) {
+    if (data[i + last] == needle[last] && memcmp(&data[i], needle, last) == 0) {
+      return (int64_t) i;
+    }
+
+    i += skip[data[i + last]];
+  }
+
+  return -1;
+}
+
+static int64_t
+bare_buffer__last_index_of(const uint8_t *data, size_t len, const uint8_t *needle, size_t needle_len, int64_t start) {
+  if (needle_len == 0 || needle_len > len) return -1;
+
+  // A start before the first byte names no position, the same reading that has
+  // the forward search report no match for a start past the last one.
+  if (start < 0) return -1;
+
+  size_t last = len - needle_len;
+  size_t from = (uint64_t) start > last ? last : (size_t) start;
+
+  if (needle_len == 1) {
+    const uint8_t *at = bare_buffer__memrchr(data, needle[0], from + 1);
+
+    return at == NULL ? -1 : (int64_t) (at - data);
+  }
+
+  size_t i = from;
+  size_t rejected = 0;
+
+  while (rejected < 32) {
+    const uint8_t *at = bare_buffer__memrchr(data, needle[0], i + 1);
+
+    if (at == NULL) return -1;
+
+    i = (size_t) (at - data);
+
+    if (memcmp(&data[i + 1], &needle[1], needle_len - 1) == 0) return (int64_t) i;
+
+    if (i == 0) return -1;
+
+    i--;
+    rejected++;
+  }
+
+  size_t skip[256];
+
+  for (size_t j = 0; j < 256; j++) {
+    skip[j] = needle_len;
+  }
+
+  for (size_t j = needle_len - 1; j >= 1; j--) {
+    skip[needle[j]] = j;
+  }
+
+  while (true) {
+    if (data[i] == needle[0] && memcmp(&data[i + 1], &needle[1], needle_len - 1) == 0) {
+      return (int64_t) i;
+    }
+
+    size_t shift = skip[data[i]];
+
+    if (i < shift) return -1;
+
+    i -= shift;
+  }
+}
+
+static inline int
+bare_buffer__memcmp(void *a, size_t a_len, void *b, size_t b_len) {
+  int r = memcmp(a, b, a_len < b_len ? a_len : b_len);
+
+  if (r == 0) {
+    if (a_len < b_len) return -1;
+    if (a_len > b_len) return 1;
+    return 0;
+  }
+
+  return r < 0 ? -1 : 1;
+}
+
+static int32_t
+bare_buffer_typed_compare(
+  js_value_t *receiver,
+  js_value_t *a_handle,
+  int64_t a_offset,
+  int64_t a_len,
+  js_value_t *b_handle,
+  int64_t b_offset,
+  int64_t b_len,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__is_buffer(env, a_handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_buffer(env, b_handle)) return BARE_BUFFER_INVALID_BUFFER;
+
+  uint8_t *a;
+  err = bare_buffer__slice(env, a_handle, a_offset, a_len, (void **) &a);
+  if (err != 0) return err;
+
+  uint8_t *b;
+  err = bare_buffer__slice(env, b_handle, b_offset, b_len, (void **) &b);
+  if (err != 0) return err;
+
+  return bare_buffer__memcmp(a, a_len, b, b_len);
+}
+
+static js_value_t *
+bare_buffer_compare(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 6;
+  js_value_t *argv[6];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_buffer(env, argv[3])) return NULL;
+  if (!bare_buffer__check_number(env, argv[4], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[5], "Length must be a number")) return NULL;
+
+  int64_t a_offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t a_len = bare_buffer__to_int64(env, argv[2]);
+  int64_t b_offset = bare_buffer__to_int64(env, argv[4]);
+  int64_t b_len = bare_buffer__to_int64(env, argv[5]);
+
+  uint8_t *a;
+  err = bare_buffer__slice(env, argv[0], a_offset, a_len, (void **) &a);
+
+  int32_t comparison = err;
+
+  if (err == 0) {
+    uint8_t *b;
+    err = bare_buffer__slice(env, argv[3], b_offset, b_len, (void **) &b);
+
+    comparison = err == 0 ? bare_buffer__memcmp(a, a_len, b, b_len) : err;
+  }
+
+  js_value_t *result;
+  err = js_create_int32(env, comparison, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static int32_t
+bare_buffer_typed_swap16(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  bare_buffer__swap16(buf, len);
+
+  return 0;
+}
+
+static js_value_t *
+bare_buffer_swap16(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  if (err == 0) bare_buffer__swap16(buf, len);
+
+  int32_t swapped = err;
+
+  js_value_t *result;
+  err = js_create_int32(env, swapped, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static int32_t
+bare_buffer_typed_swap32(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  bare_buffer__swap32(buf, len);
+
+  return 0;
+}
+
+static js_value_t *
+bare_buffer_swap32(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  if (err == 0) bare_buffer__swap32(buf, len);
+
+  int32_t swapped = err;
+
+  js_value_t *result;
+  err = js_create_int32(env, swapped, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static int32_t
+bare_buffer_typed_swap64(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  bare_buffer__swap64(buf, len);
+
+  return 0;
+}
+
+static js_value_t *
+bare_buffer_swap64(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  if (err == 0) bare_buffer__swap64(buf, len);
+
+  int32_t swapped = err;
+
+  js_value_t *result;
+  err = js_create_int32(env, swapped, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static int64_t
+bare_buffer_typed_index_of(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_value_t *needle_handle,
+  int64_t needle_offset,
+  int64_t needle_len,
+  int64_t from,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__is_buffer(env, handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_buffer(env, needle_handle)) return BARE_BUFFER_INVALID_BUFFER;
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  uint8_t *needle;
+  err = bare_buffer__slice(env, needle_handle, needle_offset, needle_len, (void **) &needle);
+  if (err != 0) return err;
+
+  return bare_buffer__index_of(buf, len, needle, needle_len, from);
+}
+
+static js_value_t *
+bare_buffer_index_of(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 7;
+  js_value_t *argv[7];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  if (!bare_buffer__check_buffer(env, argv[3])) return NULL;
+  if (!bare_buffer__check_number(env, argv[4], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[5], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[6], "Start must be a number")) return NULL;
+
+  int64_t needle_offset = bare_buffer__to_int64(env, argv[4]);
+  int64_t needle_len = bare_buffer__to_int64(env, argv[5]);
+  int64_t from = bare_buffer__to_int64(env, argv[6]);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int64_t at = err;
+
+  if (err == 0) {
+    uint8_t *needle;
+    err = bare_buffer__slice(env, argv[3], needle_offset, needle_len, (void **) &needle);
+
+    at = err == 0 ? bare_buffer__index_of(buf, len, needle, needle_len, from) : err;
+  }
+
+  js_value_t *result;
+  err = js_create_int64(env, at, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+static int64_t
+bare_buffer_typed_last_index_of(
+  js_value_t *receiver,
+  js_value_t *handle,
+  int64_t offset,
+  int64_t len,
+  js_value_t *needle_handle,
+  int64_t needle_offset,
+  int64_t needle_len,
+  int64_t from,
+  js_typed_callback_info_t *info
+) {
+  int err;
+
+  js_env_t *env;
+  err = js_get_typed_callback_info(info, &env, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__is_buffer(env, handle)) return BARE_BUFFER_INVALID_BUFFER;
+  if (!bare_buffer__is_buffer(env, needle_handle)) return BARE_BUFFER_INVALID_BUFFER;
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, handle, offset, len, (void **) &buf);
+  if (err != 0) return err;
+
+  uint8_t *needle;
+  err = bare_buffer__slice(env, needle_handle, needle_offset, needle_len, (void **) &needle);
+  if (err != 0) return err;
+
+  return bare_buffer__last_index_of(buf, len, needle, needle_len, from);
+}
+
+static js_value_t *
+bare_buffer_last_index_of(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 7;
+  js_value_t *argv[7];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  if (!bare_buffer__check_buffer(env, argv[0])) return NULL;
+  if (!bare_buffer__check_number(env, argv[1], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[2], "Length must be a number")) return NULL;
+
+  int64_t offset = bare_buffer__to_int64(env, argv[1]);
+  int64_t len = bare_buffer__to_int64(env, argv[2]);
+
+  if (!bare_buffer__check_buffer(env, argv[3])) return NULL;
+  if (!bare_buffer__check_number(env, argv[4], "Offset must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[5], "Length must be a number")) return NULL;
+  if (!bare_buffer__check_number(env, argv[6], "Start must be a number")) return NULL;
+
+  int64_t needle_offset = bare_buffer__to_int64(env, argv[4]);
+  int64_t needle_len = bare_buffer__to_int64(env, argv[5]);
+  int64_t from = bare_buffer__to_int64(env, argv[6]);
+
+  uint8_t *buf;
+  err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+
+  int64_t at = err;
+
+  if (err == 0) {
+    uint8_t *needle;
+    err = bare_buffer__slice(env, argv[3], needle_offset, needle_len, (void **) &needle);
+
+    at = err == 0 ? bare_buffer__last_index_of(buf, len, needle, needle_len, from) : err;
+  }
+
+  js_value_t *result;
+  err = js_create_int64(env, at, &result);
+  assert(err == 0);
+
+  return result;
+}
+
+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);
+
+  bare_buffer__read_limits(env);
+
+#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", bare_buffer__arraybuffer_limit());
+  V("MAX_STRING_LENGTH", bare_buffer__string_limit());
+#undef V
+
+#define V(name, untyped, signature, typed) \
+  { \
+    js_value_t *val; \
+    if (signature) { \
+      err = js_create_typed_function(env, name, -1, untyped, signature, typed, NULL, &val); \
+      assert(err == 0); \
+    } else { \
+      err = js_create_function(env, name, -1, untyped, NULL, &val); \
+      assert(err == 0); \
+    } \
+    err = js_set_named_property(env, exports, name, val); \
+    assert(err == 0); \
+  }
+
+  V("alloc", bare_buffer_alloc, NULL, NULL);
+
+  V("allocUnsafe", bare_buffer_alloc_unsafe, NULL, NULL);
+
+  V(
+    "byteLengthUTF8",
+    bare_buffer_byte_length_utf8,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int64,
+      .args_len = 2,
+      .args = (int[]){
+        js_object,
+        js_string,
+      }
+    }),
+    bare_buffer_typed_byte_length_utf8
+  );
+
+  V("toStringUTF8", bare_buffer_to_string_utf8, NULL, NULL);
+
+  V(
+    "validateUTF8",
+    bare_buffer_validate_utf8,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int32,
+      .args_len = 4,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_validate_utf8
+  );
+
+  V(
+    "writeUTF8",
+    bare_buffer_write_utf8,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int64,
+      .args_len = 5,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_string,
+      }
+    }),
+    bare_buffer_typed_write_utf8
+  );
+
+  V("toStringUTF16LE", bare_buffer_to_string_utf16le, NULL, NULL);
+
+  V(
+    "writeUTF16LE",
+    bare_buffer_write_utf16le,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int64,
+      .args_len = 5,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_string,
+      }
+    }),
+    bare_buffer_typed_write_utf16le
+  );
+
+  V("toStringLatin1", bare_buffer_to_string_latin1, NULL, NULL);
+
+  V(
+    "writeLatin1",
+    bare_buffer_write_latin1,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int64,
+      .args_len = 5,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_string,
+      }
+    }),
+    bare_buffer_typed_write_latin1
+  );
+
+  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_int64,
+      .args_len = 5,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_string,
+      }
+    }),
+    bare_buffer_typed_write_base64
+  );
+
+  V("toStringHex", bare_buffer_to_string_hex, NULL, NULL);
+
+  V(
+    "writeHex",
+    bare_buffer_write_hex,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int64,
+      .args_len = 5,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_string,
+      }
+    }),
+    bare_buffer_typed_write_hex
+  );
+
+  V(
+    "validateAscii",
+    bare_buffer_validate_ascii,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int32,
+      .args_len = 4,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_validate_ascii
+  );
+
+  V(
+    "swap16",
+    bare_buffer_swap16,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int32,
+      .args_len = 4,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_swap16
+  );
+
+  V(
+    "swap32",
+    bare_buffer_swap32,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int32,
+      .args_len = 4,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_swap32
+  );
+
+  V(
+    "swap64",
+    bare_buffer_swap64,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int32,
+      .args_len = 4,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_swap64
+  );
+
+  V(
+    "indexOf",
+    bare_buffer_index_of,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int64,
+      .args_len = 8,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_object,
+        js_int64,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_index_of
+  );
+
+  V(
+    "lastIndexOf",
+    bare_buffer_last_index_of,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int64,
+      .args_len = 8,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_object,
+        js_int64,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_last_index_of
+  );
+
+  V(
+    "compare",
+    bare_buffer_compare,
+    &((js_callback_signature_t){
+      .version = 0,
+      .result = js_int32,
+      .args_len = 7,
+      .args = (int[]){
+        js_object,
+        js_object,
+        js_int64,
+        js_int64,
+        js_object,
+        js_int64,
+        js_int64,
+      }
+    }),
+    bare_buffer_typed_compare
+  );
+#undef V
+
+  return exports;
+}
+
+BARE_MODULE(bare_buffer, bare_buffer_exports)