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

package/binding.c

@@ -0,0 +1,1077 @@
+#include <assert.h>
+#include <node_api.h>
+#include <base64.h>
+#include <hex.h>
+#include <utf.h>
+#include <stdatomic.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define BARE_BUFFER_STACK_STRING_MAX 1024
+#define BARE_BUFFER_STACK_UTF16_MAX (BARE_BUFFER_STACK_STRING_MAX / sizeof(utf16_t))
+
+#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;
+}
+
+/* Node.js default limits (N-API doesn't expose platform limits) */
+#define BARE_BUFFER_MAX_ARRAYBUFFER_LENGTH ((size_t)0x7FFFFFFF)
+#define BARE_BUFFER_MAX_STRING_LENGTH     ((size_t)0x1FFFFFFF)
+
+static inline size_t
+bare_buffer__arraybuffer_limit(void) {
+  return BARE_BUFFER_MAX_ARRAYBUFFER_LENGTH;
+}
+
+static inline size_t
+bare_buffer__string_limit(void) {
+  return BARE_BUFFER_MAX_STRING_LENGTH;
+}
+
+static inline bool
+bare_buffer__is_buffer(napi_env env, napi_value value) {
+  bool is_arraybuffer;
+  napi_is_arraybuffer(env, value, &is_arraybuffer);
+  if (is_arraybuffer) return true;
+
+  bool is_shared;
+  node_api_is_sharedarraybuffer(env, value, &is_shared);
+  return is_shared;
+}
+
+static inline int
+bare_buffer__get_info(napi_env env, napi_value buffer, void **data, size_t *len) {
+  bool is_arraybuffer;
+  napi_is_arraybuffer(env, buffer, &is_arraybuffer);
+
+  if (is_arraybuffer) {
+    napi_get_arraybuffer_info(env, buffer, data, len);
+    return 0;
+  }
+
+  bool is_shared;
+  node_api_is_sharedarraybuffer(env, buffer, &is_shared);
+
+  if (is_shared) {
+    /* SharedArrayBuffer: try napi_get_arraybuffer_info (works on some Node versions) */
+    napi_get_arraybuffer_info(env, buffer, data, len);
+    return 0;
+  }
+
+  return -1;
+}
+
+static inline bool
+bare_buffer__is_string(napi_env env, napi_value value) {
+  napi_valuetype type;
+  napi_typeof(env, value, &type);
+  return type == napi_string;
+}
+
+static inline int
+bare_buffer__slice(napi_env env, napi_value buffer, int64_t offset, int64_t len, void **data) {
+  void *base;
+  size_t byte_len;
+  int 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;
+  }
+
+  static uint8_t nowhere;
+  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;
+}
+
+/* ---- String write helpers ---- */
+
+static int64_t
+bare_buffer__write_utf8(napi_env env, napi_value string, utf8_t *buf, int64_t len) {
+  size_t str_len;
+  napi_get_value_string_utf8(env, string, NULL, 0, &str_len);
+
+  size_t written;
+  if (str_len <= (size_t) len) {
+    napi_get_value_string_utf8(env, string, buf, str_len + 1, &written);
+    return written;
+  }
+
+  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);
+
+  napi_get_value_string_utf8(env, string, buf, (size_t) len + 1, &written);
+
+  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(napi_env env, napi_value string, latin1_t *buf, int64_t len) {
+  size_t str_len;
+  napi_get_value_string_latin1(env, string, NULL, 0, &str_len);
+
+  if (str_len > (size_t) len) str_len = (size_t) len;
+
+  size_t written;
+  napi_get_value_string_latin1(env, string, buf, str_len + 1, &written);
+  return written;
+}
+
+static int64_t
+bare_buffer__write_utf16le(napi_env env, napi_value string, uint8_t *bytes, int64_t len) {
+  size_t str_len;
+  napi_get_value_string_utf16(env, string, NULL, 0, &str_len);
+
+  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)) {
+    napi_get_value_string_utf16(env, string, (utf16_t *) bytes, str_len + 1, &written);
+    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) {
+    if (bare_buffer__alloc(str_len * sizeof(utf16_t), (void **) &str) < 0) return -1;
+  }
+
+  napi_get_value_string_utf16(env, string, str, str_len + 1, &written);
+  memcpy(bytes, str, written * sizeof(utf16_t));
+
+  if (str != stack) free(str);
+  return written * sizeof(utf16_t);
+}
+
+static int64_t
+bare_buffer__write_base64(napi_env env, napi_value string, utf8_t *buf, int64_t len) {
+  size_t str_len;
+  napi_get_value_string_utf8(env, string, NULL, 0, &str_len);
+
+  char *str_buf = malloc(str_len + 1);
+  if (str_buf == NULL) return -1;
+
+  size_t written;
+  napi_get_value_string_utf8(env, string, str_buf, str_len + 1, &written);
+
+  size_t decoded = (size_t) len;
+  int err = base64_decode_utf8((const utf8_t *) str_buf, written, buf, &decoded);
+
+  free(str_buf);
+  return err == 0 ? (int64_t) decoded : -1;
+}
+
+static int64_t
+bare_buffer__write_hex(napi_env env, napi_value string, utf8_t *buf, int64_t len) {
+  size_t str_len;
+  napi_get_value_string_utf8(env, string, NULL, 0, &str_len);
+
+  char *str_buf = malloc(str_len + 1);
+  if (str_buf == NULL) return -1;
+
+  size_t written;
+  napi_get_value_string_utf8(env, string, str_buf, str_len + 1, &written);
+
+  size_t decoded = (size_t) len;
+  int err = hex_decode_utf8((const utf8_t *) str_buf, written, buf, &decoded);
+
+  free(str_buf);
+  return err == 0 ? (int64_t) decoded : -1;
+}
+
+/* ---- Check helpers ---- */
+
+static bool
+bare_buffer__check_buffer(napi_env env, napi_value value) {
+  if (bare_buffer__is_buffer(env, value)) return true;
+  napi_throw_type_error(env, NULL, "Buffer must be an array buffer");
+  return false;
+}
+
+static bool
+bare_buffer__check_number(napi_env env, napi_value value, const char *message) {
+  napi_valuetype type;
+  napi_typeof(env, value, &type);
+  if (type != napi_number) {
+    napi_throw_type_error(env, NULL, message);
+    return false;
+  }
+  return true;
+}
+
+static bool
+bare_buffer__check_string(napi_env env, napi_value value, const char *message) {
+  if (bare_buffer__is_string(env, value)) return true;
+  napi_throw_type_error(env, NULL, message);
+  return false;
+}
+
+static napi_value
+bare_buffer__view_out_of_bounds(napi_env env) {
+  napi_throw_range_error(env, NULL, "View is out of bounds of its backing store");
+  return NULL;
+}
+
+static napi_value
+bare_buffer__out_of_memory(napi_env env) {
+  napi_throw_error(env, NULL, "Out of memory");
+  return NULL;
+}
+
+static napi_value
+bare_buffer__invalid_string_length(napi_env env) {
+  napi_throw_range_error(env, NULL, "Invalid string length");
+  return NULL;
+}
+
+static inline int64_t
+bare_buffer__to_int64(napi_env env, napi_value value) {
+  int64_t result;
+  napi_get_value_int64(env, value, &result);
+  return result;
+}
+
+/* ---- N-API callbacks ---- */
+
+static napi_value
+bare_buffer_alloc(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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) {
+    napi_throw_range_error(env, NULL, "Length must not be negative");
+    return NULL;
+  }
+
+  if ((uint64_t) len > bare_buffer__arraybuffer_limit()) {
+    napi_throw_range_error(env, NULL, "Length must not exceed the maximum array buffer length");
+    return NULL;
+  }
+
+  void *data;
+  napi_value result;
+  if (napi_create_arraybuffer(env, len, &data, &result) != napi_ok) return NULL;
+  if (len > 0) memset(data, 0, (size_t) len);
+  return result;
+}
+
+static napi_value
+bare_buffer_alloc_unsafe(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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) {
+    napi_throw_range_error(env, NULL, "Length must not be negative");
+    return NULL;
+  }
+
+  if ((uint64_t) len > bare_buffer__arraybuffer_limit()) {
+    napi_throw_range_error(env, NULL, "Length must not exceed the maximum array buffer length");
+    return NULL;
+  }
+
+  void *data;
+  napi_value result;
+  if (napi_create_arraybuffer(env, len, &data, &result) != napi_ok) return NULL;
+  return result;
+}
+
+static napi_value
+bare_buffer_byte_length_utf8(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  if (!bare_buffer__check_string(env, argv[0], "String must be a string")) return NULL;
+
+  size_t str_len;
+  napi_get_value_string_utf8(env, argv[0], NULL, 0, &str_len);
+
+  napi_value result;
+  napi_create_int64(env, str_len, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_to_string_utf8(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  if (bare_buffer__slice(env, argv[0], offset, len, (void **) &buf) < 0)
+    return bare_buffer__view_out_of_bounds(env);
+
+  napi_value result;
+  if (napi_create_string_utf8(env, buf, len, &result) != napi_ok) return NULL;
+  return result;
+}
+
+static napi_value
+bare_buffer_validate_utf8(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  int32_t valid = err == 0 ? utf8_validate(buf, len) : err;
+
+  napi_value result;
+  napi_create_int32(env, valid, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_write_utf8(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+
+  napi_value result;
+  napi_create_int64(env, written, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_to_string_utf16le(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  if (bare_buffer__slice(env, argv[0], offset, len, (void **) &bytes) < 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);
+
+  napi_value result;
+  if (bare_buffer__is_aligned(bytes)) {
+    if (napi_create_string_utf16(env, (utf16_t *) bytes, str_len, &result) != napi_ok) return NULL;
+    return result;
+  }
+
+  utf16_t stack[BARE_BUFFER_STACK_UTF16_MAX];
+  utf16_t *str = stack;
+
+  if (str_len > BARE_BUFFER_STACK_UTF16_MAX) {
+    if (bare_buffer__alloc(str_len * sizeof(utf16_t), (void **) &str) < 0)
+      return bare_buffer__out_of_memory(env);
+  }
+
+  memcpy(str, bytes, str_len * sizeof(utf16_t));
+  napi_status status = napi_create_string_utf16(env, str, str_len, &result);
+  if (str != stack) free(str);
+  if (status != napi_ok) return NULL;
+  return result;
+}
+
+static napi_value
+bare_buffer_write_utf16le(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+
+  napi_value result;
+  napi_create_int64(env, written, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_to_string_latin1(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  if (bare_buffer__slice(env, argv[0], offset, len, (void **) &buf) < 0)
+    return bare_buffer__view_out_of_bounds(env);
+
+  napi_value result;
+  if (napi_create_string_latin1(env, buf, len, &result) != napi_ok) return NULL;
+  return result;
+}
+
+static napi_value
+bare_buffer_write_latin1(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+
+  napi_value result;
+  napi_create_int64(env, written, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_to_string_base64(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  if (bare_buffer__slice(env, argv[0], offset, len, (void **) &buf) < 0)
+    return bare_buffer__view_out_of_bounds(env);
+
+  size_t str_len;
+  base64_encode_utf8(buf, len, NULL, &str_len);
+
+  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)) {
+    if (bare_buffer__alloc(str_len, (void **) &str) < 0)
+      return bare_buffer__out_of_memory(env);
+  }
+
+  base64_encode_utf8(buf, len, str, &str_len);
+
+  napi_value result;
+  napi_status status = napi_create_string_latin1(env, str, str_len, &result);
+  if (str != stack) free(str);
+  if (status != napi_ok) return NULL;
+  return result;
+}
+
+static napi_value
+bare_buffer_to_string_base64url(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  if (bare_buffer__slice(env, argv[0], offset, len, (void **) &buf) < 0)
+    return bare_buffer__view_out_of_bounds(env);
+
+  size_t str_len;
+  base64url_encode_utf8(buf, len, NULL, &str_len);
+
+  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)) {
+    if (bare_buffer__alloc(str_len, (void **) &str) < 0)
+      return bare_buffer__out_of_memory(env);
+  }
+
+  base64url_encode_utf8(buf, len, str, &str_len);
+
+  napi_value result;
+  napi_status status = napi_create_string_latin1(env, str, str_len, &result);
+  if (str != stack) free(str);
+  if (status != napi_ok) return NULL;
+  return result;
+}
+
+static napi_value
+bare_buffer_write_base64(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+
+  napi_value result;
+  napi_create_int64(env, decoded, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_to_string_hex(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  if (bare_buffer__slice(env, argv[0], offset, len, (void **) &buf) < 0)
+    return bare_buffer__view_out_of_bounds(env);
+
+  size_t str_len;
+  hex_encode_utf8(buf, len, NULL, &str_len);
+
+  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)) {
+    if (bare_buffer__alloc(str_len, (void **) &str) < 0)
+      return bare_buffer__out_of_memory(env);
+  }
+
+  hex_encode_utf8(buf, len, str, &str_len);
+
+  napi_value result;
+  napi_status status = napi_create_string_latin1(env, str, str_len, &result);
+  if (str != stack) free(str);
+  if (status != napi_ok) return NULL;
+  return result;
+}
+
+static napi_value
+bare_buffer_write_hex(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+
+  napi_value result;
+  napi_create_int64(env, decoded, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_validate_ascii(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  int32_t valid = err == 0 ? ascii_validate(buf, len) : err;
+
+  napi_value result;
+  napi_create_int32(env, valid, &result);
+  return result;
+}
+
+/* ---- Swap functions ---- */
+
+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 napi_value
+bare_buffer_swap16(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err == 0) bare_buffer__swap16(buf, len);
+
+  napi_value result;
+  napi_create_int32(env, err, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_swap32(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err == 0) bare_buffer__swap32(buf, len);
+
+  napi_value result;
+  napi_create_int32(env, err, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_swap64(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value argv[3];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int err = bare_buffer__slice(env, argv[0], offset, len, (void **) &buf);
+  if (err == 0) bare_buffer__swap64(buf, len);
+
+  napi_value result;
+  napi_create_int32(env, err, &result);
+  return result;
+}
+
+/* ---- IndexOf / LastIndexOf ---- */
+
+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];
+    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;
+  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;
+  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 napi_value
+bare_buffer_index_of(napi_env env, napi_callback_info info) {
+  size_t argc = 7;
+  napi_value argv[7];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+  }
+
+  napi_value result;
+  napi_create_int64(env, at, &result);
+  return result;
+}
+
+static napi_value
+bare_buffer_last_index_of(napi_env env, napi_callback_info info) {
+  size_t argc = 7;
+  napi_value argv[7];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+  }
+
+  napi_value result;
+  napi_create_int64(env, at, &result);
+  return result;
+}
+
+/* ---- Compare ---- */
+
+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 napi_value
+bare_buffer_compare(napi_env env, napi_callback_info info) {
+  size_t argc = 6;
+  napi_value argv[6];
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+
+  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;
+  int 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;
+  }
+
+  napi_value result;
+  napi_create_int32(env, comparison, &result);
+  return result;
+}
+
+/* ---- Module Init ---- */
+
+static napi_value
+bare_buffer_exports(napi_env env, napi_value exports) {
+  napi_value constants;
+  napi_create_object(env, &constants);
+  napi_set_named_property(env, exports, "constants", constants);
+
+#define SET_INT64_CONST(name, value) do { \
+    napi_value val; \
+    napi_create_int64(env, value, &val); \
+    napi_set_named_property(env, constants, name, val); \
+  } while (0)
+
+  SET_INT64_CONST("MAX_LENGTH", bare_buffer__arraybuffer_limit());
+  SET_INT64_CONST("MAX_STRING_LENGTH", bare_buffer__string_limit());
+#undef SET_INT64_CONST
+
+#define V(name, fn) do { \
+    napi_value val; \
+    napi_create_function(env, name, NAPI_AUTO_LENGTH, fn, NULL, &val); \
+    napi_set_named_property(env, exports, name, val); \
+  } while (0)
+
+  V("alloc", bare_buffer_alloc);
+  V("allocUnsafe", bare_buffer_alloc_unsafe);
+  V("byteLengthUTF8", bare_buffer_byte_length_utf8);
+  V("toStringUTF8", bare_buffer_to_string_utf8);
+  V("validateUTF8", bare_buffer_validate_utf8);
+  V("writeUTF8", bare_buffer_write_utf8);
+  V("toStringUTF16LE", bare_buffer_to_string_utf16le);
+  V("writeUTF16LE", bare_buffer_write_utf16le);
+  V("toStringLatin1", bare_buffer_to_string_latin1);
+  V("writeLatin1", bare_buffer_write_latin1);
+  V("toStringBase64", bare_buffer_to_string_base64);
+  V("toStringBase64URL", bare_buffer_to_string_base64url);
+  V("writeBase64", bare_buffer_write_base64);
+  V("toStringHex", bare_buffer_to_string_hex);
+  V("writeHex", bare_buffer_write_hex);
+  V("validateAscii", bare_buffer_validate_ascii);
+  V("swap16", bare_buffer_swap16);
+  V("swap32", bare_buffer_swap32);
+  V("swap64", bare_buffer_swap64);
+  V("indexOf", bare_buffer_index_of);
+  V("lastIndexOf", bare_buffer_last_index_of);
+  V("compare", bare_buffer_compare);
+#undef V
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, bare_buffer_exports)