bare-buffer 2.0.1 → 2.0.3

package/CMakeLists.txt

@@ -19,15 +19,14 @@ endif()
 add_bare_module(bare_buffer)
 
 target_sources(
-  bare_buffer
+  ${bare_buffer}
   PRIVATE
     binding.c
 )
 
 target_link_libraries(
-  bare_buffer
+  ${bare_buffer}
   PUBLIC
-    utf
-    base64
-    hex
+    base64_static
+    hex_static
 )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-buffer",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Native buffers for JavaScript",
   "main": "index.js",
   "files": [
@@ -17,9 +17,7 @@
     "vendor/libutf/include",
     "vendor/libutf/src"
   ],
-  "addon": {
-    "target": "bare_buffer"
-  },
+  "addon": true,
   "scripts": {
     "test": "standard && bare test/all.js"
   },

package/vendor/libbase64/CMakeLists.txt

@@ -30,7 +30,7 @@ target_include_directories(
     $<TARGET_PROPERTY:utf,INTERFACE_INCLUDE_DIRECTORIES>
 )
 
-add_library(base64_shared SHARED $<TARGET_OBJECTS:base64>)
+add_library(base64_shared SHARED)
 
 set_target_properties(
   base64_shared
@@ -39,7 +39,13 @@ set_target_properties(
   WINDOWS_EXPORT_ALL_SYMBOLS ON
 )
 
-add_library(base64_static STATIC $<TARGET_OBJECTS:base64>)
+target_link_libraries(
+  base64_shared
+  PUBLIC
+    base64
+)
+
+add_library(base64_static STATIC)
 
 set_target_properties(
   base64_static
@@ -48,6 +54,12 @@ set_target_properties(
   PREFIX lib
 )
 
+target_link_libraries(
+  base64_static
+  PUBLIC
+    base64
+)
+
 install(TARGETS base64_shared base64_static)
 
 install(FILES include/base64.h DESTINATION include)

package/vendor/libbase64/src/base64.c

@@ -26,21 +26,31 @@ base64_encode (const uint8_t *buffer, size_t buffer_len, utf8_t *string, size_t
 
   size_t k = 0, i = 0, n = buffer_len;
 
+  uint8_t a, b, c;
+
   for (; i + 2 < n; i += 3) {
-    string[k++] = base64_alphabet[buffer[i] >> 2];
-    string[k++] = base64_alphabet[((buffer[i] & 0x03) << 4) | (buffer[i + 1] >> 4)];
-    string[k++] = base64_alphabet[((buffer[i + 1] & 0x0f) << 2) | (buffer[i + 2] >> 6)];
-    string[k++] = base64_alphabet[buffer[i + 2] & 0x3f];
+    a = buffer[i];
+    b = buffer[i + 1];
+    c = buffer[i + 2];
+
+    string[k++] = base64_alphabet[a >> 2];
+    string[k++] = base64_alphabet[((a & 0x03) << 4) | (b >> 4)];
+    string[k++] = base64_alphabet[((b & 0x0f) << 2) | (c >> 6)];
+    string[k++] = base64_alphabet[c & 0x3f];
   }
 
   if (i < n) {
-    string[k++] = base64_alphabet[buffer[i] >> 2];
+    a = buffer[i];
+
+    string[k++] = base64_alphabet[a >> 2];
 
     if (i + 1 < n) {
-      string[k++] = base64_alphabet[((buffer[i] & 0x03) << 4) | (buffer[i + 1] >> 4)];
-      string[k++] = base64_alphabet[(buffer[i + 1] & 0x0f) << 2];
+      b = buffer[i + 1];
+
+      string[k++] = base64_alphabet[((a & 0x03) << 4) | (b >> 4)];
+      string[k++] = base64_alphabet[(b & 0x0f) << 2];
     } else {
-      string[k++] = base64_alphabet[(buffer[i] & 0x03) << 4];
+      string[k++] = base64_alphabet[(a & 0x03) << 4];
       string[k++] = '=';
     }
 

package/vendor/libhex/CMakeLists.txt

@@ -30,7 +30,7 @@ target_include_directories(
     $<TARGET_PROPERTY:utf,INTERFACE_INCLUDE_DIRECTORIES>
 )
 
-add_library(hex_shared SHARED $<TARGET_OBJECTS:hex>)
+add_library(hex_shared SHARED)
 
 set_target_properties(
   hex_shared
@@ -39,7 +39,13 @@ set_target_properties(
   WINDOWS_EXPORT_ALL_SYMBOLS ON
 )
 
-add_library(hex_static STATIC $<TARGET_OBJECTS:hex>)
+target_link_libraries(
+  hex_shared
+  PUBLIC
+    hex
+)
+
+add_library(hex_static STATIC)
 
 set_target_properties(
   hex_static
@@ -48,11 +54,18 @@ set_target_properties(
   PREFIX lib
 )
 
+target_link_libraries(
+  hex_static
+  PUBLIC
+    hex
+)
+
 install(TARGETS hex_shared hex_static)
 
 install(FILES include/hex.h DESTINATION include)
 
 if(PROJECT_IS_TOP_LEVEL)
   enable_testing()
+
   add_subdirectory(test)
 endif()

package/vendor/libutf/CMakeLists.txt

@@ -15,11 +15,14 @@ target_sources(
   utf
   INTERFACE
     include/utf.h
+    include/utf/endianness.h
+    include/utf/string.h
   PRIVATE
     src/endianness.c
     src/utf8/utf16-convert.c
     src/utf8/utf16-length.c
     src/utf8/validate.c
+    src/utf8/string.c
     src/utf16/utf8-convert.c
     src/utf16/utf8-length.c
     src/utf16/validate.c
@@ -31,7 +34,7 @@ target_include_directories(
     include
 )
 
-add_library(utf_shared SHARED $<TARGET_OBJECTS:utf>)
+add_library(utf_shared SHARED)
 
 set_target_properties(
   utf_shared
@@ -40,7 +43,13 @@ set_target_properties(
   WINDOWS_EXPORT_ALL_SYMBOLS ON
 )
 
-add_library(utf_static STATIC $<TARGET_OBJECTS:utf>)
+target_link_libraries(
+  utf_shared
+  PUBLIC
+    utf
+)
+
+add_library(utf_static STATIC)
 
 set_target_properties(
   utf_static
@@ -49,10 +58,18 @@ set_target_properties(
   PREFIX lib
 )
 
+target_link_libraries(
+  utf_static
+  PUBLIC
+    utf
+)
+
 install(TARGETS utf_shared utf_static)
 
 install(FILES include/utf.h DESTINATION include)
 
+install(DIRECTORY include/utf DESTINATION include)
+
 if(PROJECT_IS_TOP_LEVEL)
   enable_testing()
   add_subdirectory(test)

package/vendor/libutf/include/utf/endianness.h

@@ -1,6 +1,10 @@
 #ifndef UTF_ENDIANNESS_H
 #define UTF_ENDIANNESS_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -43,4 +47,8 @@ utf_swap_uint32 (uint32_t n) {
          ((n & 0xff000000) >> 24);
 }
 
-#endif // UTF_ENDIANNESS_H
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UTF_ENDIANNESS_H

package/vendor/libutf/include/utf/string.h

@@ -0,0 +1,759 @@
+#ifndef UTF_STRING_H
+#define UTF_STRING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../utf.h"
+
+/**
+ * UTF-8
+ */
+
+typedef struct utf8_string_s utf8_string_t;
+typedef struct utf8_string_view_s utf8_string_view_t;
+
+struct utf8_string_s {
+  utf8_t *data;
+  size_t len;
+  size_t cap;
+};
+
+struct utf8_string_view_s {
+  const utf8_t *data;
+  size_t len;
+};
+
+inline void
+utf8_string_init (utf8_string_t *string) {
+  string->len = 0;
+  string->cap = 0;
+  string->data = NULL;
+}
+
+inline utf8_string_view_t
+utf8_string_view_init (const utf8_t *data, size_t len) {
+  return (utf8_string_view_t){data, len};
+}
+
+inline void
+utf8_string_destroy (utf8_string_t *string) {
+  free(string->data);
+}
+
+inline int
+utf8_string_reserve (utf8_string_t *string, size_t len) {
+  size_t cap = string->cap;
+
+  if (len < cap) return 0;
+
+  if (cap == 0) cap = sizeof(utf8_string_t) - 1;
+
+  while (cap < len) {
+    cap = cap * 2 + 1;
+  }
+
+  void *data = realloc(string->data, cap);
+
+  if (data == NULL) return -1;
+
+  string->cap = cap;
+  string->data = data;
+
+  return 0;
+}
+
+inline int
+utf8_string_shrink_to_fit (utf8_string_t *string) {
+  size_t cap = string->len + 1;
+
+  void *data = realloc(string->data, cap);
+
+  if (data == NULL) return -1;
+
+  string->cap = cap;
+  string->data = data;
+
+  return 0;
+}
+
+inline utf8_string_view_t
+utf8_string_view (const utf8_string_t *string) {
+  return utf8_string_view_init(string->data, string->len);
+}
+
+inline void
+utf8_string_clear (utf8_string_t *string) {
+  string->len = 0;
+}
+
+inline bool
+utf8_string_empty (utf8_string_t *string) {
+  return string->len == 0;
+}
+
+inline bool
+utf8_string_view_empty (const utf8_string_view_t view) {
+  return view.len == 0;
+}
+
+inline int
+utf8_string_copy (const utf8_string_t *string, utf8_string_t *result) {
+  int err;
+
+  err = utf8_string_reserve(result, string->len);
+  if (err < 0) return err;
+
+  memcpy(result->data, string->data, string->len);
+
+  result->len = string->len;
+
+  return 0;
+}
+
+inline int
+utf8_string_view_copy (const utf8_string_view_t view, utf8_string_t *result) {
+  int err;
+
+  err = utf8_string_reserve(result, view.len);
+  if (err < 0) return err;
+
+  memcpy(result->data, view.data, view.len);
+
+  result->len = view.len;
+
+  return 0;
+}
+
+inline int
+utf8_string_append (utf8_string_t *string, const utf8_string_t *other) {
+  int err;
+
+  err = utf8_string_reserve(string, string->len + other->len);
+  if (err < 0) return -1;
+
+  memcpy(&string->data[string->len], other->data, other->len);
+
+  string->len += other->len;
+
+  return 0;
+}
+
+inline int
+utf8_string_append_view (utf8_string_t *string, const utf8_string_view_t view) {
+  int err;
+
+  err = utf8_string_reserve(string, string->len + view.len);
+  if (err < 0) return -1;
+
+  memcpy(&string->data[string->len], view.data, view.len);
+
+  string->len += view.len;
+
+  return 0;
+}
+
+inline int
+utf8_string_append_character (utf8_string_t *string, utf8_t c) {
+  int err;
+
+  err = utf8_string_reserve(string, string->len + 1);
+  if (err < 0) return -1;
+
+  string->data[string->len] = c;
+
+  string->len += 1;
+
+  return 0;
+}
+
+inline int
+utf8_string_append_literal (utf8_string_t *string, const utf8_t *literal, size_t n) {
+  int err;
+
+  if (n == (size_t) -1) n = strlen((const char *) literal);
+
+  err = utf8_string_reserve(string, string->len + n);
+  if (err < 0) return -1;
+
+  memcpy(&string->data[string->len], literal, n);
+
+  string->len += n;
+
+  return 0;
+}
+
+inline int
+utf8_string_prepend (utf8_string_t *string, const utf8_string_t *other) {
+  int err;
+
+  err = utf8_string_reserve(string, string->len + other->len);
+  if (err < 0) return -1;
+
+  memmove(&string->data[other->len], string->data, string->len);
+
+  memcpy(string->data, other->data, other->len);
+
+  string->len += other->len;
+
+  return 0;
+}
+
+inline int
+utf8_string_prepend_view (utf8_string_t *string, const utf8_string_view_t view) {
+  int err;
+
+  err = utf8_string_reserve(string, string->len + view.len);
+  if (err < 0) return -1;
+
+  memmove(&string->data[view.len], string->data, string->len);
+
+  memcpy(string->data, view.data, view.len);
+
+  string->len += view.len;
+
+  return 0;
+}
+
+inline int
+utf8_string_prepend_character (utf8_string_t *string, utf8_t c) {
+  int err;
+
+  err = utf8_string_reserve(string, string->len + 1);
+  if (err < 0) return -1;
+
+  memmove(&string->data[1], string->data, string->len);
+
+  string->data[0] = c;
+
+  string->len += 1;
+
+  return 0;
+}
+
+inline int
+utf8_string_prepend_literal (utf8_string_t *string, const utf8_t *literal, size_t n) {
+  int err;
+
+  if (n == (size_t) -1) n = strlen((const char *) literal);
+
+  err = utf8_string_reserve(string, string->len + n);
+  if (err < 0) return -1;
+
+  memmove(&string->data[n], string->data, string->len);
+
+  memcpy(string->data, literal, n);
+
+  string->len += n;
+
+  return 0;
+}
+
+inline int
+utf8_string_insert (utf8_string_t *string, size_t pos, const utf8_string_t *other) {
+  int err;
+
+  if (pos > string->len) return -1;
+
+  size_t inserted_len = string->len + other->len;
+
+  err = utf8_string_reserve(string, inserted_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + other->len], &string->data[pos], string->len - pos);
+
+  memcpy(&string->data[pos], other->data, other->len);
+
+  string->len = inserted_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_insert_view (utf8_string_t *string, size_t pos, const utf8_string_view_t other) {
+  int err;
+
+  if (pos > string->len) return -1;
+
+  size_t inserted_len = string->len + other.len;
+
+  err = utf8_string_reserve(string, inserted_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + other.len], &string->data[pos], string->len - pos);
+
+  memcpy(&string->data[pos], other.data, other.len);
+
+  string->len = inserted_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_insert_character (utf8_string_t *string, size_t pos, utf8_t c) {
+  int err;
+
+  if (pos > string->len) return -1;
+
+  size_t inserted_len = string->len + 1;
+
+  err = utf8_string_reserve(string, inserted_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + 1], &string->data[pos], string->len - pos);
+
+  string->data[pos] = c;
+
+  string->len = inserted_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_insert_literal (utf8_string_t *string, size_t pos, const utf8_t *literal, size_t n) {
+  int err;
+
+  if (pos > string->len) return -1;
+
+  if (n == (size_t) -1) n = strlen((const char *) literal);
+
+  size_t inserted_len = string->len + n;
+
+  err = utf8_string_reserve(string, inserted_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + n], &string->data[pos], string->len - pos);
+
+  memcpy(&string->data[pos], literal, n);
+
+  string->len = inserted_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_replace (utf8_string_t *string, size_t pos, size_t len, const utf8_string_t *replacement) {
+  int err;
+
+  if (pos > string->len) return -1;
+  if (pos + len > string->len) len = string->len - pos;
+
+  size_t replaced_len = string->len + replacement->len - len;
+
+  err = utf8_string_reserve(string, replaced_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + replacement->len], &string->data[pos + len], string->len - pos - len);
+
+  memcpy(&string->data[pos], replacement->data, replacement->len);
+
+  string->len = replaced_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_replace_view (utf8_string_t *string, size_t pos, size_t len, const utf8_string_view_t replacement) {
+  int err;
+
+  if (pos > string->len) return -1;
+  if (pos + len > string->len) len = string->len - pos;
+
+  size_t replaced_len = string->len + replacement.len - len;
+
+  err = utf8_string_reserve(string, replaced_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + replacement.len], &string->data[pos + len], string->len - pos - len);
+
+  memcpy(&string->data[pos], replacement.data, replacement.len);
+
+  string->len = replaced_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_replace_character (utf8_string_t *string, size_t pos, size_t len, utf8_t c) {
+  int err;
+
+  if (pos > string->len) return -1;
+
+  size_t replaced_len = string->len + 1 - len;
+
+  err = utf8_string_reserve(string, replaced_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + 1], &string->data[pos + len], string->len - pos - len);
+
+  string->data[pos] = c;
+
+  string->len = replaced_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_replace_literal (utf8_string_t *string, size_t pos, size_t len, const utf8_t *literal, size_t n) {
+  int err;
+
+  if (pos > string->len) return -1;
+  if (pos + len > string->len) len = string->len - pos;
+
+  if (n == (size_t) -1) n = strlen((const char *) literal);
+
+  size_t replaced_len = string->len + n - len;
+
+  err = utf8_string_reserve(string, replaced_len);
+  if (err < 0) return err;
+
+  memmove(&string->data[pos + n], &string->data[pos + len], string->len - pos - len);
+
+  memcpy(&string->data[pos], literal, n);
+
+  string->len = replaced_len;
+
+  return 0;
+}
+
+inline int
+utf8_string_erase (utf8_string_t *string, size_t pos, size_t len) {
+  int err;
+
+  if (pos > string->len) return -1;
+  if (pos + len > string->len) len = string->len - pos;
+
+  memmove(&string->data[pos], &string->data[pos + len], string->len - pos - len);
+
+  string->len -= len;
+
+  return 0;
+}
+
+inline int
+utf8_string_concat (const utf8_string_t *string, const utf8_string_t *other, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, string->len + other->len);
+  if (err < 0) return err;
+
+  err = utf8_string_append(result, string);
+  assert(err == 0);
+
+  err = utf8_string_append(result, other);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_view_concat (const utf8_string_view_t view, const utf8_string_t *other, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, view.len + other->len);
+  if (err < 0) return err;
+
+  err = utf8_string_append_view(result, view);
+  assert(err == 0);
+
+  err = utf8_string_append(result, other);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_concat_view (const utf8_string_t *string, const utf8_string_view_t other, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, string->len + other.len);
+  if (err < 0) return err;
+
+  err = utf8_string_append(result, string);
+  assert(err == 0);
+
+  err = utf8_string_append_view(result, other);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_view_concat_view (const utf8_string_view_t view, const utf8_string_view_t other, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, view.len + other.len);
+  if (err < 0) return err;
+
+  err = utf8_string_append_view(result, view);
+  assert(err == 0);
+
+  err = utf8_string_append_view(result, other);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_concat_character (const utf8_string_t *string, utf8_t c, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, string->len + 1);
+  if (err < 0) return err;
+
+  err = utf8_string_append(result, string);
+  assert(err == 0);
+
+  err = utf8_string_append_character(result, c);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_view_concat_character (const utf8_string_view_t view, utf8_t c, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, view.len + 1);
+  if (err < 0) return err;
+
+  err = utf8_string_append_view(result, view);
+  assert(err == 0);
+
+  err = utf8_string_append_character(result, c);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_concat_literal (const utf8_string_t *string, const utf8_t *literal, size_t n, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, string->len + n);
+  if (err < 0) return err;
+
+  err = utf8_string_append(result, string);
+  assert(err == 0);
+
+  err = utf8_string_append_literal(result, literal, n);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_view_concat_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n, utf8_string_t *result) {
+  int err;
+
+  utf8_string_init(result);
+
+  err = utf8_string_reserve(result, view.len + n);
+  if (err < 0) return err;
+
+  err = utf8_string_append_view(result, view);
+  assert(err == 0);
+
+  err = utf8_string_append_literal(result, literal, n);
+  assert(err == 0);
+
+  return 0;
+}
+
+inline int
+utf8_string_compare (const utf8_string_t *string, const utf8_string_t *other) {
+  size_t a_len = string->len;
+  size_t b_len = other->len;
+
+  int result = strncmp((const char *) string->data, (const char *) other->data, a_len < b_len ? a_len : b_len);
+
+  if (result == 0) return a_len < b_len
+                            ? -1
+                          : a_len > b_len ? 1
+                                          : 0;
+
+  return result;
+}
+
+inline int
+utf8_string_view_compare (const utf8_string_view_t view, const utf8_string_view_t other) {
+  size_t a_len = view.len;
+  size_t b_len = other.len;
+
+  int result = strncmp((const char *) view.data, (const char *) other.data, a_len < b_len ? a_len : b_len);
+
+  if (result == 0) return a_len < b_len
+                            ? -1
+                          : a_len > b_len ? 1
+                                          : 0;
+
+  return result;
+}
+
+inline int
+utf8_string_compare_literal (const utf8_string_t *string, const utf8_t *literal, size_t n) {
+  if (n == (size_t) -1) n = strlen((const char *) literal);
+
+  size_t a_len = string->len;
+  size_t b_len = n;
+
+  int result = strncmp((const char *) string->data, (const char *) literal, a_len < b_len ? a_len : b_len);
+
+  if (result == 0) return a_len < b_len
+                            ? -1
+                          : a_len > b_len ? 1
+                                          : 0;
+
+  return result;
+}
+
+inline int
+utf8_string_view_compare_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n) {
+  if (n == (size_t) -1) n = strlen((const char *) literal);
+
+  size_t a_len = view.len;
+  size_t b_len = n;
+
+  int result = strncmp((const char *) view.data, (const char *) literal, a_len < b_len ? a_len : b_len);
+
+  if (result == 0) return a_len < b_len
+                            ? -1
+                          : a_len > b_len ? 1
+                                          : 0;
+
+  return result;
+}
+
+inline utf8_string_view_t
+utf8_string_substring (const utf8_string_t *string, size_t start, size_t end) {
+  if (end == (size_t) -1 || end > string->len) end = string->len;
+  if (start > end) start = end;
+
+  return utf8_string_view_init(&string->data[start], end - start);
+}
+
+inline utf8_string_view_t
+utf8_string_view_substring (const utf8_string_view_t view, size_t start, size_t end) {
+  if (end == (size_t) -1 || end > view.len) end = view.len;
+  if (start > end) start = end;
+
+  return utf8_string_view_init(&view.data[start], end - start);
+}
+
+inline int
+utf8_string_substring_copy (const utf8_string_t *string, size_t start, size_t end, utf8_string_t *result) {
+  int err;
+
+  if (end == (size_t) -1 || end > string->len) end = string->len;
+  if (start > end) start = end;
+
+  utf8_string_init(result);
+
+  size_t len = end - start;
+
+  err = utf8_string_reserve(result, len);
+  if (err < 0) return -1;
+
+  memcpy(result->data, &string->data[start], len);
+
+  result->len = len;
+
+  return 0;
+}
+
+inline int
+utf8_string_view_substring_copy (const utf8_string_view_t view, size_t start, size_t end, utf8_string_t *result) {
+  int err;
+
+  if (end == (size_t) -1 || end > view.len) end = view.len;
+  if (start > end) start = end;
+
+  size_t len = end - start;
+
+  err = utf8_string_reserve(result, len);
+  if (err < 0) return -1;
+
+  memcpy(result->data, &view.data[start], len);
+
+  result->len = len;
+
+  return 0;
+}
+
+inline size_t
+utf8_string_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c) {
+  for (size_t i = pos, n = string->len; i < n; i++) {
+    if (string->data[i] == c) {
+      return i;
+    }
+  }
+
+  return (size_t) -1;
+}
+
+inline size_t
+utf8_string_view_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c) {
+  for (size_t i = pos, n = view.len; i < n; i++) {
+    if (view.data[i] == c) {
+      return i;
+    }
+  }
+
+  return (size_t) -1;
+}
+
+inline size_t
+utf8_string_last_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c) {
+  if (pos == (size_t) -1) pos = string->len - 1;
+  else if (pos >= string->len) return (size_t) -1;
+
+  for (size_t i = pos; i <= pos; i--) {
+    if (string->data[i] == c) {
+      return i;
+    }
+  }
+
+  return (size_t) -1;
+}
+
+inline size_t
+utf8_string_view_last_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c) {
+  if (pos == (size_t) -1) pos = view.len - 1;
+  else if (pos >= view.len) return (size_t) -1;
+
+  for (size_t i = pos; i <= pos; i--) {
+    if (view.data[i] == c) {
+      return i;
+    }
+  }
+
+  return (size_t) -1;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UTF_STRING_H

package/vendor/libutf/include/utf.h

@@ -9,8 +9,6 @@ extern "C" {
 #include <stddef.h>
 #include <stdint.h>
 
-#include "utf/endianness.h"
-
 typedef uint_least8_t utf8_t;
 typedef uint_least16_t utf16_t;
 

package/vendor/libutf/src/utf16/utf8-convert.c

@@ -4,6 +4,7 @@
 #include <string.h>
 
 #include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
 
 /**
  * Modified from https://github.com/simdutf/simdutf

package/vendor/libutf/src/utf16/utf8-length.c

@@ -3,6 +3,7 @@
 #include <stdint.h>
 
 #include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
 
 /**
  * Modified from https://github.com/simdutf/simdutf

package/vendor/libutf/src/utf16/validate.c

@@ -3,6 +3,7 @@
 #include <stdint.h>
 
 #include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
 
 /**
  * Modified from https://github.com/simdutf/simdutf

package/vendor/libutf/src/utf8/string.c

@@ -0,0 +1,148 @@
+#include <stddef.h>
+
+#include "../../include/utf.h"
+#include "../../include/utf/string.h"
+
+extern void
+utf8_string_init (utf8_string_t *string);
+
+extern utf8_string_view_t
+utf8_string_view_init (const utf8_t *data, size_t len);
+
+extern void
+utf8_string_destroy (utf8_string_t *string);
+
+extern int
+utf8_string_reserve (utf8_string_t *string, size_t len);
+
+extern int
+utf8_string_shrink_to_fit (utf8_string_t *string);
+
+extern utf8_string_view_t
+utf8_string_view (const utf8_string_t *string);
+
+extern void
+utf8_string_clear (utf8_string_t *string);
+
+extern bool
+utf8_string_empty (utf8_string_t *string);
+
+extern bool
+utf8_string_view_empty (const utf8_string_view_t view);
+
+extern int
+utf8_string_copy (const utf8_string_t *string, utf8_string_t *result);
+
+extern int
+utf8_string_view_copy (const utf8_string_view_t view, utf8_string_t *result);
+
+extern int
+utf8_string_append (utf8_string_t *string, const utf8_string_t *other);
+
+extern int
+utf8_string_append_view (utf8_string_t *string, const utf8_string_view_t view);
+
+extern int
+utf8_string_append_character (utf8_string_t *string, utf8_t c);
+
+extern int
+utf8_string_append_literal (utf8_string_t *string, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_prepend (utf8_string_t *string, const utf8_string_t *other);
+
+extern int
+utf8_string_prepend_view (utf8_string_t *string, const utf8_string_view_t view);
+
+extern int
+utf8_string_prepend_character (utf8_string_t *string, utf8_t c);
+
+extern int
+utf8_string_prepend_literal (utf8_string_t *string, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_insert (utf8_string_t *string, size_t pos, const utf8_string_t *other);
+
+extern int
+utf8_string_insert_view (utf8_string_t *string, size_t pos, const utf8_string_view_t other);
+
+extern int
+utf8_string_insert_character (utf8_string_t *string, size_t pos, utf8_t c);
+
+extern int
+utf8_string_insert_literal (utf8_string_t *string, size_t pos, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_replace (utf8_string_t *string, size_t pos, size_t len, const utf8_string_t *replacement);
+
+extern int
+utf8_string_replace_view (utf8_string_t *string, size_t pos, size_t len, const utf8_string_view_t replacement);
+
+extern int
+utf8_string_replace_character (utf8_string_t *string, size_t pos, size_t len, utf8_t c);
+
+extern int
+utf8_string_replace_literal (utf8_string_t *string, size_t pos, size_t len, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_erase (utf8_string_t *string, size_t pos, size_t len);
+
+extern int
+utf8_string_concat (const utf8_string_t *string, const utf8_string_t *other, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat (const utf8_string_view_t view, const utf8_string_t *other, utf8_string_t *result);
+
+extern int
+utf8_string_concat_view (const utf8_string_t *string, const utf8_string_view_t other, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat_view (const utf8_string_view_t view, const utf8_string_view_t other, utf8_string_t *result);
+
+extern int
+utf8_string_concat_character (const utf8_string_t *string, utf8_t c, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat_character (const utf8_string_view_t view, utf8_t c, utf8_string_t *result);
+
+extern int
+utf8_string_concat_literal (const utf8_string_t *string, const utf8_t *literal, size_t n, utf8_string_t *result);
+
+extern int
+utf8_string_view_concat_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n, utf8_string_t *result);
+
+extern int
+utf8_string_compare (const utf8_string_t *string, const utf8_string_t *other);
+
+extern int
+utf8_string_view_compare (const utf8_string_view_t view, const utf8_string_view_t other);
+
+extern int
+utf8_string_compare_literal (const utf8_string_t *string, const utf8_t *literal, size_t n);
+
+extern int
+utf8_string_view_compare_literal (const utf8_string_view_t view, const utf8_t *literal, size_t n);
+
+extern utf8_string_view_t
+utf8_string_substring (const utf8_string_t *string, size_t start, size_t end);
+
+extern utf8_string_view_t
+utf8_string_view_substring (const utf8_string_view_t view, size_t start, size_t end);
+
+extern int
+utf8_string_substring_copy (const utf8_string_t *string, size_t start, size_t end, utf8_string_t *result);
+
+extern int
+utf8_string_view_substring_copy (const utf8_string_view_t view, size_t start, size_t end, utf8_string_t *result);
+
+extern size_t
+utf8_string_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c);
+
+extern size_t
+utf8_string_view_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c);
+
+extern size_t
+utf8_string_last_index_of_character (const utf8_string_t *string, size_t pos, utf8_t c);
+
+extern size_t
+utf8_string_view_last_index_of_character (const utf8_string_view_t view, size_t pos, utf8_t c);

package/vendor/libutf/src/utf8/utf16-convert.c

@@ -4,6 +4,7 @@
 #include <string.h>
 
 #include "../../include/utf.h"
+#include "../../include/utf/endianness.h"
 
 /**
  * Modified from https://github.com/simdutf/simdutf