qjs modules, compiling not tested

Builds/CMake/deps/quickjs.cmake

@@ -1,11 +1,23 @@
 # QuickJS source files
 set(QUICKJS_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libutf.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/qsort_r.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/tutf8e.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/vector.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/char-utils.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/buffer-utils.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/utils.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/ringbuffer.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libregexp.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libunicode.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/cutils.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-libc.c
     ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/libbf.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-textcode.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/quickjs-internal.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/quickjs/debug.c
 )
 
 # QuickJS include directories

src/quickjs/buffer-utils.c

@@ -0,0 +1,820 @@
+#include "defines.h"
+#include "char-utils.h"
+#include "buffer-utils.h"
+#include "utils.h"
+#ifdef _WIN32
+#include <windows.h>
+#elif defined(HAVE_TERMIOS_H)
+#include <termios.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#endif
+#include "debug.h"
+
+/**
+ * \addtogroup buffer-utils
+ * @{
+ */
+size_t
+ansi_length(const char* str, size_t len) {
+  size_t i, n = 0, p;
+  for(i = 0; i < len;) {
+    if(str[i] == 0x1b && (p = ansi_skip(&str[i], len - i)) > 0) {
+      i += p;
+      continue;
+    }
+    n++;
+    i++;
+  }
+  return n;
+}
+
+size_t
+ansi_skip(const char* str, size_t len) {
+  size_t pos = 0;
+  if(str[pos] == 0x1b) {
+    if(++pos < len && str[pos] == '[') {
+      while(++pos < len)
+        if(is_alphanumeric_char(str[pos]))
+          break;
+      if(++pos < len && str[pos] == '~')
+        ++pos;
+      return pos;
+    }
+  }
+  return 0;
+}
+
+size_t
+ansi_truncate(const char* str, size_t len, size_t limit) {
+  size_t i, n = 0, p;
+  for(i = 0; i < len;) {
+    if((p = ansi_skip(&str[i], len - i)) > 0) {
+      i += p;
+      continue;
+    }
+    n += is_escape_char(str[i]) ? 2 : 1;
+
+    i++;
+    if(n > limit)
+      break;
+  }
+  return i;
+}
+
+int64_t
+array_search(void* a, size_t m, size_t elsz, void* needle) {
+  char* ptr = a;
+  int64_t n, ret;
+  n = m / elsz;
+  for(ret = 0; ret < n; ret++) {
+    if(!memcmp(ptr, needle, elsz))
+      return ret;
+
+    ptr += elsz;
+  }
+  return -1;
+}
+
+char*
+str_escape(const char* s) {
+  DynBuf dbuf;
+  dbuf_init2(&dbuf, 0, 0);
+  dbuf_put_escaped(&dbuf, s, strlen(s));
+  dbuf_0(&dbuf);
+  return (char*)dbuf.buf;
+}
+
+char*
+byte_escape(const void* s, size_t n) {
+  DynBuf dbuf;
+  dbuf_init2(&dbuf, 0, 0);
+  dbuf_put_escaped(&dbuf, s, n);
+  dbuf_0(&dbuf);
+  return (char*)dbuf.buf;
+}
+
+size_t
+byte_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
+  size_t i, last;
+  const char* s = (const char*)haystack;
+  if(hlen < wlen)
+    return hlen;
+  last = hlen - wlen;
+  for(i = 0; i <= last; i++) {
+    if(byte_equal(s, wlen, what))
+      return i;
+    s++;
+  }
+  return hlen;
+}
+
+size_t
+byte_finds(const void* haystack, size_t hlen, const char* what) {
+  return byte_findb(haystack, hlen, what, strlen(what));
+}
+
+size_t
+byte_equal(const void* s, size_t n, const void* t) {
+  return memcmp(s, t, n) == 0;
+}
+
+void
+byte_copy(void* out, size_t len, const void* in) {
+  char* s = (char*)out;
+  const char* t = (const char*)in;
+  size_t i;
+  for(i = 0; i < len; ++i)
+    s[i] = t[i];
+}
+
+void
+byte_copyr(void* out, size_t len, const void* in) {
+  char* s = (char*)out + len;
+  const char* t = (const char*)in;
+  const char* u = t + len;
+
+  for(;;) {
+    if(t >= u)
+      break;
+    --u;
+    --s;
+    *s = *u;
+  }
+}
+
+size_t
+byte_rchrs(const char* in, size_t len, const char needles[], size_t nn) {
+  const char *s = in, *end = in + len, *found = 0;
+  size_t i;
+  for(; s < end; s++) {
+    for(i = 0; i < nn; ++i) {
+      if(*s == needles[i])
+        found = s;
+    }
+  }
+  return (size_t)((found ? found : s) - in);
+}
+
+char*
+dbuf_at_n(const DynBuf* db, size_t i, size_t* n, char sep) {
+  size_t p, l = 0;
+  for(p = 0; p < db->size; ++p) {
+    if(l == i) {
+      *n = byte_chr((const char*)&db->buf[p], db->size - p, sep);
+      return (char*)&db->buf[p];
+    }
+    if(db->buf[p] == sep)
+      ++l;
+  }
+  *n = 0;
+  return 0;
+}
+
+const char*
+dbuf_last_line(DynBuf* db, size_t* len) {
+  size_t i;
+
+  if((i = byte_rchr(db->buf, db->size, '\n')) < db->size)
+    i++;
+  else
+    i = 0;
+
+  if(len)
+    *len = db->size - i;
+
+  return (const char*)&db->buf[i];
+}
+
+int
+dbuf_prepend(DynBuf* s, const uint8_t* data, size_t len) {
+  int ret;
+  if(!(ret = dbuf_reserve_start(s, len)))
+    memcpy(s->buf, data, len);
+
+  return 0;
+}
+
+void
+dbuf_put_colorstr(DynBuf* db, const char* str, const char* color, int with_color) {
+  if(with_color)
+    dbuf_putstr(db, color);
+
+  dbuf_putstr(db, str);
+  if(with_color)
+    dbuf_putstr(db, COLOR_NONE);
+}
+
+void
+dbuf_put_escaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(int)) {
+  size_t i = 0, j;
+  char c;
+
+  while(i < len) {
+    if((j = predicate_find(&str[i], len - i, pred))) {
+      dbuf_append(db, (const uint8_t*)&str[i], j);
+      i += j;
+    }
+
+    if(i == len)
+      break;
+
+    dbuf_putc(db, '\\');
+
+    if(str[i] == 0x1b) {
+      dbuf_append(db, (const uint8_t*)"x1b", 3);
+    } else {
+      int r = pred(str[i]);
+
+      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(str[i])) ? c : str[i]);
+
+      if(r == 'u' || r == 'x')
+        dbuf_printf(db, r == 'u' ? "%04x" : "%02x", str[i]);
+    }
+
+    i++;
+  }
+}
+
+const uint8_t escape_url_tab[256] = {
+    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   '%',
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,
+    '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%',  '%', '%', '%',
+};
+
+const uint8_t escape_noquote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+const uint8_t escape_singlequote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0,    0,    0,    0x27, 0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+const uint8_t escape_doublequote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x',  'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+
+    'x', 'x', 'x', 'x', 0,   0,   0x22, 0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0x5c, 0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u', 'u',  'u',  'u',  'u',  'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+const uint8_t escape_backquote_tab[256] = {
+    'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 0x62, 0x74, 0,   0x76, 0x66, 0,   'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+    'x', 'x', 'x', 'x', 0,   0,   0,   0,   0x24, 0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,    0,   0,    0x60, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   'x', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,    0,    0,   0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  'u',  'u', 'u',  'u',  'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+void
+dbuf_put_escaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
+  size_t i = 0, clen;
+  int32_t c;
+  const uint8_t *pos, *end, *next;
+
+  for(pos = (const uint8_t*)str, end = pos + len; pos < end; pos = next) {
+    uint8_t r, ch;
+
+    if((c = unicode_from_utf8(pos, end - pos, &next)) < 0)
+      break;
+    clen = next - pos;
+    ch = c;
+    r = (clen >= 2 || c > 0xff) ? 'u' : table[c];
+
+    if(r == 'u' && clen > 1 && (c & 0xffffff00) == 0) {
+      r = 'x';
+      // ch = c >> 8;
+    }
+
+    if(r == '%') {
+      static const char hexdigits[] = "0123456789ABCDEF";
+
+      dbuf_putc(db, '%');
+      dbuf_putc(db, hexdigits[c >> 4]);
+      dbuf_putc(db, hexdigits[c & 0xf]);
+    } else if(c == 0x1b) {
+      dbuf_putstr(db, "\\x1b");
+    } else if(r == 'u') {
+      dbuf_printf(db, c > 0xffff ? "\\u{%X}" : "\\u%04x", c);
+    } else if(r == 'x') {
+      dbuf_printf(db, "\\x%02x", ch);
+    } else if(r) {
+      dbuf_putc(db, '\\');
+      dbuf_putc(db, (r > 1 && r <= 127) ? r : (c = escape_char_letter(ch)) ? c : ch);
+    } else {
+      dbuf_put(db, pos, next - pos);
+    }
+
+    i++;
+  }
+}
+
+void
+dbuf_put_unescaped_pred(DynBuf* db, const char* str, size_t len, int (*pred)(const char*, size_t*)) {
+  size_t i = 0, j;
+  // char c;
+
+  while(i < len) {
+    int r = 0;
+    if((j = byte_chr(&str[i], len - i, '\\'))) {
+      dbuf_append(db, (const uint8_t*)&str[i], j);
+      i += j;
+    }
+    if(i == len)
+      break;
+    size_t n = 1;
+
+    if(pred) {
+      r = pred(&str[i + 1], &n);
+
+      if(!r && n == 1)
+        dbuf_putc(db, '\\');
+    }
+
+    if(r >= 0)
+      dbuf_putc(db, /*n > 1 ||*/ r ? /*(r > 1 && r < 256) ?*/ r : str[i]);
+    i += n;
+  }
+}
+
+static inline int
+hexdigit(char c) {
+  if(c >= '0' && c <= '9')
+    return c - '0';
+
+  if(c >= 'a' && c <= 'f')
+    c -= 32;
+
+  if(c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+
+  return -1;
+}
+
+void
+dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]) {
+  size_t i = 0, j;
+  char escape_char = table == escape_url_tab ? '%' : '\\';
+
+  while(i < len) {
+    if((j = byte_chr(&str[i], len - i, escape_char))) {
+      dbuf_append(db, (const uint8_t*)&str[i], j);
+      i += j;
+    }
+
+    if(i == len)
+      break;
+
+    if(escape_char == '%') {
+      int hi = hexdigit(str[i + 1]), lo = hexdigit(str[i + 2]);
+      uint8_t c = (hi << 4) | (lo & 0xf);
+      dbuf_putc(db, c);
+
+      i += 2;
+
+    } else {
+      ++i;
+
+      uint8_t c;
+
+      switch(str[i]) {
+        case 'b': c = '\b'; break;
+        case 't': c = '\t'; break;
+        case 'n': c = '\n'; break;
+        case 'v': c = '\v'; break;
+        case 'f': c = '\f'; break;
+        case 'r': c = '\r'; break;
+        default: c = str[i]; break;
+      }
+
+      uint8_t r = table[c];
+
+      if(!(r && r != 'x' && r != 'u')) {
+        dbuf_putc(db, '\\');
+        dbuf_putc(db, c);
+      } else {
+        dbuf_putc(db, str[i] == r ? c : r);
+      }
+    }
+
+    ++i;
+  }
+}
+
+void
+dbuf_put_escaped(DynBuf* db, const char* str, size_t len) {
+  return dbuf_put_escaped_table(db, str, len, escape_noquote_tab);
+}
+
+void
+dbuf_put_value(DynBuf* db, JSContext* ctx, JSValueConst value) {
+  const char* str;
+  size_t len;
+  str = JS_ToCStringLen(ctx, &len, value);
+  dbuf_append(db, str, len);
+  JS_FreeCString(ctx, str);
+}
+
+void
+dbuf_put_uint32(DynBuf* db, uint32_t num) {
+  char buf[FMT_ULONG];
+  dbuf_put(db, (const uint8_t*)buf, fmt_ulong(buf, num));
+}
+
+void
+dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom) {
+  const char* str;
+  str = JS_AtomToCString(ctx, atom);
+  dbuf_putstr(db, str);
+  JS_FreeCString(ctx, str);
+}
+
+int
+dbuf_reserve_start(DynBuf* s, size_t len) {
+  if(unlikely((s->size + len) > s->allocated_size)) {
+    if(dbuf_realloc(s, s->size + len))
+      return -1;
+  }
+  if(s->size > 0)
+    memcpy(s->buf + len, s->buf, s->size);
+
+  s->size += len;
+  return 0;
+}
+
+uint8_t*
+dbuf_reserve(DynBuf* s, size_t len) {
+  if(unlikely((s->size + len) > s->allocated_size))
+    if(dbuf_realloc(s, s->size + len))
+      return 0;
+
+  return &s->buf[s->size];
+}
+
+size_t
+dbuf_token_pop(DynBuf* db, char delim) {
+  size_t n, p, len;
+  len = db->size;
+  for(n = db->size; n > 0;) {
+    if((p = byte_rchr(db->buf, n, delim)) == n) {
+      db->size = 0;
+      break;
+    }
+    if(p > 0 && db->buf[p - 1] == '\\') {
+      n = p - 1;
+      continue;
+    }
+    db->size = p;
+    break;
+  }
+  return len - db->size;
+}
+
+size_t
+dbuf_token_push(DynBuf* db, const char* str, size_t len, char delim) {
+  size_t pos;
+  if(db->size)
+    dbuf_putc(db, delim);
+
+  pos = db->size;
+  dbuf_put_escaped_pred(db, str, len, is_dot_char);
+  return db->size - pos;
+}
+
+JSValue
+dbuf_tostring_free(DynBuf* s, JSContext* ctx) {
+  JSValue r;
+  r = JS_NewStringLen(ctx, s->buf ? (const char*)s->buf : "", s->buf ? s->size : 0);
+  dbuf_free(s);
+  return r;
+}
+
+ssize_t
+dbuf_load(DynBuf* s, const char* filename) {
+  FILE* fp;
+  size_t nbytes = 0;
+  if((fp = fopen(filename, "rb"))) {
+    char buf[4096];
+    size_t r;
+    while(!feof(fp)) {
+      if((r = fread(buf, 1, sizeof(buf), fp)) == 0) {
+        fclose(fp);
+        return -1;
+      }
+      dbuf_put(s, (uint8_t const*)buf, r);
+      nbytes += r;
+    }
+    fclose(fp);
+  }
+  return nbytes;
+}
+
+int
+dbuf_vprintf(DynBuf* s, const char* fmt, va_list ap) {
+
+  s->size += vsnprintf((char*)(s->buf + s->size), s->allocated_size - s->size, fmt, ap);
+
+  return 0;
+}
+
+InputBuffer
+js_input_buffer(JSContext* ctx, JSValueConst value) {
+  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, {0, INT64_MAX}};
+
+  if(js_is_typedarray(ctx, value)) {
+    ret.value = offset_typedarray(&ret.range, value, ctx);
+  } else if(js_is_arraybuffer(ctx, value) || js_is_sharedarraybuffer(ctx, value)) {
+    ret.value = JS_DupValue(ctx, value);
+  }
+
+  if(js_is_arraybuffer(ctx, ret.value) || js_is_sharedarraybuffer(ctx, ret.value)) {
+    block_arraybuffer(&ret.block, ret.value, ctx);
+  } else {
+    JS_ThrowTypeError(ctx, "Invalid type (%s) for input buffer", js_value_typestr(ctx, ret.value));
+    JS_FreeValue(ctx, ret.value);
+    ret.value = JS_EXCEPTION;
+  }
+
+  return ret;
+}
+
+#undef free
+
+InputBuffer
+js_input_chars(JSContext* ctx, JSValueConst value) {
+  InputBuffer ret = {{{0, 0}}, 0, &input_buffer_free_default, JS_UNDEFINED, OFFSET_INIT()};
+
+  if(JS_IsString(value)) {
+    ret.data = (uint8_t*)JS_ToCStringLen(ctx, &ret.size, value);
+    ret.value = JS_DupValue(ctx, value);
+    ret.free = &input_buffer_free_default;
+  } else {
+    ret = js_input_buffer(ctx, value);
+  }
+
+  return ret;
+}
+
+InputBuffer
+js_input_args(JSContext* ctx, int argc, JSValueConst argv[]) {
+  InputBuffer input = js_input_chars(ctx, argv[0]);
+
+  if(argc > 1)
+    js_offset_length(ctx, input.size, argc - 1, argv + 1, &input.range);
+
+  return input;
+}
+
+InputBuffer
+js_output_args(JSContext* ctx, int argc, JSValueConst argv[]) {
+  InputBuffer output = js_input_buffer(ctx, argv[0]);
+
+  if(argc > 1)
+    js_offset_length(ctx, output.size, argc - 1, argv + 1, &output.range);
+
+  return output;
+}
+
+BOOL
+input_buffer_valid(const InputBuffer* in) {
+  return !JS_IsException(in->value);
+}
+
+InputBuffer
+input_buffer_clone(const InputBuffer* in, JSContext* ctx) {
+  InputBuffer ret = js_input_buffer(ctx, in->value);
+
+  ret.pos = in->pos;
+  ret.size = in->size;
+  ret.free = in->free;
+
+  return ret;
+}
+
+void
+input_buffer_dump(const InputBuffer* in, DynBuf* db) {
+  dbuf_printf(db, "(InputBuffer){ .data = %p, .size = %lu, .pos = %lu, .free = %p }", in->data, (unsigned long)in->size, (unsigned long)in->pos, in->free);
+}
+
+void
+input_buffer_free(InputBuffer* in, JSContext* ctx) {
+  if(in->data) {
+    in->free(ctx, (const char*)in->data, in->value);
+    in->data = 0;
+    in->size = 0;
+    in->pos = 0;
+    in->value = JS_UNDEFINED;
+  }
+}
+
+const uint8_t*
+input_buffer_peek(InputBuffer* in, size_t* lenp) {
+  input_buffer_peekc(in, lenp);
+  return input_buffer_data(in) + in->pos;
+}
+
+const uint8_t*
+input_buffer_get(InputBuffer* in, size_t* lenp) {
+  const uint8_t* ret = input_buffer_peek(in, lenp);
+
+  in->pos += *lenp;
+
+  return ret;
+}
+
+const char*
+input_buffer_currentline(InputBuffer* in, size_t* len) {
+  size_t i;
+
+  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
+    i++;
+
+  if(len)
+    *len = in->pos - i;
+
+  return (const char*)&input_buffer_data(in)[i];
+}
+
+size_t
+input_buffer_column(InputBuffer* in, size_t* len) {
+  size_t i;
+
+  if((i = byte_rchr(input_buffer_data(in), in->pos, '\n')) < in->pos)
+    i++;
+
+  return in->pos - i;
+}
+
+int
+js_offset_length(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p) {
+  int ret = 0;
+  int64_t off = 0, len = size;
+
+  if(argc >= 1 && JS_IsNumber(argv[0])) {
+    if(!JS_ToInt64(ctx, &off, argv[0]))
+      ret = 1;
+
+    if(argc >= 2 && JS_IsNumber(argv[1]))
+      if(!JS_ToInt64(ctx, &len, argv[1]))
+        ret = 2;
+
+    if(size && off != size)
+      off = ((off % size) + size) % size;
+
+    if(len >= 0)
+      len = MIN_NUM(len, size - off);
+    else
+      len = size - off;
+
+    if(off_len_p) {
+      off_len_p->offset = off;
+      off_len_p->length = len;
+    }
+  }
+
+  return ret;
+}
+
+int
+js_index_range(JSContext* ctx, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p) {
+  int ret = 0;
+  int64_t start = 0, end = size;
+
+  if(argc >= 1 && JS_IsNumber(argv[0])) {
+    if(!JS_ToInt64(ctx, &start, argv[0]))
+      ret = 1;
+
+    if(argc >= 2 && JS_IsNumber(argv[1]))
+      if(!JS_ToInt64(ctx, &end, argv[1]))
+        ret = 2;
+
+    if(size > 0) {
+      start = ((start % size) + size) % size;
+      end = ((end % size) + size) % size;
+    }
+
+    if(end > size)
+      end = size;
+
+    if(idx_rng_p) {
+      idx_rng_p->start = start;
+      idx_rng_p->end = end;
+    }
+  }
+
+  return ret;
+}
+
+int
+screen_size(int size[2]) {
+#ifdef _WIN32
+  CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
+  size[0] = csbi.srWindow.Right - csbi.srWindow.Left + 1;
+  size[1] = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
+  return 0;
+
+#elif defined(HAVE_TERMIOS_H)
+  {
+    struct winsize w = {.ws_col = -1, .ws_row = -1};
+
+    if(isatty(STDIN_FILENO))
+      ioctl(STDIN_FILENO, TIOCGWINSZ, &w);
+    else if(isatty(STDOUT_FILENO))
+      ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
+    else if(isatty(STDERR_FILENO))
+      ioctl(STDERR_FILENO, TIOCGWINSZ, &w);
+
+    size[0] = w.ws_col;
+    size[1] = w.ws_row;
+    return 0;
+  }
+#else
+  size[0] = 80;
+  size[1] = 25;
+  return 0;
+#endif
+  return -1;
+}
+
+#undef js_realloc_rt
+void
+js_dbuf_allocator(JSContext* ctx, DynBuf* s) {
+  dbuf_init2(s, JS_GetRuntime(ctx), (DynBufReallocFunc*)js_realloc_rt);
+}
+
+inline int
+input_buffer_peekc(InputBuffer* in, size_t* lenp) {
+  const uint8_t *pos, *end, *next;
+  int cp;
+  pos = input_buffer_data(in) + in->pos;
+  end = input_buffer_data(in) + input_buffer_length(in);
+  cp = unicode_from_utf8(pos, end - pos, &next);
+
+  *lenp = next - pos;
+
+  return cp;
+}
+
+inline int
+input_buffer_putc(InputBuffer* in, unsigned int c, JSContext* ctx) {
+  int len;
+
+  if(in->pos + UTF8_CHAR_LEN_MAX > in->size)
+    if(block_realloc(&in->block, in->pos + UTF8_CHAR_LEN_MAX, ctx))
+      return -1;
+
+  len = unicode_to_utf8(&in->data[in->pos], c);
+
+  in->pos += len;
+
+  return len;
+}
+
+size_t
+dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]) {
+  size_t i, n = 0;
+  for(i = 0; i < sizeof(bits) * 8; i++) {
+    if(bits & (1 << i)) {
+      size_t len = strlen(names[i]);
+      if(n) {
+        n++;
+        dbuf_putstr(db, "|");
+      }
+      dbuf_append(db, names[i], len);
+      n += len;
+    }
+  }
+  return n;
+}
+
+/**
+ * @}
+ */

src/quickjs/buffer-utils.h

@@ -0,0 +1,348 @@
+#ifndef BUFFER_UTILS_H
+#define BUFFER_UTILS_H
+
+#include <quickjs.h>
+#include <cutils.h>
+#include <stdarg.h>
+
+#include "char-utils.h"
+
+/**
+ * \defgroup buffer-utils buffer-utils: Buffer Utilities
+ * @{
+ */
+int64_t array_search(void* a, size_t m, size_t elsz, void* needle);
+#define array_contains(a, m, elsz, needle) (array_search((a), (m), (elsz), (needle)) != -1)
+
+size_t ansi_length(const char*, size_t);
+size_t ansi_skip(const char*, size_t);
+size_t ansi_truncate(const char*, size_t, size_t limit);
+int64_t array_search(void*, size_t, size_t elsz, void* needle);
+char* str_escape(const char*);
+
+char* byte_escape(const void*, size_t);
+size_t byte_findb(const void*, size_t, const void* what, size_t wlen);
+size_t byte_finds(const void*, size_t, const char* what);
+size_t byte_equal(const void* s, size_t n, const void* t);
+void byte_copy(void* out, size_t len, const void* in);
+void byte_copyr(void* out, size_t len, const void* in);
+size_t byte_rchrs(const char* in, size_t len, const char needles[], size_t nn);
+
+#define DBUF_INIT_0() \
+  (DynBuf) { 0, 0, 0, 0, 0, 0 }
+#define DBUF_INIT_CTX(ctx) \
+  (DynBuf) { 0, 0, 0, 0, (DynBufReallocFunc*)js_realloc_rt, JS_GetRuntime(ctx) }
+
+extern const uint8_t escape_url_tab[256], escape_noquote_tab[256], escape_singlequote_tab[256], escape_doublequote_tab[256], escape_backquote_tab[256];
+
+char* dbuf_at_n(const DynBuf*, size_t, size_t* n, char sep);
+const char* dbuf_last_line(DynBuf*, size_t*);
+int dbuf_prepend(DynBuf*, const uint8_t*, size_t len);
+void dbuf_put_colorstr(DynBuf*, const char*, const char* color, int with_color);
+void dbuf_put_escaped_pred(DynBuf*, const char*, size_t len, int (*pred)(int));
+void dbuf_put_escaped_table(DynBuf*, const char*, size_t len, const uint8_t table[256]);
+void dbuf_put_unescaped_table(DynBuf* db, const char* str, size_t len, const uint8_t table[256]);
+void dbuf_put_unescaped_pred(DynBuf*, const char*, size_t len, int (*pred)());
+void dbuf_put_escaped(DynBuf*, const char*, size_t len);
+void dbuf_put_value(DynBuf*, JSContext*, JSValue value);
+void dbuf_put_uint32(DynBuf* db, uint32_t num);
+void dbuf_put_atom(DynBuf* db, JSContext* ctx, JSAtom atom);
+int dbuf_reserve_start(DynBuf*, size_t);
+uint8_t* dbuf_reserve(DynBuf*, size_t);
+size_t dbuf_token_pop(DynBuf*, char);
+size_t dbuf_token_push(DynBuf*, const char*, size_t len, char delim);
+JSValue dbuf_tostring_free(DynBuf*, JSContext*);
+ssize_t dbuf_load(DynBuf*, const char*);
+int dbuf_vprintf(DynBuf*, const char*, va_list);
+
+int screen_size(int size[2]);
+
+static inline int
+dbuf_putm(DynBuf* db, ...) {
+  int r = 0;
+  va_list a;
+  const char* s;
+  va_start(a, db);
+  while((s = va_arg(a, char*)))
+    if(dbuf_putstr(db, s))
+      return -1;
+  va_end(a);
+  return r;
+}
+
+#define dbuf_append(d, x, n) dbuf_put((d), (const uint8_t*)(x), (n))
+
+static inline size_t
+dbuf_count(DynBuf* db, int ch) {
+  return byte_count(db->buf, db->size, ch);
+}
+
+static inline void
+dbuf_0(DynBuf* db) {
+  dbuf_putc(db, '\0');
+  db->size--;
+}
+
+static inline void
+dbuf_zero(DynBuf* db) {
+  dbuf_realloc(db, 0);
+  db->size = 0;
+}
+
+size_t dbuf_bitflags(DynBuf* db, uint32_t bits, const char* const names[]);
+
+#define js_dbuf_init(ctx, buf) dbuf_init2((buf), (ctx), (realloc_func*)&utils_js_realloc)
+#define js_dbuf_init_rt(rt, buf) dbuf_init2((buf), (rt), (realloc_func*)&utils_js_realloc_rt)
+
+void js_dbuf_allocator(JSContext* ctx, DynBuf* s);
+
+typedef struct {
+  uint8_t* base;
+  size_t size;
+} MemoryBlock;
+
+static inline void
+block_init(MemoryBlock* mb) {
+  mb->base = 0;
+  mb->size = 0;
+}
+
+/* clang-format off */
+static inline void* block_data(const MemoryBlock* mb) { return mb->base; }
+static inline size_t block_length(const MemoryBlock* mb) { return mb->size; }
+static inline void* block_begin(const MemoryBlock* mb) { return mb->base; }
+static inline void* block_end(const MemoryBlock* mb) { return mb->base + mb->size; }
+/* clang-format on */
+
+static inline BOOL
+block_arraybuffer(MemoryBlock* mb, JSValueConst ab, JSContext* ctx) {
+  mb->base = JS_GetArrayBuffer(ctx, &mb->size, ab);
+  return mb->base != 0;
+}
+
+typedef struct {
+  uint8_t *start, *end;
+} PointerRange;
+
+static inline void
+range_init(PointerRange* pr) {
+  pr->end = pr->start = 0;
+}
+
+static inline PointerRange
+range_from(const MemoryBlock* mb) {
+  return (PointerRange){mb->base, mb->base + mb->size};
+}
+
+typedef struct {
+  int64_t start, end;
+} IndexRange;
+
+typedef struct {
+  int64_t offset, length;
+} OffsetLength;
+
+#define OFFSET_INIT() \
+  (OffsetLength) { 0, INT64_MAX }
+
+static inline void
+offset_init(OffsetLength* ol) {
+  ol->offset = 0;
+  ol->length = INT64_MAX;
+}
+
+static inline BOOL
+offset_is_default(const OffsetLength* ol) {
+  return ol->offset == 0 && ol->length == INT64_MAX;
+}
+
+static inline void*
+offset_data(const OffsetLength* ol, const void* x) {
+  return (uint8_t*)x + ol->offset;
+}
+
+static inline size_t
+offset_size(const OffsetLength* ol, size_t n) {
+  if(ol->length == -1)
+    return (signed long)n - ol->offset;
+  return MIN_NUM(ol->length, (signed long)n - ol->offset);
+}
+
+static inline MemoryBlock
+offset_block(const OffsetLength* ol, const void* x, size_t n) {
+  return (MemoryBlock){offset_data(ol, x), offset_size(ol, n)};
+}
+
+static inline PointerRange
+offset_range(const OffsetLength* ol, const void* x, size_t n) {
+  MemoryBlock mb = offset_block(ol, x, n);
+  return range_from(&mb);
+}
+
+static inline OffsetLength
+offset_slice(const OffsetLength ol, int64_t start, int64_t end) {
+  if(start < 0)
+    start = ol.length + (start % ol.length);
+  else if(start > ol.length)
+    start = ol.length;
+  if(end < 0)
+    end = ol.length + (end % ol.length);
+  else if(end > ol.length)
+    end = ol.length;
+
+  return (OffsetLength){start, end - start};
+}
+
+static inline OffsetLength
+offset_offset(const OffsetLength* ol, const OffsetLength* by) {
+  OffsetLength ret;
+  ret.offset = ol->offset + by->offset;
+  ret.length = MIN_NUM(by->length, ol->length - by->offset);
+  return ret;
+}
+
+static inline OffsetLength
+offset_from_indexrange(const IndexRange* ir) {
+  OffsetLength ret;
+  ret.offset = ir->start;
+  ret.length = ir->end - ir->start;
+  return ret;
+}
+
+static inline JSValue
+offset_typedarray(OffsetLength* ol, JSValueConst array, JSContext* ctx) {
+  JSValue ret;
+  size_t offset, length;
+
+  ret = JS_GetTypedArrayBuffer(ctx, array, &offset, &length, NULL);
+
+  if(!JS_IsException(ret)) {
+    ol->offset = offset;
+    ol->length = length;
+  }
+
+  return ret;
+}
+
+static inline IndexRange
+indexrange_from_offset(const OffsetLength* ol) {
+  IndexRange ret;
+  ret.start = ol->offset;
+  ret.end = ol->offset + ol->length;
+  return ret;
+}
+
+static inline MemoryBlock
+block_range(const MemoryBlock* mb, const OffsetLength* range) {
+  MemoryBlock ret;
+  ret.base = mb->base + range->offset;
+  ret.size = MIN_NUM((size_t)range->length, mb->size - range->offset);
+  return ret;
+}
+
+static inline int
+block_realloc(MemoryBlock* mb, size_t new_size, JSContext* ctx) {
+  if((mb->base = js_realloc(ctx, mb->base, new_size))) {
+    mb->size = new_size;
+    return 0;
+  }
+  return -1;
+}
+
+typedef struct InputBuffer {
+  union {
+    MemoryBlock block;
+    struct {
+      uint8_t* data;
+      size_t size;
+    };
+  };
+  size_t pos;
+  void (*free)(JSContext*, const char*, JSValue);
+  JSValue value;
+  OffsetLength range;
+} InputBuffer;
+
+static inline void
+input_buffer_free_default(JSContext* ctx, const char* str, JSValue val) {
+  if(JS_IsString(val))
+    JS_FreeCString(ctx, str);
+
+  if(!JS_IsUndefined(val))
+    JS_FreeValue(ctx, val);
+}
+
+InputBuffer js_input_buffer(JSContext* ctx, JSValueConst value);
+InputBuffer js_input_chars(JSContext* ctx, JSValueConst value);
+InputBuffer js_input_args(JSContext* ctx, int argc, JSValueConst argv[]);
+InputBuffer js_output_args(JSContext* ctx, int argc, JSValueConst argv[]);
+
+InputBuffer input_buffer_clone(const InputBuffer* in, JSContext* ctx);
+BOOL input_buffer_valid(const InputBuffer* in);
+void input_buffer_dump(const InputBuffer* in, DynBuf* db);
+void input_buffer_free(InputBuffer* in, JSContext* ctx);
+
+static inline uint8_t*
+input_buffer_data(const InputBuffer* in) {
+  return offset_data(&in->range, in->data);
+}
+
+static inline size_t
+input_buffer_length(const InputBuffer* in) {
+  return offset_size(&in->range, in->size);
+}
+
+static inline MemoryBlock
+input_buffer_block(InputBuffer* in) {
+  return (MemoryBlock){input_buffer_data(in), input_buffer_length(in)};
+}
+
+static inline MemoryBlock*
+input_buffer_blockptr(InputBuffer* in) {
+  return &in->block;
+}
+
+const uint8_t* input_buffer_get(InputBuffer* in, size_t* lenp);
+const uint8_t* input_buffer_peek(InputBuffer* in, size_t* lenp);
+const char* input_buffer_currentline(InputBuffer*, size_t* len);
+size_t input_buffer_column(InputBuffer*, size_t* len);
+
+int input_buffer_peekc(InputBuffer* in, size_t* lenp);
+int input_buffer_putc(InputBuffer*, unsigned int, JSContext*);
+
+static inline int
+input_buffer_getc(InputBuffer* in) {
+  size_t n;
+  int ret;
+  ret = input_buffer_peekc(in, &n);
+  in->pos += n;
+  return ret;
+}
+
+static inline void*
+input_buffer_begin(const InputBuffer* in) {
+  return input_buffer_data(in);
+}
+
+static inline void*
+input_buffer_end(const InputBuffer* in) {
+  return input_buffer_data(in) + input_buffer_length(in);
+}
+
+static inline BOOL
+input_buffer_eof(const InputBuffer* in) {
+  return in->pos == input_buffer_length(in);
+}
+
+static inline size_t
+input_buffer_remain(const InputBuffer* in) {
+  return input_buffer_length(in) - in->pos;
+}
+
+int js_offset_length(JSContext*, int64_t size, int argc, JSValueConst argv[], OffsetLength* off_len_p);
+int js_index_range(JSContext*, int64_t size, int argc, JSValueConst argv[], IndexRange* idx_rng_p);
+
+/**
+ * @}
+ */
+#endif /* defined(BUFFER_UTILS) */

src/quickjs/char-utils.c

@@ -0,0 +1,578 @@
+#include "char-utils.h"
+#include "libutf.h"
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
+#include <winnls.h>
+#include <windows.h>
+#include <wchar.h>
+#endif
+
+/**
+ * \addtogroup char-utils
+ * @{
+ */
+size_t
+token_length(const char* str, size_t len, char delim) {
+  const char *s, *e;
+  size_t pos;
+
+  for(s = str, e = s + len; s < e; s += pos + 1) {
+    pos = byte_chr(s, e - s, delim);
+
+    if(s + pos == e)
+      break;
+
+    if(pos == 0 || s[pos - 1] != '\\') {
+      s += pos;
+      break;
+    }
+  }
+
+  return s - str;
+}
+
+size_t
+fmt_ulong(char* dest, uint32_t i) {
+  uint32_t len, tmp, len2;
+
+  for(len = 1, tmp = i; tmp > 9; ++len)
+    tmp /= 10;
+
+  if(dest)
+    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10)
+      *--dest = (char)((tmp % 10) + '0');
+
+  return len;
+}
+
+size_t
+fmt_longlong(char* dest, int64_t i) {
+  if(i < 0) {
+    if(dest)
+      *dest++ = '-';
+    return fmt_ulonglong(dest, (uint64_t)-i) + 1;
+  }
+
+  return fmt_ulonglong(dest, (uint64_t)i);
+}
+
+size_t
+fmt_ulonglong(char* dest, uint64_t i) {
+  size_t len;
+  uint64_t tmp, len2;
+
+  for(len = 1, tmp = i; tmp > 9ll; ++len)
+    tmp /= 10ll;
+
+  if(dest)
+    for(tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10ll)
+      *--dest = (tmp % 10ll) + '0';
+
+  return len;
+}
+
+#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
+
+size_t
+fmt_xlonglong(char* dest, uint64_t i) {
+  uint64_t len, tmp;
+
+  for(len = 1, tmp = i; tmp > 15ll; ++len)
+    tmp >>= 4ll;
+
+  if(dest)
+    for(tmp = i, dest += len;;) {
+      *--dest = tohex(tmp & 15ll);
+
+      if(!(tmp >>= 4ll))
+        break;
+    }
+
+  return len;
+}
+
+size_t
+fmt_xlonglong0(char* dest, uint64_t num, size_t n) {
+  size_t i = 0, len;
+
+  if((len = fmt_xlonglong(NULL, num)) < n) {
+    len = n - len;
+
+    while(i < len)
+      dest[i++] = '0';
+  }
+
+  i += fmt_xlonglong(&dest[i], num);
+  return i;
+}
+
+size_t
+fmt_8long(char* dest, uint32_t i) {
+  uint32_t len, tmp;
+
+  /* first count the number of bytes needed */
+  for(len = 1, tmp = i; tmp > 7; ++len)
+    tmp >>= 3;
+
+  if(dest)
+    for(tmp = i, dest += len;;) {
+      *--dest = (char)((tmp & 7) + '0');
+
+      if(!(tmp >>= 3))
+        break;
+    }
+
+  return len;
+}
+
+#define tohex(c) (char)((c) >= 10 ? (c)-10 + 'a' : (c) + '0')
+
+size_t
+fmt_xlong(char* dest, uint32_t i) {
+  uint32_t len, tmp;
+
+  /* first count the number of bytes needed */
+  for(len = 1, tmp = i; tmp > 15; ++len)
+    tmp >>= 4;
+
+  if(dest)
+    for(tmp = i, dest += len;;) {
+      *--dest = tohex(tmp & 15);
+
+      if(!(tmp >>= 4))
+        break;
+    }
+
+  return len;
+}
+
+size_t
+fmt_xlong0(char* dest, uint32_t num, size_t n) {
+  size_t i = 0, len;
+
+  if((len = fmt_xlong(NULL, num)) < n) {
+    len = n - len;
+
+    while(i < len)
+      dest[i++] = '0';
+  }
+
+  i += fmt_xlong(&dest[i], num);
+  return i;
+}
+
+size_t
+scan_ushort(const char* src, uint16_t* dest) {
+  const char* cur;
+  uint16_t l;
+
+  for(cur = src, l = 0; *cur >= '0' && *cur <= '9'; ++cur) {
+    uint32_t tmp = l * 10ul + *cur - '0';
+
+    if((uint16_t)tmp != tmp)
+      break;
+
+    l = tmp;
+  }
+
+  if(cur > src)
+    *dest = l;
+
+  return (size_t)(cur - src);
+}
+
+size_t
+scan_uint(const char* src, uint32_t* dest) {
+  uint64_t u64;
+  size_t r = scan_ulonglong(src, &u64);
+  *dest = u64;
+  return r;
+}
+
+size_t
+scan_int(const char* src, int32_t* dest) {
+  int64_t i64;
+  size_t r = scan_longlong(src, &i64);
+  *dest = i64;
+  return r;
+}
+
+#ifndef MAXLONG
+#define MAXLONG (((uint32_t)-1) >> 1)
+#endif
+
+size_t
+scan_longlong(const char* src, int64_t* dest) {
+  size_t i, o;
+  uint64_t l;
+  char c = src[0];
+  unsigned int neg = c == '-';
+  o = c == '-' || c == '+';
+
+  if((i = scan_ulonglong(src + o, &l))) {
+    if(i > 0ll && l > MAXLONG + neg) {
+      l /= 10ll;
+      --i;
+    }
+
+    if(i + o)
+      *dest = (int64_t)(c == '-' ? -l : l);
+
+    return i + o;
+  }
+
+  return 0;
+}
+
+size_t
+scan_ulonglong(const char* src, uint64_t* dest) {
+  const char* tmp = src;
+  uint64_t l = 0;
+  unsigned char c;
+
+  while((c = (unsigned char)(*tmp - '0')) < 10) {
+    uint64_t n;
+    n = l << 3ll;
+
+    if((n >> 3ll) != l)
+      break;
+
+    if(n + (l << 1ll) < n)
+      break;
+
+    n += l << 1ll;
+
+    if(n + c < n)
+      break;
+
+    l = n + c;
+    ++tmp;
+  }
+
+  if(tmp - src)
+    *dest = l;
+
+  return (size_t)(tmp - src);
+}
+
+size_t
+scan_xlonglong(const char* src, uint64_t* dest) {
+  const char* tmp = src;
+  int64_t l = 0;
+  unsigned char c;
+
+  while((c = scan_fromhex(*tmp)) < 16) {
+    l = (l << 4) + c;
+    ++tmp;
+  }
+
+  *dest = l;
+  return tmp - src;
+}
+
+size_t
+scan_8longn(const char* src, size_t n, uint32_t* dest) {
+  const char* tmp = src;
+  uint32_t l = 0;
+  unsigned char c;
+
+  while(n-- > 0 && (c = (unsigned char)(*tmp - '0')) < 8) {
+    if(l >> (sizeof(l) * 8 - 3))
+      break;
+
+    l = l * 8 + c;
+    ++tmp;
+  }
+
+  *dest = l;
+  return (size_t)(tmp - src);
+}
+
+size_t
+scan_whitenskip(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = t + limit; t < u; ++t)
+    if(!is_whitespace_char(*t))
+      break;
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_nonwhitenskip(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = t + limit; t < u; ++t)
+    if(is_whitespace_char(*t))
+      break;
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_line(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = s + limit; t < u; ++t)
+    if(*t == '\n' || *t == '\r')
+      break;
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_lineskip(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = s + limit; t < u; ++t)
+    if(*t == '\n') {
+      ++t;
+      break;
+    }
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_lineskip_escaped(const char* s, size_t limit) {
+  const char *t, *u;
+
+  for(t = s, u = s + limit; t < u; ++t) {
+    if(*t == '\\') {
+      ++t;
+      continue;
+    }
+    if(*t == '\n') {
+      ++t;
+      break;
+    }
+  }
+
+  return (size_t)(t - s);
+}
+
+size_t
+scan_eolskip(const char* s, size_t limit) {
+  size_t n = 0;
+
+  if(n + 1 < limit && s[0] == '\r' && s[1] == '\n')
+    n += 2;
+  else if(n < limit && s[0] == '\n')
+    n += 1;
+
+  return n;
+}
+
+size_t
+utf8_strlen(const void* in, size_t len) {
+  const uint8_t *pos, *end, *next;
+  size_t i = 0;
+
+  for(pos = (const uint8_t*)in, end = pos + len; pos < end; pos = next, ++i)
+    unicode_from_utf8(pos, end - pos, &next);
+
+  return i;
+}
+
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)
+wchar_t*
+utf8_towcs(const char* s) {
+  int len = (int)strlen(s);
+  int n = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0);
+  wchar_t* ret;
+
+  if((ret = (wchar_t*)malloc((n + 1) * sizeof(wchar_t)))) {
+    MultiByteToWideChar(CP_UTF8, 0, s, len, ret, n);
+    ret[n] = L'\0';
+  }
+
+  return ret;
+}
+
+char*
+utf8_fromwcs(const wchar_t* wstr) {
+  int len = (int)wcslen(wstr);
+  int n = WideCharToMultiByte(CP_UTF8, 0, wstr, len, NULL, 0, NULL, NULL);
+  char* ret;
+
+  if((ret = malloc((n + 1)))) {
+    WideCharToMultiByte(CP_UTF8, 0, wstr, len, ret, n, NULL, NULL);
+    ret[n] = '\0';
+  }
+
+  return ret;
+}
+#endif
+
+BOOL
+utf16_multiword(const void* in) {
+  const uint16_t* p16 = in;
+  LibutfC16Type type = libutf_c16_type(p16[0]);
+
+  return !((LIBUTF_UTF16_NOT_SURROGATE == type) || (LIBUTF_UTF16_SURROGATE_HIGH != type || LIBUTF_UTF16_SURROGATE_LOW != libutf_c16_type(p16[1])));
+}
+
+int
+case_lowerc(int c) {
+  if(c >= 'A' && c <= 'Z')
+    c += 'a' - 'A';
+
+  return c;
+}
+
+int
+case_starts(const char* a, const char* b) {
+  const char *s, *t;
+
+  for(s = a, t = b;; ++s, ++t) {
+    unsigned char x, y;
+
+    if(!*t)
+      return 1;
+
+    x = case_lowerc(*s);
+    y = case_lowerc(*t);
+
+    if(x != y)
+      break;
+
+    if(!x)
+      break;
+  }
+
+  return 0;
+}
+
+int
+case_diffb(const void* S, size_t len, const void* T) {
+  unsigned char x, y;
+  const char *s, *t;
+
+  for(s = (const char*)S, t = (const char*)T; len > 0;) {
+    --len;
+    x = case_lowerc(*s);
+    y = case_lowerc(*t);
+
+    ++s;
+    ++t;
+
+    if(x != y)
+      return ((int)(unsigned int)x) - ((int)(unsigned int)y);
+  }
+
+  return 0;
+}
+
+size_t
+case_findb(const void* haystack, size_t hlen, const void* what, size_t wlen) {
+  size_t i, last;
+  const char* s = haystack;
+
+  if(hlen < wlen)
+    return hlen;
+
+  last = hlen - wlen;
+
+  for(i = 0; i <= last; i++, s++)
+    if(!case_diffb(s, wlen, what))
+      return i;
+
+  return hlen;
+}
+
+size_t
+case_finds(const void* haystack, const char* what) {
+  return case_findb(haystack, strlen(haystack), what, strlen(what));
+}
+
+ssize_t
+write_file(const char* file, const void* buf, size_t len) {
+  FILE* f;
+  ssize_t ret = -1;
+
+  if((f = fopen(file, "w+")))
+    switch(fwrite(buf, len, 1, f)) {
+      case 1: {
+        ret = len;
+        break;
+      }
+    }
+
+  fflush(f);
+  ret = ftell(f);
+  fclose(f);
+
+  return ret;
+}
+
+ssize_t
+puts_file(const char* file, const char* s) {
+  return write_file(file, s, strlen(s));
+}
+
+size_t
+u64toa(char* x, uint64_t num, int base) {
+  size_t len = 0;
+  uint64_t n = num;
+
+  do {
+    n /= base;
+    len++;
+    x++;
+  } while(n != 0);
+
+  *x-- = '\0';
+
+  do {
+    char c = num % base;
+    num /= base;
+
+    if(c >= 10)
+      c += 'a' - '0' - 10;
+    *x-- = c + '0';
+  } while(num != 0);
+
+  return len;
+}
+
+size_t
+i64toa(char* x, int64_t num, int base) {
+  size_t pos = 0, len;
+
+  if(num < 0) {
+    x[pos++] = '-';
+    num = -num;
+  }
+
+  len = u64toa(&x[pos], num, base);
+
+  return pos + len;
+}
+
+size_t
+str_findb(const char* s1, const char* x, size_t n) {
+  const char* b;
+  size_t i, j, len = strlen(s1);
+
+  if(len >= n) {
+    size_t end = len - n + 1;
+
+    for(i = 0; i < end; i++) {
+      b = &s1[i];
+
+      for(j = 0; x[j] == b[j];)
+        if(++j == n)
+          return i;
+    }
+  }
+
+  return len;
+}
+
+size_t
+str_find(const void* s, const void* what) {
+  return str_findb(s, what, strlen(what));
+}
+/**
+ * @}
+ */

src/quickjs/char-utils.h

@@ -0,0 +1,441 @@
+#ifndef CHAR_UTILS_H
+#define CHAR_UTILS_H
+
+#include <cutils.h>
+#include <string.h>
+#include "debug.h"
+
+/**
+ * \defgroup char-utils char-utils: Character Utilities
+ * @{
+ */
+#define is_control_char(c) ((c) == '\a' || (c) == '\b' || (c) == '\t' || (c) == '\n' || (c) == '\v' || (c) == '\f' || (c) == '\r')
+#define is_alphanumeric_char(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+
+#define is_digit_char(c) ((c) >= '0' && (c) <= '9')
+#define is_print_char(c) ((c) >= ' ' && (c) <= '\x7f')
+#define is_newline_char(c) ((c) == '\n')
+#define is_identifier_char(c) (is_alphanumeric_char(c) || is_digit_char(c) || (c) == '$' || (c) == '_')
+#define is_whitespace_char(c) ((c) == ' ' || (c) == '\t' || (c) == '\v' || (c) == '\n' || (c) == '\r')
+
+#define str_equal(s, t) (!strcmp((s), (t)))
+
+static inline int
+escape_char_pred(int c) {
+  static const unsigned char table[256] = {
+      'x', 'x', 'x', 'x', 'x', 'x',  'x', 'x', 0x62, 0x74, 0x6e, 0x76, 0x66, 0x72, 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x',
+      'x', 'x', 'x', 0,   0,   0,    0,   0,   0,    0,    0x27, 0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0x5c, 0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    'x',  0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+      0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,    0,    0,    0,    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  };
+
+  return table[(unsigned char)c];
+}
+
+static inline int
+unescape_char_pred(int c) {
+  switch(c) {
+    case 'b': return 8;
+    case 'f': return 12;
+    case 'n': return 10;
+    case 'r': return 13;
+    case 't': return 9;
+    case 'v': return 11;
+    case '\'': return 39;
+    case '\\': return 92;
+  }
+
+  return 0;
+}
+
+static inline int
+is_escape_char(int c) {
+  return is_control_char(c) || c == '\\' || c == '\'' || c == 0x1b || c == 0;
+}
+
+static inline int
+is_backslash_char(int c) {
+  return c == '\\';
+}
+
+//#define is_dot_char(c) ((c) == '.')0
+//#define is_backslash_char(c) ((c) == '\\')
+
+static inline int
+is_dot_char(int c) {
+  return c == '.';
+}
+
+static inline int
+is_identifier(const char* str) {
+  if(!((*str >= 'A' && *str <= 'Z') || (*str >= 'a' && *str <= 'z') || *str == '$' || *str == '_'))
+    return 0;
+
+  while(*++str)
+    if(!is_identifier_char(*str))
+      return 0;
+
+  return 1;
+}
+
+static inline int
+is_integer(const char* str) {
+  if(*str == '-')
+    ++str;
+
+  if(!(*str >= '1' && *str <= '9') && !(*str == '0' && str[1] == '\0'))
+    return 0;
+
+  while(*++str)
+    if(!is_digit_char(*str))
+      return 0;
+
+  return 1;
+}
+
+static inline size_t
+byte_count(const void* s, size_t n, char c) {
+  const uint8_t* t;
+  uint8_t ch = (uint8_t)c;
+  size_t count;
+
+  for(t = (uint8_t*)s, count = 0; n; ++t, --n)
+    if(*t == ch)
+      ++count;
+
+  return count;
+}
+
+static inline size_t
+byte_chr(const void* str, size_t len, char c) {
+  const char* s = memchr(str, c, len);
+
+  if(s)
+    return s - (const char*)str;
+
+  return len;
+}
+
+static inline size_t
+byte_rchr(const void* haystack, size_t len, char needle) {
+  const char *s, *t;
+
+  for(s = (const char*)haystack, t = s + len;;) {
+    --t;
+
+    if(s > t)
+      break;
+
+    if(*t == needle)
+      return (size_t)(t - s);
+  }
+
+  return len;
+}
+
+/*size_t
+byte_rchr(const void* str, size_t len, char c) {
+  const char* s = memrchr(str, c, len);
+  if(s)
+    return s - (const char*)str;
+  return len;
+}*/
+
+static inline size_t
+byte_chrs(const void* str, size_t len, const char needle[], size_t nl) {
+  const char *s, *t;
+
+  for(s = str, t = s + len; s != t; s++)
+    if(byte_chr(needle, nl, *s) < nl)
+      break;
+
+  return s - (const char*)str;
+}
+
+static inline int
+byte_diff(const void* a, size_t len, const void* b) {
+  size_t i;
+
+  for(i = 0; i < len; ++i) {
+    int r = ((unsigned char*)a)[i] - ((unsigned char*)b)[i];
+
+    if(r)
+      return r;
+  }
+
+  return 0;
+}
+
+static inline int
+byte_diff2(const char* a, size_t alen, const char* b, size_t blen) {
+
+  if(alen < blen)
+    return -b[alen];
+
+  if(blen < alen)
+    return a[blen];
+
+  return byte_diff(a, alen, b);
+}
+
+static inline size_t
+str_chr(const char* in, char needle) {
+  const char *t, c = needle;
+
+  for(t = in; *t; ++t)
+    if(*t == c)
+      break;
+
+  return (size_t)(t - in);
+}
+
+static inline size_t
+str_chrs(const char* in, const char needles[], size_t nn) {
+  const char* t;
+  size_t i;
+
+  for(t = in; *t; ++t)
+    for(i = 0; i < nn; i++)
+      if(*t == needles[i])
+        return (size_t)(t - in);
+
+  return (size_t)(t - in);
+}
+
+static inline size_t
+str_rchr(const char* s, char needle) {
+  const char *in, *found = 0;
+
+  for(in = s; *in; ++in)
+    if(*in == needle)
+      found = in;
+
+  return (size_t)((found ? found : in) - s);
+}
+
+static inline size_t
+str_rchrs(const char* in, const char needles[], size_t nn) {
+  const char *s, *found = 0;
+  size_t i;
+
+  for(s = in; *s; ++s)
+    for(i = 0; i < nn; ++i)
+      if(*s == needles[i])
+        found = s;
+
+  return (size_t)((found ? found : s) - in);
+}
+
+static inline int
+str_endb(const char* a, const char* x, size_t n) {
+  size_t alen = strlen(a);
+  a += alen - n;
+
+  return alen >= n && !memcmp(a, x, n);
+}
+
+/* str_ends returns 1 if the b is a suffix of a, 0 otherwise */
+static inline int
+str_ends(const char* a, const char* b) {
+  return str_endb(a, b, strlen(b));
+}
+
+static inline int
+str_startb(const char* a, const char* x, size_t len) {
+  size_t i;
+
+  for(i = 0;; i++) {
+    if(i == len)
+      return 1;
+    if(a[i] != x[i])
+      break;
+  }
+
+  return 0;
+}
+
+static inline int
+str_start(const char* a, const char* b) {
+  return str_startb(a, b, strlen(b));
+}
+
+#define str_contains(s, needle) (!!strchr((s), (needle)))
+
+char* str_escape(const char*);
+
+static inline size_t
+str_count(const char* s, char c) {
+  size_t i, count = 0;
+
+  for(i = 0; s[i]; i++)
+    if(s[i] == c)
+      ++count;
+
+  return count;
+}
+
+static inline size_t
+str_copy(char* out, const char* in) {
+  char* s;
+
+  for(s = out; (*s = *in); ++s)
+    ++in;
+
+  return (size_t)(s - out);
+}
+
+static inline size_t
+str_copyn(char* out, const char* in, size_t n) {
+  char* s;
+
+  for(s = out; n-- && (*s = *in); ++s)
+    ++in;
+
+  *s = '\0';
+  return (size_t)(s - out);
+}
+
+static inline char*
+str_ndup(const char* s, size_t n) {
+  char* r = malloc(n + 1);
+
+  if(r == NULL)
+    return NULL;
+
+  memcpy(r, s, n);
+  r[n] = '\0';
+  return r;
+}
+
+size_t str_findb(const char*, const char*, size_t);
+size_t str_find(const void*, const void*);
+
+static inline size_t
+predicate_find(const char* str, size_t len, int (*pred)(int32_t)) {
+  size_t pos;
+
+  for(pos = 0; pos < len; pos++)
+    if(pred(str[pos]))
+      break;
+
+  return pos;
+}
+
+static inline size_t
+lookup_find(const char* str, size_t len, const char table[256]) {
+  size_t pos;
+
+  for(pos = 0; pos < len; pos++)
+    if(table[(unsigned char)str[pos]])
+      break;
+
+  return pos;
+}
+
+static inline char
+escape_char_letter(char c) {
+  switch(c) {
+    case '\0': return '0';
+    case '\a': return 'a';
+    case '\b': return 'b';
+    case '\t': return 't';
+    case '\n': return 'n';
+    case '\v': return 'v';
+    case '\f': return 'f';
+    case '\r': return 'r';
+    case '\\': return '\\';
+    case '\'': return '\'';
+  }
+
+  return 0;
+}
+
+#define FMT_LONG 41  /* enough space to hold -2^127 in decimal, plus \0 */
+#define FMT_ULONG 40 /* enough space to hold 2^128 - 1 in decimal, plus \0 */
+#define FMT_8LONG 44 /* enough space to hold 2^128 - 1 in octal, plus \0 */
+#define FMT_XLONG 33 /* enough space to hold 2^128 - 1 in hexadecimal, plus \0 */
+
+size_t token_length(const char*, size_t, char delim);
+size_t fmt_ulong(char*, uint32_t);
+size_t scan_ushort(const char*, uint16_t*);
+size_t fmt_longlong(char*, int64_t);
+size_t fmt_ulonglong(char*, uint64_t);
+size_t fmt_xlonglong(char*, uint64_t);
+size_t fmt_xlonglong0(char*, uint64_t, size_t);
+size_t fmt_8long(char* dest, uint32_t i);
+size_t fmt_xlong(char* dest, uint32_t num);
+size_t fmt_xlong0(char* dest, uint32_t num, size_t n);
+size_t scan_longlong(const char*, int64_t*);
+size_t scan_int(const char*, int32_t*);
+size_t scan_uint(const char*, uint32_t*);
+size_t scan_ulonglong(const char*, uint64_t*);
+size_t scan_xlonglong(const char*, uint64_t*);
+size_t scan_8longn(const char*, size_t, uint32_t* dest);
+size_t scan_whitenskip(const char*, size_t);
+size_t scan_nonwhitenskip(const char*, size_t);
+size_t scan_line(const char*, size_t);
+size_t scan_lineskip(const char*, size_t);
+size_t scan_lineskip_escaped(const char*, size_t);
+size_t scan_eolskip(const char*, size_t);
+size_t utf8_strlen(const void*, size_t);
+wchar_t* utf8_towcs(const char*);
+char* utf8_fromwcs(const wchar_t*);
+BOOL utf16_multiword(const void*);
+int case_lowerc(int);
+int case_starts(const char*, const char*);
+int case_diffb(const void*, size_t, const void* T);
+size_t case_findb(const void*, size_t, const void* what, size_t wlen);
+size_t case_finds(const void*, const char*);
+
+static inline int
+scan_fromhex(unsigned char c) {
+  c -= '0';
+
+  if(c <= 9)
+    return c;
+
+  c &= ~0x20;
+  c -= 'A' - '0';
+
+  if(c < 6)
+    return c + 10;
+
+  return -1;
+}
+
+static inline size_t
+scan_8long(const char* src, uint32_t* dest) {
+  return scan_8longn(src, (size_t)-1, dest);
+}
+
+static inline size_t
+utf8_charlen(const char* in, size_t len) {
+  const uint8_t* next = (const void*)in;
+  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
+  return r == -1 ? 0 : next - (const uint8_t*)in;
+}
+
+static inline int
+utf8_charcode(const char* in, size_t len) {
+  const uint8_t* next = (const void*)in;
+  int r = unicode_from_utf8((const uint8_t*)in, len, &next);
+  return next > in ? r : -1;
+}
+
+BOOL utf16_multiword(const void*);
+
+ssize_t write_file(const char* file, const void* buf, size_t len);
+ssize_t puts_file(const char* file, const char* s);
+
+size_t u64toa(char*, uint64_t num, int base);
+size_t i64toa(char*, int64_t num, int base);
+
+/**
+ * @}
+ */
+#endif /* defined(CHAR_UTILS_H) */

src/quickjs/debug.c

@@ -0,0 +1,483 @@
+#define _IN_DEBUG_C 1
+#include "debug.h"
+#include <quickjs.h>
+#include <list.h>
+#include <cutils.h>
+#include <assert.h>
+#include "defines.h"
+#include <string.h>
+#include <stdlib.h>
+
+/**
+ * \addtogroup debug
+ * @{
+ */
+struct alloc_block {
+  struct list_head link;
+  const char* file;
+  int line;
+  size_t size;
+};
+
+#define ALLOC_BLOCK_SIZE sizeof(struct alloc_block)
+#define ALLOC_BLOCK(p) (((struct alloc_block*)(p)) - 1)
+#define ALLOC_PTR struct alloc_block*
+
+#undef malloc
+#undef calloc
+#undef realloc
+#undef strdup
+#undef free
+#undef js_malloc
+#undef js_mallocz
+#undef js_realloc
+#undef js_strdup
+#undef js_strndup
+#undef js_free
+#undef js_malloc_usable_size
+#undef js_malloc_rt
+#undef js_mallocz_rt
+#undef js_realloc_rt
+#undef js_free_rt
+#undef js_malloc_usable_size_rt
+
+thread_local struct list_head alloc_block_list = {0, 0};
+
+static inline void
+add_to_list(struct list_head* el, struct list_head* head) {
+  if(alloc_block_list.prev == 0 && alloc_block_list.next == 0)
+    init_list_head(&alloc_block_list);
+
+  list_add_tail(el, head);
+}
+
+int64_t
+check_pointer(void* p) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+  struct list_head* link;
+  int64_t ret = 0;
+  list_for_each(link, &alloc_block_list) {
+    if(link == &ptr->link)
+      return ret;
+    ret++;
+  }
+  // assert(0);
+  return -1;
+}
+
+void*
+debug_malloc(size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = malloc(n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_calloc(size_t m, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  m *= n;
+  n = 1;
+
+  if((ptr = calloc(m + ALLOC_BLOCK_SIZE, 1))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_realloc(void* p, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if(p) {
+
+    check_pointer(p);
+
+    ptr = ALLOC_BLOCK(p);
+    list_del(&ptr->link);
+
+    if(n == 0) {
+      free(ptr);
+      return 0;
+    }
+
+    ptr = realloc(ptr, n + ALLOC_BLOCK_SIZE);
+  } else {
+    ptr = malloc(n + ALLOC_BLOCK_SIZE);
+  }
+
+  if(ptr) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_strdup(const char* s, const char* file, int line) {
+  ALLOC_PTR ptr;
+  size_t len = strlen(s);
+
+  if((ptr = malloc(len + 1 + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = len + 1;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+
+    memcpy(&ptr[1], s, len + 1);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void
+debug_free(void* p, const char* file, int line) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+
+  list_del(&ptr->link);
+
+  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
+
+  free(ptr);
+}
+
+void*
+debug_js_malloc(JSContext* ctx, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_mallocz(JSContext* ctx, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_mallocz(ctx, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_realloc(JSContext* ctx, void* p, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if(p) {
+
+    check_pointer(p);
+
+    ptr = ALLOC_BLOCK(p);
+    list_del(&ptr->link);
+
+    if(n == 0) {
+      js_free(ctx, ptr);
+      return 0;
+    }
+
+    ptr = js_realloc(ctx, ptr, n + ALLOC_BLOCK_SIZE);
+  } else {
+    ptr = js_malloc(ctx, n + ALLOC_BLOCK_SIZE);
+  }
+
+  if(ptr) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_realloc2(JSContext* ctx, void* p, size_t size, size_t* pslack, const char* file, int line) {
+  void* ptr;
+
+  if((ptr = debug_js_realloc(ctx, p, size, file, line))) {
+    if(pslack) {
+      size_t new_size = debug_js_malloc_usable_size(ctx, ptr, file, line);
+      *pslack = (new_size > size) ? new_size - size : 0;
+    }
+  }
+  return ptr;
+}
+
+void*
+debug_js_strdup(JSContext* ctx, const char* s, const char* file, int line) {
+  ALLOC_PTR ptr;
+  size_t len = strlen(s);
+
+  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
+    char* p = (char*)&ptr[1];
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = len + 1;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+
+    memcpy(p, s, len + 1);
+    return p;
+  }
+  return 0;
+}
+
+void*
+debug_js_strndup(JSContext* ctx, const char* s, size_t len, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_malloc(ctx, len + 1 + ALLOC_BLOCK_SIZE))) {
+    char* p = (char*)&ptr[1];
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = len + 1;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+
+    memcpy(p, s, len);
+    p[len] = '\0';
+
+    return p;
+  }
+  return 0;
+}
+
+size_t
+debug_js_malloc_usable_size(JSContext* ctx, const void* p, const char* file, int line) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+
+  return js_malloc_usable_size(ctx, ptr) - ALLOC_BLOCK_SIZE;
+}
+
+void
+debug_js_free(JSContext* ctx, void* p, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  check_pointer(p);
+  ptr = ALLOC_BLOCK(p);
+  list_del(&ptr->link);
+
+  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
+
+  js_free(ctx, ptr);
+}
+
+void*
+debug_js_malloc_rt(JSRuntime* rt, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_mallocz_rt(JSRuntime* rt, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if((ptr = js_mallocz_rt(rt, n + ALLOC_BLOCK_SIZE))) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+void*
+debug_js_realloc_rt(JSRuntime* rt, void* p, size_t n, const char* file, int line) {
+  ALLOC_PTR ptr;
+
+  if(p) {
+    check_pointer(p);
+
+    ptr = ALLOC_BLOCK(p);
+    list_del(&ptr->link);
+    if(n == 0) {
+      js_free_rt(rt, ptr);
+      return 0;
+    }
+    ptr = js_realloc_rt(rt, ptr, n + ALLOC_BLOCK_SIZE);
+  } else {
+    ptr = js_malloc_rt(rt, n + ALLOC_BLOCK_SIZE);
+  }
+
+  if(ptr) {
+    ptr->file = file;
+    ptr->line = line;
+    ptr->size = n;
+
+    add_to_list(&ptr->link, &alloc_block_list);
+    return &ptr[1];
+  }
+  return 0;
+}
+
+size_t
+debug_js_malloc_usable_size_rt(JSRuntime* rt, const void* p, const char* file, int line) {
+  ALLOC_PTR ptr = ALLOC_BLOCK(p);
+
+  return js_malloc_usable_size_rt(rt, ptr) - ALLOC_BLOCK_SIZE;
+}
+
+void
+debug_js_free_rt(JSRuntime* rt, void* p, const char* file, int line) {
+  ALLOC_PTR ptr;
+  check_pointer(p);
+
+  ptr = ALLOC_BLOCK(p);
+
+  // printf("debug_js_free_rt %p\n", p);
+
+  list_del(&ptr->link);
+
+  memset(ptr, 0xff, ALLOC_BLOCK_SIZE);
+
+  js_free_rt(rt, ptr);
+}
+
+#undef malloc
+#undef calloc
+#undef realloc
+#undef strdup
+#undef free
+#undef js_malloc
+#undef js_mallocz
+#undef js_realloc
+#undef js_strdup
+#undef js_strndup
+#undef js_malloc_usable_size
+#undef js_free
+#undef js_malloc_rt
+#undef js_mallocz_rt
+#undef js_realloc_rt
+#undef js_malloc_usable_size_rt
+#undef js_free_rt
+
+void*
+orig_malloc(size_t size) {
+  return malloc(size);
+}
+
+void*
+orig_calloc(size_t nelem, size_t elemsz) {
+  return calloc(nelem, elemsz);
+}
+
+void*
+orig_realloc(void* ptr, size_t size) {
+  return realloc(ptr, size);
+}
+
+void*
+orig_strdup(const char* str) {
+  return strdup(str);
+}
+
+void
+orig_free(void* ptr) {
+  free(ptr);
+}
+
+void*
+orig_js_malloc(JSContext* ctx, size_t size) {
+  return js_malloc(ctx, size);
+}
+
+void*
+orig_js_mallocz(JSContext* ctx, size_t size) {
+  return js_mallocz(ctx, size);
+}
+
+void*
+orig_js_realloc(JSContext* ctx, void* p, size_t size) {
+  return js_realloc(ctx, p, size);
+}
+
+void*
+orig_js_strdup(JSContext* ctx, const char* str) {
+  return js_strdup(ctx, str);
+}
+
+void*
+orig_js_strndup(JSContext* ctx, const char* str, size_t size) {
+  return js_strndup(ctx, str, size);
+}
+
+size_t
+orig_js_malloc_usable_size(JSContext* ctx, const void* p) {
+  return js_malloc_usable_size(ctx, p);
+}
+
+void
+orig_js_free(JSContext* ctx, void* p) {
+  return js_free(ctx, p);
+}
+
+void*
+orig_js_malloc_rt(JSRuntime* rt, size_t size) {
+  return js_malloc_rt(rt, size);
+}
+
+void*
+orig_js_mallocz_rt(JSRuntime* rt, size_t size) {
+  return js_mallocz_rt(rt, size);
+}
+
+void*
+orig_js_realloc_rt(JSRuntime* rt, void* p, size_t size) {
+  return js_realloc_rt(rt, p, size);
+}
+
+size_t
+orig_js_malloc_usable_size_rt(JSRuntime* rt, const void* p) {
+  return js_malloc_usable_size_rt(rt, p);
+}
+
+void
+orig_js_free_rt(JSRuntime* rt, void* p) {
+  return js_free_rt(rt, p);
+}
+
+/**
+ * @}
+ */

src/quickjs/debug.h

@@ -0,0 +1,165 @@
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include <quickjs.h>
+#include <cutils.h>
+#include "defines.h"
+
+#ifndef QUICKJS_H
+#error "quickjs.h not included"
+#endif
+
+/**
+ * \defgroup debug debug: Debugging helpers
+ * @{
+ */
+
+extern thread_local struct list_head alloc_block_list;
+
+int64_t check_pointer(void*);
+void* debug_malloc(size_t, const char*, int);
+void* debug_calloc(size_t, size_t, const char*, int line);
+void* debug_realloc(void*, size_t, const char*, int line);
+void* debug_strdup(const char*, const char*, int);
+void debug_free(void*, const char*, int);
+void* debug_js_malloc(JSContext*, size_t, const char*, int line);
+void* debug_js_mallocz(JSContext*, size_t, const char*, int line);
+void* debug_js_realloc(JSContext*, void*, size_t, const char* file, int line);
+void* debug_js_realloc2(JSContext*, void*, size_t, size_t* pslack, const char* file, int line);
+void* debug_js_strdup(JSContext*, const char*, const char*, int line);
+void* debug_js_strndup(JSContext*, const char*, size_t, const char* file, int line);
+size_t debug_js_malloc_usable_size(JSContext*, const void*, const char*, int line);
+void debug_js_free(JSContext*, void*, const char*, int line);
+void* debug_js_malloc_rt(JSRuntime*, size_t, const char*, int line);
+void* debug_js_mallocz_rt(JSRuntime*, size_t, const char*, int line);
+void* debug_js_realloc_rt(JSRuntime*, void*, size_t, const char* file, int line);
+size_t debug_js_malloc_usable_size_rt(JSRuntime*, const void*, const char*, int line);
+void debug_js_free_rt(JSRuntime*, void*, const char*, int line);
+
+#if !defined(_IN_DEBUG_C)
+
+#if defined(DEBUG_ALLOC)
+#define malloc(size) debug_malloc(size, __FILE__, __LINE__)
+#define calloc(nelem, size) debug_calloc(nelem, size, __FILE__, __LINE__)
+#define realloc(ptr, size) debug_realloc(ptr, size, __FILE__, __LINE__)
+#define strdup(str) debug_strdup(str, __FILE__, __LINE__)
+#define free(ptr) debug_free(ptr, __FILE__, __LINE__)
+#define js_malloc(ctx, size) debug_js_malloc(ctx, size, __FILE__, __LINE__)
+#define js_mallocz(ctx, size) debug_js_mallocz(ctx, size, __FILE__, __LINE__)
+#define js_realloc(ctx, ptr, size) debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__)
+#define js_strdup(ctx, str) debug_js_strdup(ctx, str, __FILE__, __LINE__)
+#define js_strndup(ctx, str, len) debug_js_strndup(ctx, str, len, __FILE__, __LINE__)
+#define js_free(ctx, ptr) debug_js_free(ctx, ptr, __FILE__, __LINE__)
+#define js_malloc_usable_size(ctx, ptr) debug_js_malloc_usable_size(ctx, ptr, __FILE__, __LINE__)
+#define js_malloc_rt(rt, size) debug_js_malloc_rt(rt, size, __FILE__, __LINE__)
+#define js_mallocz_rt(rt, size) debug_js_mallocz_rt(rt, size, __FILE__, __LINE__)
+#define js_realloc_rt(rt, ptr, size) debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__)
+#define js_malloc_usable_size_rt(rt, ptr) debug_js_malloc_usable_size_rt(rt, ptr, __FILE__, __LINE__)
+#define js_free_rt(rt, ptr) debug_js_free_rt(rt, ptr, __FILE__, __LINE__)
+#endif
+
+#ifdef DEBUG_ALLOC
+#define realloc_helper(name) \
+  void* name(void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_malloc(size, __FILE__, __LINE__); \
+    if(size == 0) \
+      return debug_free(ptr, __FILE__, __LINE__); \
+    return debug_realloc(ptr, size, __FILE__, __LINE__); \
+  }
+#define realloc2_helper(name) \
+  void* name(void* opaque, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_malloc(size, __FILE__, __LINE__); \
+    if(size == 0) { \
+      debug_free(ptr, __FILE__, __LINE__); \
+      return 0; \
+    } \
+    return debug_realloc(ptr, size, __FILE__, __LINE__); \
+  }
+#define js_realloc_helper(name) \
+  void* name(JSContext* ctx, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_js_malloc(ctx, size, __FILE__, __LINE__); \
+    if(size == 0) { \
+      debug_js_free(ctx, ptr, __FILE__, __LINE__); \
+      return 0; \
+    } \
+    return debug_js_realloc(ctx, ptr, size, __FILE__, __LINE__); \
+  }
+#define js_realloc_rt_helper(name) \
+  void* name(JSRuntime* rt, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return debug_js_malloc_rt(rt, size, __FILE__, __LINE__); \
+    if(size == 0) { \
+      debug_js_free_rt(rt, ptr, __FILE__, __LINE__); \
+      return 0; \
+    } \
+    return debug_js_realloc_rt(rt, ptr, size, __FILE__, __LINE__); \
+  }
+#else
+#define realloc_helper(name) \
+  void* name(void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return malloc(size); \
+    if(size == 0) { \
+      free(ptr); \
+      return 0; \
+    } \
+    return realloc(ptr, size); \
+  }
+#define realloc2_helper(name) \
+  void* name(void* opaque, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return malloc(size); \
+    if(size == 0) { \
+      free(ptr); \
+      return 0; \
+    } \
+    return realloc(ptr, size); \
+  }
+#define js_realloc_helper(name) \
+  void* name(JSContext* ctx, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return orig_js_malloc(ctx, size); \
+    if(size == 0) { \
+      orig_js_free(ctx, ptr); \
+      return 0; \
+    } \
+    return orig_js_realloc(ctx, ptr, size); \
+  }
+#define js_realloc_rt_helper(name) \
+  void* name(JSRuntime* rt, void* ptr, size_t size) { \
+    if(ptr == 0) \
+      return orig_js_malloc_rt(rt, size); \
+    if(size == 0) { \
+      orig_js_free_rt(rt, ptr); \
+      return 0; \
+    } \
+    return orig_js_realloc_rt(rt, ptr, size); \
+  }
+#endif
+#endif
+
+void* orig_malloc(size_t);
+void* orig_calloc(size_t, size_t);
+void* orig_realloc(void*, size_t);
+void* orig_strdup(const char*);
+void orig_free(void*);
+void* orig_js_malloc(JSContext*, size_t);
+void* orig_js_mallocz(JSContext*, size_t);
+void* orig_js_realloc(JSContext*, void*, size_t);
+void* orig_js_strdup(JSContext*, const char*);
+void* orig_js_strndup(JSContext*, const char*, size_t);
+size_t orig_js_malloc_usable_size(JSContext*, const void*);
+void orig_js_free(JSContext*, void*);
+void* orig_js_malloc_rt(JSRuntime*, size_t);
+void* orig_js_mallocz_rt(JSRuntime*, size_t);
+void* orig_js_realloc_rt(JSRuntime*, void*, size_t);
+size_t orig_js_malloc_usable_size_rt(JSRuntime*, const void*);
+void orig_js_free_rt(JSRuntime*, void*);
+
+/**
+ * @}
+ */
+#endif /* defined(DEBUG_H) */

src/quickjs/defines.h

@@ -0,0 +1,181 @@
+#ifndef DEFINES_H
+#define DEFINES_H
+
+/**
+ * \defgroup defines defines: Preprocessor definitions
+ * @{
+ */
+
+#ifdef _WIN32
+#include <io.h>
+#define FD_TO_SOCKET(fd) ((SOCKET)_get_osfhandle((fd)))
+#define SOCKET_TO_FD(fh) (_open_osfhandle((intptr_t)(fh), O_RDWR | O_BINARY))
+#else
+#define FD_TO_SOCKET(fd) (fd)
+#define SOCKET_TO_FD(fh) (fh)
+#endif
+
+#ifndef offsetof
+#define offsetof(type, field) ((size_t) & ((type*)0)->field)
+#endif
+
+#ifndef inrange
+#define inrange(value, min, max) ((value) >= (min) && (value) <= (max))
+#endif
+
+#define trim_dotslash(str) (!strncmp((str), "./", 2) ? (str) + 2 : (str))
+
+#ifndef thread_local
+#ifdef _Thread_local
+#define thread_local _Thread_local
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
+#define thread_local __thread
+#elif defined(_WIN32)
+#define thread_local __declspec(thread)
+#else
+#error No TLS implementation found.
+#endif
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define PACK __attribute__((packed))
+#define ENDPACK
+#else
+#define PACK #pragma pack(push, 1)
+#define ENDPACK #pragma pack(pop)
+#endif
+
+#define JS_CGETSET_ENUMERABLE_DEF(prop_name, fgetter, fsetter, magic_num) \
+  { \
+    .name = prop_name, .prop_flags = JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
+      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
+    } \
+  }
+
+#define JS_CGETSET_MAGIC_FLAGS_DEF(prop_name, fgetter, fsetter, magic_num, flags) \
+  { \
+    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CGETSET_MAGIC, .magic = magic_num, .u = { \
+      .getset = {.get = {.getter_magic = fgetter}, .set = {.setter_magic = fsetter}} \
+    } \
+  }
+
+#define JS_CFUNC_DEF_FLAGS(prop_name, length, func1, flags) \
+  { \
+    .name = prop_name, .prop_flags = flags, .def_type = JS_DEF_CFUNC, .magic = 0, .u = {.func = {length, JS_CFUNC_generic, {.generic = func1}} } \
+  }
+
+#define JS_CONSTANT_FLAGS(name, flags) JS_PROP_INT32_DEF(#name, name, (flags))
+#define JS_CONSTANT(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE)
+#define JS_CONSTANT_NONENUMERABLE(name) JS_PROP_INT32_DEF(#name, name, JS_PROP_CONFIGURABLE)
+
+#ifdef JS_SHARED_LIBRARY
+#if defined(_WIN32) || defined(__MINGW32__)
+#define VISIBLE __declspec(dllexport)
+#define HIDDEN
+#else
+#define VISIBLE __attribute__((visibility("default")))
+#define HIDDEN __attribute__((visibility("hidden")))
+#endif
+#else
+#define VISIBLE
+#define HIDDEN
+#endif
+
+#ifndef MAX_NUM
+#define MAX_NUM(a, b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef MIN_NUM
+#define MIN_NUM(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef ABS_NUM
+#define ABS_NUM(n) ((n) < 0 ? -(n) : (n))
+#endif
+#ifndef MOD_NUM
+#define MOD_NUM(n, divisor) ((((n) % (divisor)) + (divisor)) % (divisor))
+#endif
+#ifndef SIGN_NUM
+#define SIGN_NUM(n) ((n) < 0)
+#endif
+
+#define COLOR_BLACK "\x1b[0;30m"
+#define COLOR_RED "\x1b[0;31m"
+#define COLOR_GREEN "\x1b[0;32m"
+#define COLOR_BROWN "\x1b[0;33m"
+#define COLOR_BLUE "\x1b[0;34m"
+#define COLOR_PURPLE "\x1b[0;35m"
+#define COLOR_MARINE "\x1b[0;36m"
+#define COLOR_LIGHTGRAY "\x1b[0;37m"
+#define COLOR_GRAY "\x1b[1;30m"
+#define COLOR_NONE "\x1b[0m"
+
+#define COLOR_LIGHTRED "\x1b[1;31m"
+
+#define COLOR_LIGHTGREEN "\x1b[1;32m"
+#define COLOR_YELLOW "\x1b[1;33m"
+#define COLOR_LIGHTBLUE "\x1b[1;34m"
+#define COLOR_MAGENTA "\x1b[1;35m"
+#define COLOR_CYAN "\x1b[1;36m"
+#define COLOR_WHITE "\x1b[1;37m"
+
+#define BGCOLOR_RED "\x1b[48;5;124m"
+#define BGCOLOR_BLUE "\x1b[48;5;20m"
+#define BGCOLOR_YELLOW "\x1b[48;5;214m"
+#define BGCOLOR_GREEN "\x1b[48;5;28m"
+#define BGCOLOR_PINK "\x1b[48;5;165m"
+
+#define JS_VALUE_FREE(ctx, value) \
+  do { \
+    JS_FreeValue((ctx), (value)); \
+    (value) = JS_UNDEFINED; \
+  } while(0);
+#define JS_VALUE_FREE_RT(ctx, value) \
+  do { \
+    JS_FreeValueRT((ctx), (value)); \
+    (value) = JS_UNDEFINED; \
+  } while(0);
+
+#if 0
+#define js_object_tmpmark_set(value) \
+  do { \
+    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] |= 0x40; \
+  } while(0);
+#define js_object_tmpmark_clear(value) \
+  do { \
+    ((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] &= ~0x40; \
+  } while(0);
+#define js_object_tmpmark_isset(value) (((uint8_t*)JS_VALUE_GET_OBJ((value)))[5] & 0x40)
+#else
+#define js_object_tmpmark_set(value) \
+  do { \
+    JS_VALUE_GET_OBJ((value))->tmp_mark |= 0x40; \
+  } while(0);
+#define js_object_tmpmark_clear(value) \
+  do { \
+    JS_VALUE_GET_OBJ((value))->tmp_mark &= ~0x40; \
+  } while(0);
+#define js_object_tmpmark_isset(value) (JS_VALUE_GET_OBJ((value))->tmp_mark & 0x40)
+#endif
+
+#define js_runtime_exception_set(rt, value) \
+  do { \
+    *(JSValue*)((uint8_t*)(rt) + 216) = value; \
+  } while(0);
+#define js_runtime_exception_get(rt) (*(JSValue*)((uint8_t*)(rt) + 216))
+#define js_runtime_exception_clear(rt) \
+  do { \
+    if(!JS_IsNull(js_runtime_exception_get(rt))) \
+      JS_FreeValueRT((rt), js_runtime_exception_get(rt)); \
+    js_runtime_exception_set(rt, JS_NULL); \
+  } while(0)
+
+#define JS_ATOM_TAG_INT (1U << 31)
+#define JS_ATOM_MAX_INT (JS_ATOM_TAG_INT - 1)
+
+#define JS_ATOM_ISINT(i) ((JSAtom)((i)&JS_ATOM_TAG_INT))
+#define JS_ATOM_FROMINT(i) ((JSAtom)((i)&JS_ATOM_MAX_INT) | JS_ATOM_TAG_INT)
+#define JS_ATOM_TOINT(i) (unsigned int)(((JSAtom)(i) & (~(JS_ATOM_TAG_INT))))
+
+/**
+ * @}
+ */
+#endif /* defined(DEFINES_H) */

src/quickjs/iso_8859_1.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_1_H
+#define TUTF8E_ISO_8859_1_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_1_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_1_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_1, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_1_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_1, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_1_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_1, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_10.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_10_H
+#define TUTF8E_ISO_8859_10_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_10_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_10_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_10, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_10_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_10, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_10_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_10, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_11.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_11_H
+#define TUTF8E_ISO_8859_11_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_11_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_11_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_11, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_11_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_11, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_11_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_11, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_13.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_13_H
+#define TUTF8E_ISO_8859_13_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_13_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_13_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_13, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_13_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_13, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_13_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_13, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_14.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_14_H
+#define TUTF8E_ISO_8859_14_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_14_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_14, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_14_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_14, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_14_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_14, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_14_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_14, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_15.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_15_H
+#define TUTF8E_ISO_8859_15_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_15_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_15, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_15_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_15, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_15_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_15, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_15_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_15, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_16.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_16_H
+#define TUTF8E_ISO_8859_16_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_16_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_16, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_16_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_16, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_16_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_16, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_16_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_16, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_2.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_2_H
+#define TUTF8E_ISO_8859_2_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_2_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_2, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_2_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_2, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_2_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_2, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_2_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_2, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_3.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_3_H
+#define TUTF8E_ISO_8859_3_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_3_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_3, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_3_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_3, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_3_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_3, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_3_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_3, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_4.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_4_H
+#define TUTF8E_ISO_8859_4_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_4_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_4, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_4_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_4, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_4_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_4, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_4_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_4, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_5.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_5_H
+#define TUTF8E_ISO_8859_5_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_5_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_5, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_5_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_5, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_5_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_5, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_5_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_5, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_6.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_6_H
+#define TUTF8E_ISO_8859_6_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_6_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_6, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_6_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_6, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_6_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_6, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_6_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_6, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_7.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_7_H
+#define TUTF8E_ISO_8859_7_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_7_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_7, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_7_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_7, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_7_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_7, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_7_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_7, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_8.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_8_H
+#define TUTF8E_ISO_8859_8_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_8_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_8, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_8_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_8, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_8_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_8, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_8_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_8, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/iso_8859_9.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_ISO_8859_9_H
+#define TUTF8E_ISO_8859_9_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_iso_8859_9_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_iso_8859_9, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_iso_8859_9_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_iso_8859_9, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_iso_8859_9_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_iso_8859_9, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_iso_8859_9_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_iso_8859_9, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/libutf.c

@@ -0,0 +1,153 @@
+#include <libutf.h>
+
+#include <assert.h>
+#include <stdlib.h>
+
+LibutfC16Type libutf_c16_type(uint_least16_t c16) {
+    if (0xD800 != (0xF800 & c16)) {
+        return LIBUTF_UTF16_NOT_SURROGATE;
+    }
+    return (c16 & 0x0400) ? LIBUTF_UTF16_SURROGATE_LOW : LIBUTF_UTF16_SURROGATE_HIGH;
+}
+
+LibutfC8Type libutf_c8_type(char c) {
+    static const LibutfC8Type lookup_table[256] = {
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+           -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+           -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+           -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+           -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+            4, 4, 4, 4, 4, 4, 4, 4,-2,-2,-2,-2,-2,-2,-2,-2,
+    };
+    return lookup_table[(unsigned char) c];
+}
+
+bool libutf_c32_to_c8(uint_least32_t c32, int *length, char c8[4]) {
+    if (!libutf_c32_is_valid(c32)) {
+        *length = 3;
+        c8[0] = (char) 0xEF;
+        c8[1] = (char) 0xBF;
+        c8[2] = (char) 0xBD;
+        return false;
+    }
+    if (c32 <= 0x007F) {
+        c8[0] = c32;
+        *length = 1;
+        return true;
+    } else if (c32 <= 0x07FF) {
+        c8[0] = (char) (0xC0 | (c32 >> 6));
+        c8[1] = (char) (0x80 | (c32 & 0x3F));
+        *length = 2;
+        return true;
+    } else if (c32 <= 0xFFFF) {
+        c8[0] = (char) (0xE0 | (c32 >> 12));
+        c8[1] = (char) (0x80 | ((c32 >> 6) & 0x3F));
+        c8[2] = (char) (0x80 | (c32 & 0x3F));
+        *length = 3;
+        return true;
+    }
+    assert(c32 <= 0x10FFFF);
+    c8[0] = (char) (0xF0 | (c32 >> 18));
+    c8[1] = (char) (0x80 | ((c32 >> 12) & 0x3F));
+    c8[2] = (char) (0x80 | ((c32 >> 6) & 0x3F));
+    c8[3] = (char) (0x80 | (c32 & 0x3F));
+    *length = 4;
+    return true;
+}
+
+bool libutf_c8_to_c32(const char *c8, uint_least32_t *c32) {
+    if (!c8 || !c32) {
+        return false;
+    }
+    unsigned char c = *c8;
+    *c32 = 0xFFFD;
+    LibutfC8Type type = libutf_c8_type(c);
+    if (type < 0) {
+        return false;
+    }
+    int len = type;
+    uint_least32_t result;
+    switch (len) {
+    case 1:
+        *c32 = c;
+        return true;
+    case 2:
+        result = c & 0x1F;
+        break;
+    case 3:
+        result = c & 0x0F;
+        break;
+    case 4:
+        result = c & 0x07;
+        break;
+    default:
+        abort();
+    }
+    for (int i = 1; i < len; ++i) {
+        c = *++c8;
+        if ((0xC0 & c) != 0x80) {
+            return false;
+        }
+        result = (result << 6) + (c & 0x3F);
+    }
+    if (!libutf_c32_is_valid(result)) {
+        return false;
+    }
+    char c8seq[4];
+    int n;
+    bool ok = libutf_c32_to_c8(result, &n, c8seq);
+    assert(ok);
+    if (n < (int) len) {
+        return false;
+    }
+    *c32 = result;
+    return true;
+}
+
+bool libutf_c32_to_c16(uint_least32_t c32, int *length, uint_least16_t c16[2]) {
+    if (!libutf_c32_is_valid(c32)) {
+        c16[0] = 0xFFFD;
+        c16[1] = 0;
+        *length = 1;
+        return false;
+    }
+    if (c32 < 0x10000) {
+        c16[0] = c32;
+        c16[1] = 0;
+        *length = 1;
+    } else {
+        c32 -= 0x10000;
+        c16[0] = 0xD800 | (c32 >> 10);
+        c16[1] = 0xDC00 | (c32 & 0x3FF);
+        *length = 2;
+    }
+    return true;
+}
+
+bool libutf_c16_to_c32(uint_least16_t c16[2], uint_least32_t *c32) {
+    LibutfC16Type type = libutf_c16_type(c16[0]);
+    if (LIBUTF_UTF16_NOT_SURROGATE == type) {
+        *c32 = c16[0];
+        return true;
+    }
+    if (LIBUTF_UTF16_SURROGATE_HIGH != type || LIBUTF_UTF16_SURROGATE_LOW != libutf_c16_type(c16[1])) {
+        *c32 = 0xFFFD;
+        return false;
+    }
+    *c32 = 0x10000 + ((c16[0] & 0x3FF) << 10) + (c16[1] & 0x3ff);
+    return true;
+}
+
+bool libutf_c32_is_valid(uint_least32_t c32) {
+    return c32 < 0xD800 || (0xDFFF < c32 && c32 < 0x110000);
+}

src/quickjs/libutf.h

@@ -0,0 +1,109 @@
+/* LIBrary of UTF-(8,16,32) helper utility functions.
+ *
+ * Terminology:
+ * code point = number of a Unicode character
+ * code unit
+ *   = 1 byte  for UTF-8
+ *   = 2 bytes for UTF-16
+ *   = 4 bytes for UTF-32
+ * sequence = sequence of code units encoding SINGLE Unicode character
+ *
+ * Unicode has code points 0x000000..0x10FFFF except for the codes 0xD800..0xDFFF which are
+ * reserved for UTF-16 surrogate pairs.
+ *
+ * UTF-32 is the simplest Unicode encoding. It encodes Unicode code points as is. Thus we may use
+ * UTF-32 as a synonym for Unicode code point.
+ * + O(1) indexing
+ * - the text is 2-4 times bigger than in other encodings
+ *
+ * UTF-16 is variable width encoding. Each Unicode code point is represented as either single
+ * code unit (two-byte number) or two code units which are called surrogate pairs.
+ * - ASCII-only texts will be twice as big as in ASCII
+ * - O(n) indexing
+ *
+ * UTF-8 is a variable width encoding. Each Unicode code point is represented as a sequence
+ * of up to 4 bytes. The first byte determines the length of the sequence.
+ * + is a superset of ASCII
+ * + ASCII-only texts will have the same size
+ * - O(n) indexing
+ * - single Unicode code point can have different representations in
+ *   UTF-8, only the shortest one is considered valid
+ */
+
+#ifndef LIBUTF_H
+#define LIBUTF_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+// UTF-8 code unit type
+typedef enum {
+    LIBUTF_UTF8_OVERLONG   = -2,
+    LIBUTF_UTF8_TRAILING   = -1,
+    LIBUTF_UTF8_ONE_BYTE   = 1,
+    LIBUTF_UTF8_TWO_BYTE   = 2,
+    LIBUTF_UTF8_THREE_BYTE = 3,
+    LIBUTF_UTF8_FOUR_BYTE  = 4,
+} LibutfC8Type;
+
+// UTF-16 code unit type
+typedef enum {
+    LIBUTF_UTF16_SURROGATE_LOW  = -1,
+    LIBUTF_UTF16_NOT_SURROGATE  = 1,
+    LIBUTF_UTF16_SURROGATE_HIGH = 2,
+} LibutfC16Type;
+
+/* Determine type of UTF-16 code unit. type = length of UTF-16 sequence starting with the specified code unit
+ * or negative value if sequence cannot start with this code unit. */
+LibutfC16Type libutf_c16_type(uint_least16_t c16);
+
+/* Determine type of UTF-8 sequence based on the first byte. type = length of UTF-8 sequence starting
+ * with this byte or negative value if the byte cannot be first. UTF-8 may be up to 4 bytes long.
+ * Common idiom for using this function:
+ * >>> LibutfC8Type type = libutf_c8_type(c);
+ * >>> if (type < 0) {
+ * >>>     return ERROR_CODE;
+ * >>> }
+ * >>> int length = type;
+ * */
+LibutfC8Type libutf_c8_type(char c);
+
+/* Convert Unicode code point into UTF-8 sequence. If c32 is not a valid
+ * Unicode code point c8 will be filled with UTF-8 representation of special
+ * replacement character U+FFFD, *length will be set to its length and false will be returned.
+ * c32    -- UTF-32 Unicode code point
+ * length -- where to put length of the UTF-8 sequence.
+ * c8     -- where to put UTF-8 sequence. Make sure string has enough space.
+ * result -- true if c32 is a valid Unicode code point or false otherwise. */
+bool libutf_c32_to_c8(uint_least32_t c32, int *length, char c8[4]);
+
+/* Convert UTF-8 sequence into a UTF-32 Unicode code point. If c8 does not
+ * point to a valid UTF-8 sequence c32 will be filled with special replacement
+ * character U+FFFD and false will be returned.
+ * c8     -- pointer to UTF-8 sequence.
+ * c32    -- where to save UTF-32 Unicode code point.
+ * result -- true if c8 points to a valid UTF-8 sequence or false otherwise. */
+bool libutf_c8_to_c32(const char *c8, uint_least32_t *c32);
+
+/* Convert UTF-32 Unicode code point into UTF-16 sequence. If c32 is not a valid
+ * Unicode code point c16 will be filled with UTF-16 representation of special
+ * replacement character U+FFFD and false will be returned.
+ * c32    -- UTF-32 Unicode code point.
+ * length -- were to put length of UTF-16 sequence.
+ * c16    -- where to put UTF-16 sequence (c16[0] -- high surrogate, c16[1] -- low surrogate)
+ * result -- true if c32 is a valid Unicode code point or false otherwise. */
+bool libutf_c32_to_c16(uint_least32_t c32, int *length, uint_least16_t c16[2]);
+
+/* Construct UTF-32 Unicode code point from UTF-16 surrogate pair. high
+ * must be high surrogate and low must be low surrogate otherwise *c32 will
+ * be filled with special replacement character U+FFFD and false will be returned.
+ * c16    -- where to put UTF-16 sequence (c32[0] -- high surrogate, c32[1] -- low surrogate)
+ * result -- true if c16 points to a valid UTF-16 sequence (single not surrogate
+ * or valid surrogate pair) or false otherwise. */
+bool libutf_c16_to_c32(uint_least16_t c16[2], uint_least32_t *c32);
+
+/* Check whether given value is a valid Unicode code point i.e. below 0x110000 and is not
+ * a UTF-16 surrogate. */
+bool libutf_c32_is_valid(uint_least32_t c32);
+
+#endif

src/quickjs/qsort_r.c

@@ -0,0 +1,87 @@
+#include <sys/types.h>
+#include <stdlib.h>
+
+static void
+exch(char* base, size_t size, size_t a, size_t b) {
+  char* x = base + a * size;
+  char* y = base + b * size;
+  while(size) {
+    char z = *x;
+    *x = *y;
+    *y = z;
+    --size;
+    ++x;
+    ++y;
+  }
+}
+
+#define RAND
+
+/* Quicksort with 3-way partitioning, ala Sedgewick */
+/* Blame him for the scary variable names */
+/* http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf */
+static void
+quicksort(char* base, size_t size, ssize_t l, ssize_t r, int (*compar)(const void*, const void*, void*), void* ptr) {
+  ssize_t i = l - 1, j = r, p = l - 1, q = r, k;
+  char* v = base + r * size;
+  if(r <= l)
+    return;
+
+#ifdef RAND
+  /*
+     We chose the rightmost element in the array to be sorted as pivot,
+     which is OK if the data is random, but which is horrible if the
+     data is already sorted.  Try to improve by exchanging it with a
+     random other pivot.
+   */
+  exch(base, size, l + (rand() % (r - l)), r);
+#elif defined MID
+  /*
+     We chose the rightmost element in the array to be sorted as pivot,
+     which is OK if the data is random, but which is horrible if the
+     data is already sorted.  Try to improve by chosing the middle
+     element instead.
+   */
+  exch(base, size, l + (r - l) / 2, r);
+#endif
+
+  for(;;) {
+    while(++i != r && compar(base + i * size, v, ptr) < 0)
+      ;
+    while(compar(v, base + (--j) * size, ptr) < 0)
+      if(j == l)
+        break;
+    if(i >= j)
+      break;
+    exch(base, size, i, j);
+    if(compar(base + i * size, v, ptr) == 0)
+      exch(base, size, ++p, i);
+    if(compar(v, base + j * size, ptr) == 0)
+      exch(base, size, j, --q);
+  }
+  exch(base, size, i, r);
+  j = i - 1;
+  ++i;
+  for(k = l; k < p; k++, j--)
+    exch(base, size, k, j);
+  for(k = r - 1; k > q; k--, i++)
+    exch(base, size, i, k);
+  quicksort(base, size, l, j, compar, ptr);
+  quicksort(base, size, i, r, compar, ptr);
+}
+
+void
+quicksort_r(void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*, void*), void* ptr) {
+  /* check for integer overflows */
+  if(nmemb >= (((size_t)-1) >> 1) || size >= (((size_t)-1) >> 1))
+    return;
+#if 0
+  if (sizeof(size_t) < sizeof(unsigned long long)) {
+    if ((unsigned long long)size * nmemb > (size_t)-1) return;
+  } else {
+    if (size*nmemb/nmemb != size) return;
+  }
+#endif
+  if(nmemb > 1)
+    quicksort(base, size, 0, nmemb - 1, compar, ptr);
+}

src/quickjs/quickjs-config.h

@@ -0,0 +1,8 @@
+#ifndef __QUICKJS_CONFIG_H
+#define __QUICKJS_CONFIG_H
+
+#ifdef _WIN32
+#define _WIN32_WINNT 0x0600
+#endif
+
+#endif	// __QUICKJS_CONFIG_H

src/quickjs/quickjs-internal.c

@@ -0,0 +1,645 @@
+#include "utils.h"
+#include "char-utils.h"
+#include "vector.h"
+#include "quickjs-internal.h"
+
+JSValue
+js_std_file(JSContext* ctx, FILE* f) {
+  JSClassID class_id = js_class_find(ctx, "FILE");
+  JSValue obj, proto = JS_GetClassProto(ctx, class_id);
+  JSSTDFile* file;
+
+  file = js_malloc(ctx, sizeof(JSSTDFile));
+  *file = (JSSTDFile){0, TRUE, FALSE};
+
+  file->f = f;
+
+  obj = JS_NewObjectProtoClass(ctx, proto, class_id);
+
+  JS_SetOpaque(obj, file);
+
+  return obj;
+}
+
+struct list_head*
+js_modules_list(JSContext* ctx) {
+  return &ctx->loaded_modules;
+}
+
+JSModuleDef**
+js_modules_vector(JSContext* ctx) {
+  struct list_head* el;
+  Vector vec = VECTOR(ctx);
+  JSModuleDef* m;
+
+  list_for_each(el, js_modules_list(ctx)) {
+    m = list_entry(el, JSModuleDef, link);
+
+    vector_push(&vec, m);
+  }
+
+  m = NULL;
+  vector_push(&vec, m);
+
+  return vector_begin(&vec);
+}
+
+JSValue
+js_modules_entries(JSContext* ctx, JSValueConst this_val, int magic) {
+  struct list_head* el;
+  JSValue ret = JS_NewArray(ctx);
+  uint32_t i = 0;
+  list_for_each(el, &ctx->loaded_modules) {
+    JSModuleDef* m = list_entry(el, JSModuleDef, link);
+    // const char* name = module_namecstr(ctx, m);
+    JSValue entry = JS_NewArray(ctx);
+    JS_SetPropertyUint32(ctx, entry, 0, JS_AtomToValue(ctx, m->module_name));
+    JS_SetPropertyUint32(ctx, entry, 1, magic ? module_entry(ctx, m) : module_value(ctx, m));
+
+    if(1 /*str[0] != '<'*/)
+      JS_SetPropertyUint32(ctx, ret, i++, entry);
+    else
+      JS_FreeValue(ctx, entry);
+
+    // JS_FreeCString(ctx, name);
+  }
+
+  return ret;
+}
+
+JSValue
+js_modules_object(JSContext* ctx, JSValueConst this_val, int magic) {
+  struct list_head* it;
+  JSValue obj = JS_NewObject(ctx);
+
+  list_for_each(it, &ctx->loaded_modules) {
+    JSModuleDef* m = list_entry(it, JSModuleDef, link);
+    const char* name = module_namecstr(ctx, m);
+    JSValue entry = magic ? module_entry(ctx, m) : module_value(ctx, m);
+
+    if(1 /*str[0] != '<'*/)
+      JS_SetPropertyStr(ctx, obj, basename(name), entry);
+    else
+      JS_FreeValue(ctx, entry);
+
+    JS_FreeCString(ctx, name);
+  }
+
+  return obj;
+}
+
+JSModuleDef*
+js_module_find_fwd(JSContext* ctx, const char* name, JSModuleDef* start) {
+  struct list_head* el;
+
+  for(el = start ? &start->link : ctx->loaded_modules.next; el != &ctx->loaded_modules; el = el->next)
+  /*list_for_each(el, &ctx->loaded_modules)*/ {
+    JSModuleDef* m = list_entry(el, JSModuleDef, link);
+    const char* str = module_namecstr(ctx, m);
+    BOOL match = !strcmp(str, name);
+    JS_FreeCString(ctx, str);
+
+    if(match)
+      return m;
+  }
+
+  return 0;
+}
+
+int
+js_module_index(JSContext* ctx, JSModuleDef* m) {
+  struct list_head* el;
+  int i = 0;
+
+  list_for_each(el, &ctx->loaded_modules) {
+
+    if(m == list_entry(el, JSModuleDef, link))
+      return i;
+    ++i;
+  }
+
+  return -1;
+}
+
+JSModuleDef*
+js_module_find_rev(JSContext* ctx, const char* name, JSModuleDef* start) {
+  struct list_head* el;
+
+  for(el = start ? &start->link : ctx->loaded_modules.prev; el != &ctx->loaded_modules; el = el->prev) /*list_for_each_prev(el, &ctx->loaded_modules)*/ {
+    JSModuleDef* m = list_entry(el, JSModuleDef, link);
+    const char* str = module_namecstr(ctx, m);
+    BOOL match = !strcmp(str, name);
+    JS_FreeCString(ctx, str);
+
+    if(match)
+      return m;
+  }
+
+  return 0;
+}
+
+int
+js_module_indexof(JSContext* ctx, JSModuleDef* def) {
+  int i = 0;
+  struct list_head* el;
+
+  list_for_each(el, &ctx->loaded_modules) {
+    JSModuleDef* m = list_entry(el, JSModuleDef, link);
+
+    if(m == def)
+      return i;
+
+    ++i;
+  }
+
+  return -1;
+}
+
+JSModuleDef*
+js_module_at(JSContext* ctx, int index) {
+  int i = 0;
+  struct list_head* el;
+
+  if(index >= 0) {
+    list_for_each(el, &ctx->loaded_modules) {
+      JSModuleDef* m = list_entry(el, JSModuleDef, link);
+
+      if(index == i)
+        return m;
+
+      ++i;
+    }
+  } else {
+    index = -(index + 1);
+
+    list_for_each_prev(el, &ctx->loaded_modules) {
+      JSModuleDef* m = list_entry(el, JSModuleDef, link);
+
+      if(index == i)
+        return m;
+
+      ++i;
+    }
+  }
+
+  return 0;
+}
+
+void
+module_make_object(JSContext* ctx, JSModuleDef* m, JSValueConst obj) {
+  JSValue tmp;
+  char buf[FMT_XLONG + 2];
+  strcpy(buf, "0x");
+
+  if(!js_has_propertystr(ctx, obj, "name"))
+    JS_SetPropertyStr(ctx, obj, "name", module_name(ctx, m));
+
+  JS_DefinePropertyValueStr(ctx, obj, "resolved", JS_NewBool(ctx, m->resolved), 0);
+  JS_DefinePropertyValueStr(ctx, obj, "funcCreated", JS_NewBool(ctx, m->func_created), 0);
+  JS_DefinePropertyValueStr(ctx, obj, "instantiated", JS_NewBool(ctx, m->instantiated), 0);
+  JS_DefinePropertyValueStr(ctx, obj, "evaluated", JS_NewBool(ctx, m->evaluated), 0);
+
+  if(!JS_IsUndefined((tmp = module_ns(ctx, m))))
+    JS_DefinePropertyValueStr(ctx, obj, "ns", tmp, 0);
+
+  if(!JS_IsUndefined((tmp = module_exports(ctx, m))))
+    JS_DefinePropertyValueStr(ctx, obj, "exports", tmp, 0);
+
+  if(!JS_IsUndefined((tmp = module_imports(ctx, m))))
+    JS_DefinePropertyValueStr(ctx, obj, "imports", tmp, 0);
+
+  if(!JS_IsUndefined((tmp = module_reqmodules(ctx, m))))
+    JS_SetPropertyStr(ctx, obj, "reqModules", tmp);
+
+  if(m->init_func) {
+    JS_SetPropertyStr(ctx, obj, "native", JS_NewBool(ctx, m->init_func != NULL));
+  }
+
+  if(!JS_IsUndefined((tmp = module_func(ctx, m)))) {
+    if(m->init_func)
+      JS_DefinePropertyValueStr(ctx, obj, "initFunc", tmp, 0);
+    else
+      JS_SetPropertyStr(ctx, obj, "func", tmp);
+  }
+
+  if(!js_is_null_or_undefined((tmp = JS_DupValue(ctx, m->meta_obj))))
+    JS_SetPropertyStr(ctx, obj, "metaObj", tmp);
+
+  if(!js_is_null_or_undefined((tmp = JS_DupValue(ctx, m->eval_exception))))
+    JS_SetPropertyStr(ctx, obj, "evalException", tmp);
+
+  {
+    JSAtom atom = js_symbol_static_atom(ctx, "toStringTag");
+    JS_DefinePropertyValue(ctx, obj, atom, JS_NewString(ctx, "Module"), 0);
+    JS_FreeAtom(ctx, atom);
+  }
+
+  {
+
+    buf[2 + fmt_xlonglong0(&buf[2], (long long)(uintptr_t)m, __SIZEOF_POINTER__ * 2)] = 0;
+
+    JS_DefinePropertyValueStr(ctx, obj, "address", JS_NewString(ctx, buf), 0);
+  }
+}
+
+JSValue
+module_object(JSContext* ctx, JSModuleDef* m) {
+  JSValue obj = JS_NewObject(ctx);
+  module_make_object(ctx, m, obj);
+  return obj;
+}
+
+int
+module_exports_get(JSContext* ctx, JSModuleDef* m, BOOL rename_default, JSValueConst exports) {
+  JSAtom def = JS_NewAtom(ctx, "default");
+  int i;
+
+  for(i = 0; i < m->export_entries_count; i++) {
+    JSExportEntry* entry = &m->export_entries[i];
+    JSVarRef* ref = entry->u.local.var_ref;
+    JSValue val = JS_UNDEFINED;
+    JSAtom name = entry->export_name;
+
+    if(ref) {
+      val = JS_DupValue(ctx, ref->pvalue ? *ref->pvalue : ref->value);
+
+      if(rename_default && name == def)
+        name = m->module_name;
+    }
+
+    JS_SetProperty(ctx, exports, name, val);
+  }
+
+  JS_FreeAtom(ctx, def);
+  return i;
+}
+
+JSValue
+module_imports(JSContext* ctx, JSModuleDef* m) {
+  JSValue obj = m->import_entries_count > 0 ? JS_NewArray(ctx) : JS_UNDEFINED;
+  int i;
+
+  for(i = 0; i < m->import_entries_count; i++) {
+    JSImportEntry* entry = &m->import_entries[i];
+    JSAtom name = entry->import_name;
+    /*JSReqModuleEntry* req_module = &m->req_module_entries[entry->req_module_idx];
+    JSAtom module_name = req_module->module_name;*/
+
+    JSValue import_value = JS_NewArray(ctx);
+
+    JS_SetPropertyUint32(ctx, import_value, 0, JS_AtomToValue(ctx, name));
+    JS_SetPropertyUint32(ctx, import_value, 1, JS_NewUint32(ctx, entry->req_module_idx));
+    JS_SetPropertyUint32(ctx, obj, i, import_value);
+  }
+
+  return obj;
+}
+
+JSValue
+module_reqmodules(JSContext* ctx, JSModuleDef* m) {
+  JSValue obj = m->req_module_entries_count > 0 ? JS_NewArray(ctx) : JS_UNDEFINED;
+  int i;
+
+  for(i = 0; i < m->req_module_entries_count; i++) {
+    JSReqModuleEntry* req_module = &m->req_module_entries[i];
+    JSAtom module_name = req_module->module_name;
+    JSModuleDef* module = req_module->module;
+
+    JSValue req_module_value = JS_NewArray(ctx);
+
+    JS_SetPropertyUint32(ctx, req_module_value, 0, JS_AtomToValue(ctx, module_name));
+    JS_SetPropertyUint32(ctx, req_module_value, 1, JS_NewInt32(ctx, js_module_index(ctx, module)));
+    JS_SetPropertyUint32(ctx, obj, i, req_module_value);
+  }
+
+  return obj;
+}
+
+JSValue
+module_default_export(JSContext* ctx, JSModuleDef* m) {
+  JSAtom def = JS_NewAtom(ctx, "default");
+  JSValue ret = JS_UNDEFINED;
+  int i;
+
+  for(i = 0; i < m->export_entries_count; i++) {
+    JSExportEntry* entry = &m->export_entries[i];
+    JSVarRef* ref = entry->u.local.var_ref;
+    JSAtom name = entry->export_name;
+
+    if(ref) {
+
+      if(name == def) {
+        ret = JS_DupValue(ctx, ref->pvalue ? *ref->pvalue : ref->value);
+        break;
+      }
+    }
+  }
+
+  JS_FreeAtom(ctx, def);
+  return ret;
+}
+
+JSValue
+module_ns(JSContext* ctx, JSModuleDef* m) {
+  return JS_DupValue(ctx, m->module_ns);
+}
+
+JSValue
+module_exception(JSContext* ctx, JSModuleDef* m) {
+  return m->eval_has_exception ? JS_DupValue(ctx, m->eval_exception) : JS_NULL;
+}
+
+JSValue
+module_meta_obj(JSContext* ctx, JSModuleDef* m) {
+  return JS_DupValue(ctx, m->meta_obj);
+}
+
+static JSValue
+call_module_func(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst* argv, int magic, JSValue* data) {
+  union {
+    JSModuleInitFunc* init_func;
+    int32_t i[2];
+  } u;
+
+  u.i[0] = JS_VALUE_GET_INT(data[0]);
+  u.i[1] = JS_VALUE_GET_INT(data[1]);
+
+  if(argc >= 1) {
+    JSModuleDef* m;
+
+    if((m = js_module_def(ctx, argv[0])))
+      return JS_NewInt32(ctx, u.init_func(ctx, m));
+  }
+
+  return JS_ThrowTypeError(ctx, "argument 1 module expected");
+}
+
+JSValue
+module_func(JSContext* ctx, JSModuleDef* m) {
+  JSValue func = JS_UNDEFINED;
+
+  if(JS_IsFunction(ctx, m->func_obj)) {
+    func = JS_DupValue(ctx, m->func_obj);
+  } else if(m->init_func) {
+    union {
+      JSModuleInitFunc* init_func;
+      int32_t i[2];
+    } u = {m->init_func};
+
+    JSValueConst data[2] = {
+        JS_MKVAL(JS_TAG_INT, u.i[0]),
+        JS_MKVAL(JS_TAG_INT, u.i[1]),
+    };
+
+    func = JS_NewCFunctionData(ctx, call_module_func, 1, 0, 2, data);
+  }
+
+  return func;
+}
+
+JSValue
+module_name(JSContext* ctx, JSModuleDef* m) {
+
+  if(m->module_name < (size_t)JS_GetRuntime(ctx)->atom_count)
+    return JS_AtomToValue(ctx, m->module_name);
+
+  return JS_UNDEFINED;
+}
+
+const char*
+module_namecstr(JSContext* ctx, JSModuleDef* m) {
+  return JS_AtomToCString(ctx, m->module_name);
+}
+
+JSValue
+module_exports_find(JSContext* ctx, JSModuleDef* m, JSAtom atom) {
+  int i;
+
+  for(i = 0; i < m->export_entries_count; i++) {
+    JSExportEntry* entry = &m->export_entries[i];
+
+    if(entry->export_name == atom) {
+      JSVarRef* ref = entry->u.local.var_ref;
+      JSValue export = ref ? JS_DupValue(ctx, ref->pvalue ? *ref->pvalue : ref->value) : JS_UNDEFINED;
+      return export;
+    }
+  }
+
+  return JS_UNDEFINED;
+}
+
+JSModuleDef*
+module_next(JSContext* ctx, JSModuleDef* m) {
+  return m->link.next != js_modules_list(ctx) ? list_entry(m->link.next, JSModuleDef, link) : 0;
+}
+
+JSModuleDef*
+module_prev(JSContext* ctx, JSModuleDef* m) {
+  return m->link.prev != js_modules_list(ctx) ? list_entry(m->link.prev, JSModuleDef, link) : 0;
+}
+
+JSModuleDef*
+module_last(JSContext* ctx) {
+  struct list_head* list = js_modules_list(ctx);
+
+  return list_empty(list) ? 0 : list_entry(list->prev, JSModuleDef, link);
+}
+
+void
+module_rename(JSContext* ctx, JSModuleDef* m, JSAtom name) {
+  JS_FreeAtom(ctx, m->module_name);
+  m->module_name = name;
+}
+
+static void
+js_arraybuffer_freestring(JSRuntime* rt, void* opaque, void* ptr) {
+  JSString* jstr = opaque;
+  JS_FreeValueRT(rt, JS_MKPTR(JS_TAG_STRING, jstr));
+}
+
+JSValue
+js_arraybuffer_fromstring(JSContext* ctx, JSValueConst str) {
+  JSString* jstr;
+
+  if(!JS_IsString(str))
+    return JS_ThrowTypeError(ctx, "Not a string");
+
+  JS_DupValue(ctx, str);
+  jstr = JS_VALUE_GET_PTR(str);
+
+  return JS_NewArrayBuffer(ctx, jstr->u.str8, jstr->len, js_arraybuffer_freestring, jstr, FALSE);
+}
+
+void*
+js_sab_alloc(void* opaque, size_t size) {
+  JSSABHeader* sab;
+
+  if(!(sab = malloc(sizeof(JSSABHeader) + size)))
+    return 0;
+
+  sab->ref_count = 1;
+  return sab->buf;
+}
+
+void
+js_sab_free(void* opaque, void* ptr) {
+  JSSABHeader* sab;
+  int ref_count;
+  sab = (JSSABHeader*)((uint8_t*)ptr - sizeof(JSSABHeader));
+  ref_count = atomic_add_int(&sab->ref_count, -1);
+  assert(ref_count >= 0);
+
+  if(ref_count == 0)
+    free(sab);
+}
+
+void
+js_sab_dup(void* opaque, void* ptr) {
+  JSSABHeader* sab;
+  sab = (JSSABHeader*)((uint8_t*)ptr - sizeof(JSSABHeader));
+  atomic_add_int(&sab->ref_count, 1);
+}
+
+JSValueConst
+js_cstring_value(const char* ptr) {
+  return JS_MKPTR(JS_TAG_STRING, (JSString*)(void*)(ptr - offsetof(JSString, u)));
+}
+
+char*
+js_cstring_dup(JSContext* ctx, const char* str) {
+  /* purposely removing constness */
+  JSString* p = (JSString*)(void*)(str - offsetof(JSString, u));
+  JS_DupValue(ctx, JS_MKPTR(JS_TAG_STRING, p));
+  return (char*)str;
+}
+
+size_t
+js_cstring_len(JSValueConst v) {
+  JSString* p;
+
+  if(JS_IsString(v)) {
+    p = JS_VALUE_GET_PTR(v);
+    return p->len;
+  }
+
+  return 0;
+}
+
+char*
+js_cstring_ptr(JSValueConst v) {
+  JSString* p;
+
+  if(JS_IsString(v)) {
+    p = JS_VALUE_GET_PTR(v);
+    return (char*)p->u.str8;
+  }
+
+  return 0;
+}
+
+const char*
+js_class_name(JSContext* ctx, JSClassID id) {
+  JSAtom atom = JS_GetRuntime(ctx)->class_array[id].class_name;
+  return JS_AtomToCString(ctx, atom);
+}
+
+JSAtom
+js_class_atom(JSContext* ctx, JSClassID id) {
+  JSAtom atom = 0;
+
+  if(id > 0 && id < (JSClassID)JS_GetRuntime(ctx)->class_count)
+    atom = JS_GetRuntime(ctx)->class_array[id].class_name;
+  return atom;
+}
+
+JSClassID
+js_class_find(JSContext* ctx, const char* name) {
+  JSAtom atom = JS_NewAtom(ctx, name);
+  JSRuntime* rt = JS_GetRuntime(ctx);
+  int i, n = rt->class_count;
+
+  for(i = 0; i < n; i++)
+
+    if(rt->class_array[i].class_name == atom)
+      return i;
+
+  return -1;
+}
+
+JSClassID
+js_class_id(JSContext* ctx, int id) {
+  return JS_GetRuntime(ctx)->class_array[id].class_id;
+}
+
+JSValue
+js_opcode_array(JSContext* ctx, const JSOpCode* opcode) {
+  JSValue ret = JS_NewArray(ctx);
+  JS_SetPropertyUint32(ctx, ret, 0, JS_NewUint32(ctx, opcode->size));
+  JS_SetPropertyUint32(ctx, ret, 1, JS_NewUint32(ctx, opcode->n_pop));
+  JS_SetPropertyUint32(ctx, ret, 2, JS_NewUint32(ctx, opcode->n_push));
+  JS_SetPropertyUint32(ctx, ret, 3, JS_NewUint32(ctx, opcode->fmt));
+  JS_SetPropertyUint32(ctx, ret, 4, JS_NewString(ctx, opcode->name));
+  return ret;
+}
+
+JSValue
+js_opcode_object(JSContext* ctx, const struct JSOpCode* opcode) {
+  JSValue ret = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, ret, "size", JS_NewUint32(ctx, opcode->size));
+  JS_SetPropertyStr(ctx, ret, "n_pop", JS_NewUint32(ctx, opcode->n_pop));
+  JS_SetPropertyStr(ctx, ret, "n_push", JS_NewUint32(ctx, opcode->n_push));
+  JS_SetPropertyStr(ctx, ret, "fmt", JS_NewUint32(ctx, opcode->fmt));
+  JS_SetPropertyStr(ctx, ret, "name", JS_NewString(ctx, opcode->name));
+  return ret;
+}
+
+JSValue
+js_get_bytecode(JSContext* ctx, JSValueConst value) {
+  JSValue ret = JS_UNDEFINED;
+
+  if(JS_IsFunction(ctx, value)) {
+    JSObject* obj = JS_VALUE_GET_OBJ(value);
+    JSFunctionBytecode* fnbc;
+
+    if((fnbc = obj->u.func.function_bytecode)) {
+      ret = JS_NewArrayBufferCopy(ctx, fnbc->byte_code_buf, fnbc->byte_code_len);
+    }
+  }
+
+  return ret;
+}
+
+JSValue
+js_opcode_list(JSContext* ctx, BOOL as_object) {
+  JSValue ret = JS_NewArray(ctx);
+  size_t i, j, len = countof(js_opcodes);
+
+  for(i = 0, j = 0; i < len; i++) {
+
+    if(i >= OP_TEMP_START && i < OP_TEMP_END)
+      continue;
+
+    JS_SetPropertyUint32(ctx, ret, j++, (as_object ? js_opcode_object : js_opcode_array)(ctx, &js_opcodes[i]));
+  }
+
+  return ret;
+}
+
+#ifdef HAVE_JS_DEBUGGER_BUILD_BACKTRACE
+JSValue js_debugger_build_backtrace(JSContext* ctx, const uint8_t* cur_pc);
+
+JSValue
+js_stack_get(JSContext* ctx) {
+  return js_debugger_build_backtrace(ctx, ctx->rt->current_stack_frame->cur_pc);
+}
+#endif
+
+#define SHORT_OPCODES 1
+
+const JSOpCode js_opcodes[OP_COUNT + (OP_TEMP_END - OP_TEMP_START)] = {
+#define FMT(f)
+#define DEF(id, size, n_pop, n_push, f) {size, n_pop, n_push, OP_FMT_##f, #id},
+#include <quickjs-opcode.h>
+#undef DEF
+#undef FMT
+};

src/quickjs/quickjs-textcode.c

@@ -0,0 +1,695 @@
+#include "defines.h"
+#include "quickjs-textcode.h"
+#include "utils.h"
+#include "buffer-utils.h"
+#include "debug.h"
+#include <libutf.h>
+#include <libutf.h>
+#include "tutf8e.h"
+
+/**
+ * \addtogroup quickjs-textdecoder
+ * @{
+ */
+
+VISIBLE JSClassID js_decoder_class_id = 0, js_encoder_class_id = 0;
+VISIBLE JSValue textdecoder_proto = {{0}, JS_TAG_UNDEFINED}, textdecoder_ctor = {{0}, JS_TAG_UNDEFINED}, textencoder_proto = {{0}, JS_TAG_UNDEFINED},
+                textencoder_ctor = {{0}, JS_TAG_UNDEFINED};
+
+const TUTF8encoder* tutf8e_coders[] = {
+    /* 0, 0, 0, 0, 0, 0, 0, 0, */
+    &tutf8e_encoder_iso_8859_1,   &tutf8e_encoder_iso_8859_2,   &tutf8e_encoder_iso_8859_3,   &tutf8e_encoder_iso_8859_4,   &tutf8e_encoder_iso_8859_5,
+    &tutf8e_encoder_iso_8859_6,   &tutf8e_encoder_iso_8859_7,   &tutf8e_encoder_iso_8859_8,   &tutf8e_encoder_iso_8859_9,   &tutf8e_encoder_iso_8859_10,
+    &tutf8e_encoder_iso_8859_11,  &tutf8e_encoder_iso_8859_13,  &tutf8e_encoder_iso_8859_14,  &tutf8e_encoder_iso_8859_15,  &tutf8e_encoder_iso_8859_16,
+    &tutf8e_encoder_windows_1250, &tutf8e_encoder_windows_1251, &tutf8e_encoder_windows_1252, &tutf8e_encoder_windows_1253, &tutf8e_encoder_windows_1254,
+    &tutf8e_encoder_windows_1255, &tutf8e_encoder_windows_1256, &tutf8e_encoder_windows_1257, &tutf8e_encoder_windows_1258,
+};
+
+const char* const textcode_encodings[] = {
+    "unknown",      "UTF-8",        "UTF-16",       "UTF-32",       "unknown",      "UTF-8",        "UTF-16BE",     "UTF-32BE",
+    "ISO-8859-1",   "ISO-8859-2",   "ISO-8859-3",   "ISO-8859-4",   "ISO-8859-5",   "ISO-8859-6",   "ISO-8859-7",   "ISO-8859-8",
+    "ISO-8859-9",   "ISO-8859-10",  "ISO-8859-11",  "ISO-8859-13",  "ISO-8859-14",  "ISO-8859-15",  "ISO-8859-16",  "WINDOWS-1250",
+    "WINDOWS-1251", "WINDOWS-1252", "WINDOWS-1253", "WINDOWS-1254", "WINDOWS-1255", "WINDOWS-1256", "WINDOWS-1257", "WINDOWS-1258",
+};
+
+enum {
+  DECODER_DECODE,
+  DECODER_END,
+};
+enum {
+  DECODER_ENCODING,
+  DECODER_ENDIANNESS,
+  DECODER_BUFFERED,
+};
+
+static size_t
+textdecoder_try(const void* in, size_t len) {
+  const uint8_t *x, *y, *end;
+  size_t r = 0;
+  int ch;
+
+  x = in;
+  end = x + len;
+
+  while(x < end) {
+    y = x;
+
+    if((ch = unicode_from_utf8(x, end - x, &x)) == -1)
+      break;
+
+    r += x - y;
+  }
+
+  return r;
+}
+
+size_t
+textdecoder_length(TextDecoder* td) {
+  size_t len = 0, r;
+
+  r = textdecoder_try(ringbuffer_begin(&td->buffer), ringbuffer_continuous(&td->buffer));
+  len += r;
+
+  if(len == ringbuffer_continuous(&td->buffer))
+    if(td->buffer.head < td->buffer.tail) {
+      r = textdecoder_try(td->buffer.data, ringbuffer_head(&td->buffer));
+      len += r;
+    }
+
+  return len;
+}
+
+JSValue
+textdecoder_decode(TextDecoder* dec, JSContext* ctx) {
+  JSValue ret = JS_UNDEFINED;
+  DynBuf dbuf;
+  size_t i = 0, blen;
+  uint_least32_t cp;
+  char tmp[UTF8_CHAR_LEN_MAX];
+  int len = 0;
+  js_dbuf_init(ctx, &dbuf);
+  blen = ringbuffer_length(&dec->buffer);
+
+  if(blen)
+    switch(dec->encoding) {
+      case UTF8: {
+        size_t blen, rlen = ringbuffer_length(&dec->buffer);
+
+        if((blen = textdecoder_length(dec)) < rlen) {
+          ringbuffer_normalize(&dec->buffer);
+          blen = textdecoder_length(dec);
+        }
+
+        ret = JS_NewStringLen(ctx, (const char*)ringbuffer_begin(&dec->buffer), blen);
+        ringbuffer_skip(&dec->buffer, blen);
+        break;
+      }
+      case UTF16: {
+        uint_least16_t* ptr = ringbuffer_begin(&dec->buffer);
+        size_t n = blen & ~(0x1);
+
+        for(i = 0; i < n; ptr = ringbuffer_next(&dec->buffer, ptr), i += 2) {
+          uint_least16_t u16[2] = {uint16_get_endian(ptr, dec->endian), 0};
+          size_t ns = 2;
+
+          if(utf16_multiword(u16)) {
+            if(i + 2 >= n)
+              break;
+            u16[1] = uint16_get_endian(ptr + 1, dec->endian == BIG);
+            ns += 2;
+          }
+
+          if(!libutf_c16_to_c32(u16, &cp)) {
+            ret = JS_ThrowInternalError(ctx,
+                                        "%s: TextDecoder: not a valid utf-16 code at (%llu: 0x%04x, 0x%04x): %lu",
+                                        __func__,
+                                        (long long unsigned int)i,
+                                        (unsigned int)ptr[0],
+                                        (unsigned int)ptr[1],
+                                        (unsigned long)cp);
+            break;
+          }
+          len = unicode_to_utf8((void*)tmp, cp);
+
+          if(dbuf_put(&dbuf, (const void*)tmp, len))
+            return JS_EXCEPTION;
+        }
+
+        break;
+      }
+      case UTF32: {
+        const uint_least32_t* ptr = ringbuffer_begin(&dec->buffer);
+        size_t n = blen & ~(0x3);
+
+        for(i = 0; i < n; ptr = ringbuffer_next(&dec->buffer, ptr), i += 4) {
+          cp = uint32_get_endian(ptr, dec->endian);
+          if(!libutf_c32_to_c8(cp, &len, tmp)) {
+            ret = JS_ThrowInternalError(ctx,
+                                        "%s: TextDecoder: not a valid utf-32 code at (%llu: 0x%04x, 0x%04x): %lu",
+                                        __func__,
+                                        (long long unsigned int)i,
+                                        (unsigned int)ptr[0],
+                                        (unsigned int)ptr[1],
+                                        (unsigned long)cp);
+            break;
+          }
+          if(dbuf_put(&dbuf, (const void*)tmp, len))
+            return JS_EXCEPTION;
+        }
+        break;
+      }
+      default: {
+        TUTF8encoder encoder;
+
+        if((encoder = *tutf8e_coders[dec->encoding - 8])) {
+
+          const char* ptr = ringbuffer_begin(&dec->buffer);
+          size_t n = 0;
+
+          if(TUTF8E_OK == tutf8e_encoder_buffer_length(encoder, ptr, 0, blen, &n)) {
+
+            uint8_t* dst = dbuf_reserve(&dbuf, n);
+
+            if(TUTF8E_OK == tutf8e_encoder_buffer_encode(encoder, ptr, blen, 0, (char*)dst, &n)) {
+              dbuf.size += n;
+              i = blen;
+            }
+          }
+
+        } else {
+          ret = JS_ThrowInternalError(ctx, "%s: TextDecoder: unknown encoding: %s", __func__, textcode_encodings[dec->encoding]);
+        }
+        break;
+      }
+    }
+
+  ringbuffer_skip(&dec->buffer, i);
+
+  if(JS_IsUndefined(ret) && dbuf.size > 0)
+    ret = JS_NewStringLen(ctx, (const char*)dbuf.buf, dbuf.size);
+
+  dbuf_free(&dbuf);
+
+  return ret;
+}
+
+static JSValue
+js_decoder_get(JSContext* ctx, JSValueConst this_val, int magic) {
+  TextDecoder* dec;
+  JSValue ret = JS_UNDEFINED;
+  if(!(dec = js_decoder_data(ctx, this_val)))
+    return ret;
+  switch(magic) {
+    case DECODER_ENCODING: {
+      ret = JS_NewString(ctx, textcode_encodings[dec->type_code]);
+      break;
+    }
+
+    case DECODER_ENDIANNESS: {
+      ret = JS_NewBool(ctx, dec->endian == BIG);
+      break;
+    }
+
+    case DECODER_BUFFERED: {
+      ret = JS_NewUint32(ctx, ringbuffer_length(&dec->buffer));
+      break;
+    }
+  }
+  return ret;
+}
+
+static JSValue
+js_decoder_constructor(JSContext* ctx, JSValueConst new_target, int argc, JSValueConst argv[]) {
+  JSValue obj = JS_UNDEFINED;
+  JSValue proto;
+  TextDecoder* dec;
+
+  if(!(dec = js_mallocz(ctx, sizeof(TextDecoder))))
+    return JS_EXCEPTION;
+
+  /* using new_target to get the prototype is necessary when the class is extended. */
+  proto = JS_GetPropertyStr(ctx, new_target, "prototype");
+  if(JS_IsException(proto))
+    goto fail;
+  if(!JS_IsObject(proto))
+    proto = textdecoder_proto;
+
+  /* using new_target to get the prototype is necessary when the class is extended. */
+  obj = JS_NewObjectProtoClass(ctx, proto, js_decoder_class_id);
+  JS_FreeValue(ctx, proto);
+  if(JS_IsException(obj))
+    goto fail;
+
+  ringbuffer_init(&dec->buffer, ctx);
+
+  if(argc >= 1) {
+    const char* s = JS_ToCString(ctx, argv[0]);
+
+    if(s[case_finds(s, "utf32")] || s[case_finds(s, "utf-32")])
+      dec->encoding = UTF32;
+    else if(s[case_finds(s, "utf16")] || s[case_finds(s, "utf-16")])
+      dec->encoding = UTF16;
+    else if(s[case_finds(s, "utf8")] || s[case_finds(s, "utf-8")])
+      dec->encoding = UTF8;
+    else {
+      return JS_ThrowInternalError(ctx, "%s: TextDecoder: '%s' is invalid s", __func__, s);
+    }
+
+    if(s[case_finds(s, "be")] || s[case_finds(s, "be")])
+      dec->endian = BIG;
+
+    JS_FreeCString(ctx, s);
+  } else {
+    dec->encoding = UTF8;
+  }
+  JS_SetOpaque(obj, dec);
+
+  return obj;
+
+fail:
+  js_free(ctx, dec);
+  JS_FreeValue(ctx, obj);
+  return JS_EXCEPTION;
+}
+
+static JSValue
+js_decoder_decode(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst argv[], int magic) {
+  TextDecoder* dec;
+  JSValue ret = JS_UNDEFINED;
+
+  if(!(dec = js_decoder_data(ctx, this_val)))
+    return JS_EXCEPTION;
+
+  switch(magic) {
+    case DECODER_END:
+    case DECODER_DECODE: {
+      InputBuffer in = js_input_chars(ctx, argv[0]);
+
+      // printf("js_decoder_decode (1) %s length=%zu in.size=%zu\n", magic == DECODER_DECODE ? "decode" :
+      // "end", ringbuffer_length(&dec->buffer), in.size);
+      if(ringbuffer_write(&dec->buffer, in.data, in.size) < 0)
+        return JS_ThrowInternalError(ctx, "%s: TextDecoder: ringbuffer %s failed", __func__, magic == DECODER_DECODE ? "decode" : "end");
+
+      if(ringbuffer_length(&dec->buffer) == 0)
+        ret = JS_NULL;
+      else
+        ret = textdecoder_decode(dec, ctx);
+
+      if(magic == DECODER_END)
+        ringbuffer_reset(&dec->buffer);
+      break;
+    }
+  }
+  return ret;
+}
+
+static JSValue
+js_decoder_inspect(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst argv[]) {
+  TextDecoder* dec;
+
+  if(!(dec = js_decoder_data(ctx, this_val)))
+    return JS_EXCEPTION;
+
+  JSValue obj = JS_NewObjectClass(ctx, js_decoder_class_id);
+
+  JS_DefinePropertyValueStr(ctx, obj, "encoding", JS_NewString(ctx, textcode_encodings[dec->type_code]), JS_PROP_ENUMERABLE);
+  JS_DefinePropertyValueStr(ctx, obj, "buffered", JS_NewUint32(ctx, ringbuffer_length(&dec->buffer)), JS_PROP_ENUMERABLE);
+  return obj;
+}
+
+static void
+js_decoder_finalizer(JSRuntime* rt, JSValue val) {
+  TextDecoder* dec = JS_GetOpaque(val, js_decoder_class_id);
+  if(dec) {
+    ringbuffer_free(&dec->buffer);
+    js_free_rt(rt, dec);
+  }
+  // JS_FreeValueRT(rt, val);
+}
+
+static JSClassDef js_decoder_class = {
+    .class_name = "TextDecoder",
+    .finalizer = js_decoder_finalizer,
+};
+
+static const JSCFunctionListEntry js_decoder_funcs[] = {
+    JS_CFUNC_MAGIC_DEF("decode", 1, js_decoder_decode, DECODER_DECODE),
+    JS_CFUNC_MAGIC_DEF("end", 1, js_decoder_decode, DECODER_END),
+    JS_CGETSET_ENUMERABLE_DEF("encoding", js_decoder_get, 0, DECODER_ENCODING),
+    JS_CGETSET_MAGIC_DEF("endian", js_decoder_get, 0, DECODER_ENDIANNESS),
+    JS_CGETSET_MAGIC_DEF("buffered", js_decoder_get, 0, DECODER_BUFFERED),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "TextDecoder", JS_PROP_CONFIGURABLE),
+};
+
+enum {
+  ENCODER_ENCODE,
+  ENCODER_END,
+};
+enum {
+  ENCODER_ENCODING,
+  ENCODER_ENDIANNESS,
+  ENCODER_BUFFERED,
+};
+
+/*static size_t
+textencoder_try(const void* in, size_t len) {
+  const uint8_t *x, *y, *end;
+  size_t r = 0;
+  int ch;
+  for(x = in, end=x+len; x < end; ) {
+    y = x;
+    if((ch = unicode_from_utf8(x, end - x, &x)) == -1)
+      break;
+    r += x - y;
+  }
+  return r;
+}
+
+size_t
+textencoder_length(TextEncoder* td) {
+  size_t r = 0;
+
+  r += textencoder_try(ringbuffer_begin(&td->buffer), ringbuffer_continuous(&td->buffer));
+
+  if(td->buffer.head < td->buffer.tail)
+    r += textencoder_try(td->buffer.data, ringbuffer_head(&td->buffer));
+
+  return r;
+}*/
+
+JSValue
+textencoder_read(TextEncoder* te, JSContext* ctx) {
+  JSValue ret, buf;
+  int bits;
+  size_t len = ringbuffer_length(&te->buffer);
+
+  if(len > ringbuffer_continuous(&te->buffer))
+    ringbuffer_normalize(&te->buffer);
+
+  switch(te->encoding) {
+    case UTF8: bits = 8; break;
+    case UTF16: bits = 16; break;
+    case UTF32: bits = 32; break;
+    default: return JS_ThrowInternalError(ctx, "%s: TextEncoder: invalid encoding: %d", __func__, te->encoding);
+  }
+
+  buf = JS_NewArrayBufferCopy(ctx, ringbuffer_begin(&te->buffer), len);
+  ret = js_typedarray_new(ctx, bits, FALSE, FALSE, buf);
+  JS_FreeValue(ctx, buf);
+
+  te->buffer.tail += len;
+  return ret;
+}
+
+JSValue
+textencoder_encode(TextEncoder* enc, InputBuffer in, JSContext* ctx) {
+  JSValue ret = JS_UNDEFINED;
+  size_t i;
+  uint32_t cp;
+  uint8_t u8[UTF8_CHAR_LEN_MAX];
+  const uint8_t *ptr, *end, *next;
+
+  switch(enc->encoding) {
+    case UTF8: {
+      if(ringbuffer_write(&enc->buffer, in.data, in.size) < 0)
+        return JS_ThrowInternalError(ctx, "%s: TextEncoder: ringbuffer write failed", __func__);
+      break;
+    }
+
+    case UTF16: {
+      ptr = block_begin(&in.block);
+      end = block_end(&in.block);
+
+      for(i = 0; ptr < end; ptr = next, i++) {
+        cp = unicode_from_utf8(ptr, end - ptr, &next);
+
+        {
+          uint_least16_t u16[2];
+          int len;
+
+          if(!libutf_c32_to_c16(cp, &len, u16))
+            return JS_ThrowInternalError(ctx,
+                                         "%s: TextEncoder: not a valid code point at (%llu) [%llu]: %lu",
+                                         __func__,
+                                         (long long unsigned int)i,
+                                         (long long unsigned int)(end - ptr),
+                                         (unsigned long)cp);
+
+          for(int j = 0; j < len; j++)
+            uint16_put_endian(u8 + j * 2, u16[j], enc->endian);
+
+          if(ringbuffer_append(&enc->buffer, u8, len * sizeof(uint16_t), ctx) < 0)
+            return JS_ThrowInternalError(ctx, "TextEncoder: ringbuffer write failed");
+        }
+      }
+
+      break;
+    }
+
+    case UTF32: {
+      ptr = block_begin(&in.block);
+      end = block_end(&in.block);
+
+      for(i = 0; ptr < end; ptr = next, i++) {
+        cp = unicode_from_utf8(ptr, end - ptr, &next);
+        if(cp == 0xffffffff)
+          return JS_ThrowInternalError(
+              ctx, "%s: TextEncoder: not a valid code point at (%llu): %lu", __func__, (long long unsigned int)(ptr - in.block.base), (long unsigned int)cp);
+        /*cp = 0;
+        if(!libutf_c8_to_c32(ptr, &cp))
+          return JS_ThrowInternalError(ctx, "No a valid code point at (%zu) [%zu]: %" PRIu32, i, end - ptr,
+        cp); next = ptr + libutf_c8_type(ptr); if(next == ptr) break;*/
+
+        uint32_put_endian(u8, cp, enc->endian);
+
+        if(ringbuffer_append(&enc->buffer, u8, sizeof(cp), ctx) < 0)
+          return JS_ThrowInternalError(ctx, "%s: TextEncoder: ringbuffer write failed", __func__);
+      }
+      break;
+    }
+    default: {
+      ret = JS_ThrowInternalError(ctx, "%s: TextEncoder: unknown encoding", __func__);
+      break;
+    }
+  }
+
+  return ret;
+}
+
+static JSValue
+js_encoder_get(JSContext* ctx, JSValueConst this_val, int magic) {
+  TextEncoder* enc;
+  JSValue ret = JS_UNDEFINED;
+  if(!(enc = js_encoder_data(ctx, this_val)))
+    return ret;
+  switch(magic) {
+    case ENCODER_ENCODING: {
+      ret = JS_NewString(ctx, textcode_encodings[enc->type_code]);
+      break;
+    }
+
+    case ENCODER_ENDIANNESS: {
+      ret = JS_NewBool(ctx, enc->endian == BIG);
+      break;
+    }
+
+    case ENCODER_BUFFERED: {
+      ret = JS_NewUint32(ctx, ringbuffer_length(&enc->buffer));
+      break;
+    }
+  }
+  return ret;
+}
+
+static JSValue
+js_encoder_constructor(JSContext* ctx, JSValueConst new_target, int argc, JSValueConst argv[]) {
+  JSValue obj = JS_UNDEFINED;
+  JSValue proto;
+  TextEncoder* enc;
+
+  if(!(enc = js_mallocz(ctx, sizeof(TextEncoder))))
+    return JS_EXCEPTION;
+
+  /* using new_target to get the prototype is necessary when the class is extended. */
+  proto = JS_GetPropertyStr(ctx, new_target, "prototype");
+  if(JS_IsException(proto))
+    goto fail;
+  if(!JS_IsObject(proto))
+    proto = textencoder_proto;
+
+  /* using new_target to get the prototype is necessary when the class is extended. */
+  obj = JS_NewObjectProtoClass(ctx, proto, js_encoder_class_id);
+  JS_FreeValue(ctx, proto);
+  if(JS_IsException(obj))
+    goto fail;
+
+  ringbuffer_init(&enc->buffer, ctx);
+
+  if(argc >= 1) {
+    const char* s = JS_ToCString(ctx, argv[0]);
+
+    if(s[case_finds(s, "utf32")] || s[case_finds(s, "utf-32")])
+      enc->encoding = UTF32;
+    else if(s[case_finds(s, "utf16")] || s[case_finds(s, "utf-16")])
+      enc->encoding = UTF16;
+    else if(s[case_finds(s, "utf8")] || s[case_finds(s, "utf-8")])
+      enc->encoding = UTF8;
+    else {
+      return JS_ThrowInternalError(ctx, "TextEncoder '%s' is invalid s", s);
+    }
+
+    if(enc->encoding > UTF8)
+      if(s[case_finds(s, "be")] || s[case_finds(s, "be")])
+        enc->endian = BIG;
+
+    JS_FreeCString(ctx, s);
+  } else {
+    enc->encoding = UTF8;
+  }
+  JS_SetOpaque(obj, enc);
+
+  return obj;
+
+fail:
+  js_free(ctx, enc);
+  JS_FreeValue(ctx, obj);
+  return JS_EXCEPTION;
+}
+
+static JSValue
+js_encoder_encode(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst argv[], int magic) {
+  TextEncoder* enc;
+  JSValue ret = JS_UNDEFINED;
+
+  if(!(enc = js_encoder_data(ctx, this_val)))
+    return JS_EXCEPTION;
+
+  switch(magic) {
+    case ENCODER_END:
+    case ENCODER_ENCODE: {
+      InputBuffer in = js_input_chars(ctx, argv[0]);
+
+      ret = textencoder_encode(enc, in, ctx);
+
+      if(JS_IsException(ret))
+        break;
+
+      if(ringbuffer_length(&enc->buffer) == 0)
+        ret = JS_NULL;
+      else
+        ret = textencoder_read(enc, ctx);
+
+      if(magic == ENCODER_END)
+        ringbuffer_reset(&enc->buffer);
+      break;
+    }
+  }
+  return ret;
+}
+
+static JSValue
+js_encoder_inspect(JSContext* ctx, JSValueConst this_val, int argc, JSValueConst argv[]) {
+  TextEncoder* enc;
+
+  if(!(enc = js_encoder_data(ctx, this_val)))
+    return JS_EXCEPTION;
+
+  JSValue obj = JS_NewObjectClass(ctx, js_encoder_class_id);
+
+  JS_DefinePropertyValueStr(ctx, obj, "encoding", JS_NewString(ctx, textcode_encodings[enc->type_code]), JS_PROP_ENUMERABLE);
+  JS_DefinePropertyValueStr(ctx, obj, "buffered", JS_NewUint32(ctx, ringbuffer_length(&enc->buffer)), JS_PROP_ENUMERABLE);
+  return obj;
+}
+
+static void
+js_encoder_finalizer(JSRuntime* rt, JSValue val) {
+  TextEncoder* enc = JS_GetOpaque(val, js_encoder_class_id);
+  if(enc) {
+    ringbuffer_free(&enc->buffer);
+    js_free_rt(rt, enc);
+  }
+  // JS_FreeValueRT(rt, val);
+}
+
+static JSClassDef js_encoder_class = {
+    .class_name = "TextEncoder",
+    .finalizer = js_encoder_finalizer,
+};
+
+static const JSCFunctionListEntry js_encoder_funcs[] = {
+    JS_CFUNC_MAGIC_DEF("encode", 1, js_encoder_encode, ENCODER_ENCODE),
+    JS_CFUNC_MAGIC_DEF("end", 1, js_encoder_encode, ENCODER_END),
+    JS_CGETSET_ENUMERABLE_DEF("encoding", js_encoder_get, 0, ENCODER_ENCODING),
+    JS_CGETSET_MAGIC_DEF("endian", js_encoder_get, 0, ENCODER_ENDIANNESS),
+    JS_CGETSET_MAGIC_DEF("buffered", js_encoder_get, 0, ENCODER_BUFFERED),
+    JS_PROP_STRING_DEF("[Symbol.toStringTag]", "TextEncoder", JS_PROP_CONFIGURABLE),
+};
+
+int
+js_code_init(JSContext* ctx, JSModuleDef* m) {
+
+  if(js_decoder_class_id == 0) {
+    JS_NewClassID(&js_decoder_class_id);
+    JS_NewClass(JS_GetRuntime(ctx), js_decoder_class_id, &js_decoder_class);
+
+    textdecoder_ctor = JS_NewCFunction2(ctx, js_decoder_constructor, "TextDecoder", 1, JS_CFUNC_constructor, 0);
+    textdecoder_proto = JS_NewObject(ctx);
+
+    JS_SetPropertyFunctionList(ctx, textdecoder_proto, js_decoder_funcs, countof(js_decoder_funcs));
+    JS_SetClassProto(ctx, js_decoder_class_id, textdecoder_proto);
+
+    JS_SetConstructor(ctx, textdecoder_ctor, textdecoder_proto);
+
+    JS_NewClassID(&js_encoder_class_id);
+    JS_NewClass(JS_GetRuntime(ctx), js_encoder_class_id, &js_encoder_class);
+
+    textencoder_ctor = JS_NewCFunction2(ctx, js_encoder_constructor, "TextEncoder", 1, JS_CFUNC_constructor, 0);
+    textencoder_proto = JS_NewObject(ctx);
+
+    JS_SetPropertyFunctionList(ctx, textencoder_proto, js_encoder_funcs, countof(js_encoder_funcs));
+    JS_SetClassProto(ctx, js_encoder_class_id, textencoder_proto);
+
+    JS_SetConstructor(ctx, textencoder_ctor, textencoder_proto);
+
+    // js_set_inspect_method(ctx, textdecoder_proto,
+    // js_decoder_inspect);
+  }
+
+  if(m) {
+    JS_SetModuleExport(ctx, m, "TextDecoder", textdecoder_ctor);
+    JS_SetModuleExport(ctx, m, "TextEncoder", textencoder_ctor);
+
+    /*  const char* module_name = JS_AtomToCString(ctx, m->module_name);
+
+      if(!strcmp(module_name, "textdecoder"))
+        JS_SetModuleExport(ctx, m, "default", textdecoder_ctor);
+
+      JS_FreeCString(ctx, module_name);*/
+  }
+
+  return 0;
+}
+
+#ifdef JS_TEXTCODE_MODULE
+#define JS_INIT_MODULE js_init_module
+#else
+#define JS_INIT_MODULE js_init_module_textdecoder
+#endif
+
+VISIBLE JSModuleDef*
+JS_INIT_MODULE(JSContext* ctx, const char* module_name) {
+  JSModuleDef* m;
+
+  if((m = JS_NewCModule(ctx, module_name, js_code_init))) {
+    JS_AddModuleExport(ctx, m, "TextDecoder");
+    JS_AddModuleExport(ctx, m, "TextEncoder");
+    /*if(!strcmp(module_name, "textdecoder"))
+      JS_AddModuleExport(ctx, m, "default");*/
+  }
+
+  return m;
+}
+
+/**
+ * @}
+ */

src/quickjs/quickjs-textcode.h

@@ -0,0 +1,86 @@
+#ifndef QUICKJS_TEXTCODE_H
+#define QUICKJS_TEXTCODE_H
+
+#include "utils.h"
+#include "ringbuffer.h"
+
+/**
+ * \defgroup quickjs-textdecoder quickjs-textdecoder: String Decoder
+ * @{
+ */
+
+typedef enum utf_encoding { UNKNOWN = 0, UTF8, UTF16, UTF32 } UTFCharset;
+typedef enum text_encoding {
+  UTF16LE = 2,
+  UTF32LE = 3,
+  UTF16BE = 6,
+  UTF32BE = 7,
+  ISO_8859_1,
+  ISO_8859_2,
+  ISO_8859_3,
+  ISO_8859_4,
+  ISO_8859_5,
+  ISO_8859_6,
+  ISO_8859_7,
+  ISO_8859_8,
+  ISO_8859_9,
+  ISO_8859_10,
+  ISO_8859_11,
+  ISO_8859_13,
+  ISO_8859_14,
+  ISO_8859_15,
+  ISO_8859_16,
+  WINDOWS_1250,
+  WINDOWS_1251,
+  WINDOWS_1252,
+  WINDOWS_1253,
+  WINDOWS_1254,
+  WINDOWS_1255,
+  WINDOWS_1256,
+  WINDOWS_1257,
+  WINDOWS_1258,
+} TextEncoding;
+
+#define TextcodeType \
+  PACK union { \
+    struct { \
+      UTFCharset encoding : 2; \
+      Endian endian : 1; \
+    }; \
+    TextEncoding type_code; \
+  }; \
+  ENDPACK
+
+struct text_coder {
+  RingBuffer buffer;
+  TextcodeType
+};
+
+typedef struct text_coder TextEncoder;
+typedef struct text_coder TextDecoder;
+
+extern VISIBLE JSClassID js_decoder_class_id, js_encoder_class_id;
+extern VISIBLE JSValue textdecoder_proto, textdecoder_ctor, textencoder_proto, textencoder_ctor;
+extern const char* const textcode_encodings[];
+
+size_t textdecoder_length(TextDecoder*);
+JSValue textdecoder_read(TextDecoder*, JSContext* ctx);
+int js_code_init(JSContext*, JSModuleDef* m);
+size_t textencoder_length(TextEncoder*);
+JSValue textencoder_read(TextEncoder*, JSContext* ctx);
+int js_encoder_init(JSContext*, JSModuleDef* m);
+
+static inline TextDecoder*
+js_decoder_data(JSContext* ctx, JSValueConst value) {
+  return JS_GetOpaque(value, js_decoder_class_id);
+}
+
+static inline TextEncoder*
+js_encoder_data(JSContext* ctx, JSValueConst value) {
+  return JS_GetOpaque(value, js_encoder_class_id);
+}
+
+/**
+ * @}
+ */
+#endif /* defined(QUICKJS_TEXTCODE_H) */

src/quickjs/ringbuffer.c

@@ -0,0 +1,136 @@
+#include "ringbuffer.h"
+
+/**
+ * \addtogroup ringbuffer
+ * @{
+ */
+void
+ringbuffer_reset(RingBuffer* r) {
+  r->head = r->tail = 0;
+}
+
+void
+ringbuffer_queue(RingBuffer* r, uint8_t data) {
+  /* overwrite the oldest byte if the r is full */
+  if(ringbuffer_full(r)) {
+    r->tail = ((r->tail + 1) % r->size);
+  }
+
+  r->data[r->head] = data;
+  r->head = ((r->head + 1) % r->size);
+}
+
+BOOL
+ringbuffer_dequeue(RingBuffer* r, uint8_t* data) {
+  if(ringbuffer_empty(r))
+    return FALSE;
+
+  *data = r->data[r->tail];
+  r->tail = ((r->tail + 1) % r->size);
+  return TRUE;
+}
+
+ssize_t
+ringbuffer_write(RingBuffer* r, const void* x, size_t len) {
+  const uint8_t* p = x;
+  size_t i;
+
+  if(ringbuffer_avail(r) < len)
+    return -1;
+  //    ringbuffer_realloc(r, ringbuffer_length(r) + len);
+
+  for(i = 0; i < len; i++) {
+    assert(!ringbuffer_full(r));
+    ringbuffer_queue(r, p[i]);
+  }
+
+  return i;
+}
+
+ssize_t
+ringbuffer_append(RingBuffer* r, const void* x, size_t len, JSContext* ctx) {
+
+  if(!ringbuffer_reserve(r, ringbuffer_length(r) + len))
+    return -1;
+
+  return ringbuffer_write(r, x, len);
+}
+
+ssize_t
+ringbuffer_read(RingBuffer* r, void* x, size_t len) {
+  uint8_t* p = x;
+  size_t i;
+
+  if(ringbuffer_empty(r))
+    return -1;
+
+  for(i = 0; i < len; i++)
+    ringbuffer_dequeue(r, &p[i]);
+
+  return i;
+}
+
+uint8_t*
+ringbuffer_peek(RingBuffer* r, size_t index) {
+  if(index >= ringbuffer_length(r))
+    return 0;
+
+  return &r->data[(r->tail + index) % r->size];
+}
+
+void
+ringbuffer_normalize(RingBuffer* r) {
+  if(r->head < r->tail) {
+    size_t n = r->size - r->tail;
+    void* x = alloca(r->head);
+    memcpy(x, r->data, r->head);
+    memmove(r->data, &r->data[r->tail], n);
+    memcpy(&r->data[n], x, r->head);
+    r->tail = 0;
+    r->head += n;
+    return;
+  }
+
+  memcpy(r->data, &r->data[r->tail], ringbuffer_length(r));
+  r->head -= r->tail;
+  r->tail = 0;
+}
+
+BOOL
+ringbuffer_resize(RingBuffer* r, size_t newsize) {
+  ringbuffer_normalize(r);
+  if(newsize > r->size)
+    return vector_grow(&r->vec, 1, newsize);
+  else if(newsize < r->size)
+    return vector_shrink(&r->vec, 1, newsize);
+  return TRUE;
+}
+
+BOOL
+ringbuffer_allocate(RingBuffer* r, size_t size) {
+  ssize_t n = ringbuffer_length(r);
+
+  if((r->size - n) < size)
+    return ringbuffer_resize(r, ringbuffer_length(r) + size);
+
+  return TRUE;
+}
+
+uint8_t*
+ringbuffer_reserve(RingBuffer* rb, size_t min_bytes) {
+  ssize_t grow;
+  if((grow = min_bytes - ringbuffer_avail(rb)) > 0)
+    if(!ringbuffer_resize(rb, vector_size(&rb->vec, 1) + grow))
+      return 0;
+
+  if(ringbuffer_headroom(rb) < min_bytes)
+    ringbuffer_normalize(rb);
+
+  assert(ringbuffer_headroom(rb) >= min_bytes);
+
+  return ringbuffer_end(rb);
+}
+
+/**
+ * @}
+ */

src/quickjs/ringbuffer.h

@@ -0,0 +1,88 @@
+#ifndef RINGBUFFER_H
+#define RINGBUFFER_H
+
+#include "vector.h"
+#include "debug.h"
+
+/**
+ * \defgroup ringbuffer ringbuffer: Ring Buffer implementation
+ * @{
+ */
+typedef union ringbuffer {
+  struct {
+    uint8_t* data;
+    size_t size, capacity;
+    BOOL error;
+    DynBufReallocFunc* realloc_func;
+    void* opaque;
+    volatile uint32_t tail, head;
+  };
+  DynBuf dbuf;
+  Vector vec;
+
+} RingBuffer;
+
+#define RINGBUFFER_INIT() \
+  { \
+    { 0, 0, 0, 0, &ringbuffer_default_realloc, 0 } \
+  }
+
+#define ringbuffer_init(rb, ctx) \
+  do { \
+    vector_init(&(rb)->vec, ctx); \
+    vector_allocate(&(rb)->vec, 1, 1023); \
+  } while(0)
+#define ringbuffer_init_rt(rb, rt) \
+  do { \
+    vector_init_rt(&(rb)->vec, rt); \
+    vector_allocate(&(rb)->vec, 1, 1023); \
+  } while(0)
+#define RINGBUFFER(ctx) \
+  (RingBuffer) { \
+    { 0, 0, 0, 0, (DynBufReallocFunc*)&js_realloc, ctx, 0, 0 } \
+  }
+#define RINGBUFFER_RT(rt) \
+  (RingBuffer) { \
+    { 0, 0, 0, 0, (DynBufReallocFunc*)&js_realloc_rt, rt } \
+  }
+#define ringbuffer_free(rb) vector_free(&(rb)->vec)
+#define ringbuffer_begin(rb) (void*)&ringbuffer_tail(rb)
+#define ringbuffer_end(rb) (void*)&ringbuffer_head(rb)
+#define ringbuffer_head(rb) (rb)->data[(rb)->head]
+#define ringbuffer_tail(rb) (rb)->data[(rb)->tail]
+
+#define ringbuffer_empty(rb) ((rb)->tail == (rb)->head)
+#define ringbuffer_full(rb) ((rb)->size == (rb)->head - (rb)->tail)
+#define ringbuffer_wrapped(rb) ((rb)->head < (rb)->tail)
+#define ringbuffer_headroom(rb) ((rb)->size - (rb)->head)
+#define ringbuffer_avail(rb) ((rb)->size - ringbuffer_length(rb))
+#define ringbuffer_length(rb) (ringbuffer_wrapped(rb) ? ((rb)->size - (rb)->tail) + (rb)->head : (rb)->head - (rb)->tail)
+#define ringbuffer_continuous(rb) (ringbuffer_wrapped(rb) ? (rb)->size - (rb)->tail : (rb)->head - (rb)->tail)
+#define ringbuffer_is_continuous(rb) ((rb)->head >= (rb)->tail)
+//#define ringbuffer_skip(rb, n) ((rb)->tail += (n), (rb)->tail %= (rb)->size)
+#define ringbuffer_wrap(rb, idx) ((idx) % (rb)->size)
+#define ringbuffer_next(rb, ptr) (void*)(ringbuffer_wrap(rb, ((uint8_t*)(ptr + 1)) - (rb)->data) + (rb)->data)
+
+void ringbuffer_reset(RingBuffer*);
+void ringbuffer_queue(RingBuffer*, uint8_t data);
+BOOL ringbuffer_dequeue(RingBuffer*, uint8_t* data);
+ssize_t ringbuffer_write(RingBuffer*, const void* x, size_t len);
+ssize_t ringbuffer_read(RingBuffer*, void* x, size_t len);
+uint8_t* ringbuffer_peek(RingBuffer*, size_t index);
+void ringbuffer_normalize(RingBuffer*);
+BOOL ringbuffer_resize(RingBuffer*, size_t);
+BOOL ringbuffer_allocate(RingBuffer*, size_t);
+uint8_t* ringbuffer_reserve(RingBuffer* rb, size_t min_bytes);
+ssize_t ringbuffer_append(RingBuffer* r, const void* x, size_t len, JSContext* ctx);
+
+static inline uint8_t*
+ringbuffer_skip(RingBuffer* rb, size_t n) {
+  assert(ringbuffer_length(rb) >= n);
+  rb->tail = (rb->tail + n) % rb->size;
+  return ringbuffer_begin(rb);
+}
+
+/**
+ * @}
+ */
+#endif /* defined(RINGBUFFER_H) */

src/quickjs/tutf8e.c

@@ -0,0 +1,676 @@
+
+#include <tutf8e.h>
+
+#include <string.h>
+
+int tutf8e_string_length(const uint16_t *table, const char *input, const char *invalid, size_t *input_length, size_t *output_length)
+{
+  const size_t invalid_length = invalid ? strlen(invalid) : 0;
+
+  const unsigned char *i;
+  for (i = (const unsigned char *) input; *i; ++i, (*input_length)++) {
+    const uint16_t c = table[*i];
+    if (c<0x80) {
+      *output_length += 1;
+      continue;
+    }
+    if (c<0x800) {
+      *output_length += 2;
+      continue;
+    }
+    if (c<0xffff) {
+      *output_length += 3;
+      continue;
+    }
+    if (invalid) {
+      *output_length += invalid_length;
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
+  }
+  return TUTF8E_OK;
+}
+
+int tutf8e_string_encode(const uint16_t *table, const char *input, const char *invalid, char *output, size_t *output_length)
+{
+  int ret;
+  size_t input_length = 0;
+  size_t encoded_length = 0;
+  if (!(ret = tutf8e_string_length(table, input, invalid, &input_length, &encoded_length)))
+  {
+    if (encoded_length+1 > *output_length) return TUTF8E_TOOLONG;
+    if (!(ret = tutf8e_buffer_encode(table, input, input_length, invalid, output, output_length)))
+    {
+      output[encoded_length] = 0;
+      return TUTF8E_OK;
+    }
+  }
+  return ret;
+}
+
+int tutf8e_buffer_length
+(
+  const uint16_t *table,
+  const char *input,
+  size_t input_length,
+  const char *invalid,
+  size_t *length
+)
+{
+  const size_t invalid_length = invalid ? strlen(invalid) : 0;
+
+  const unsigned char *i;
+  for (i = (const unsigned char *) input; input_length; ++i, --input_length) {
+    const uint16_t c = table[*i];
+    if (c<0x80) {
+      ++*length;
+      continue;
+    }
+    if (c<0x800) {
+      *length += 2;
+      continue;
+    }
+    if (c<0xffff) {
+      *length += 3;
+      continue;
+    }
+    if (invalid) {
+      *length += invalid_length;
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
+  }
+  return TUTF8E_OK;
+}
+
+int tutf8e_buffer_encode
+(
+  const uint16_t *table,
+  const char *input,
+  size_t input_length,
+  const char *invalid,
+  char *output,
+  size_t *output_length
+)
+{
+  size_t invalid_length = invalid ? strlen(invalid) : 0;
+
+  size_t left = *output_length;
+  unsigned char *o = (unsigned char *) output;
+  const unsigned char *i;
+  for (i = (const unsigned char *) input; input_length; ++i, --input_length) {
+    const uint16_t c = table[*i];
+    if (c<0x80) {
+      if (left<1) return TUTF8E_TOOLONG;
+      *(o++) = c;
+      left -= 1;
+      continue;
+    }
+    if (c<0x800) {
+      if (left<2) return TUTF8E_TOOLONG;
+      *(o++) = 0xc0 | (c>>6);
+      *(o++) = 0x80 | (c&0x3f);
+      left -= 2;
+      continue;
+    }
+    if (c<0xffff) {
+      if (left<3) return TUTF8E_TOOLONG;
+      *(o++) = 0xe0 | (c>>12);
+      *(o++) = 0x80 | ((c>>6)&0x3f);
+      *(o++) = 0x80 | (c&0x3f);
+      left -= 3;
+      continue;
+    }
+    if (invalid)
+    {
+      if (left<invalid_length) return TUTF8E_TOOLONG;
+      if (invalid_length) {
+        memcpy(o, invalid, invalid_length);
+        o += invalid_length;
+        left -= invalid_length;
+      }
+    }
+    else {
+      return TUTF8E_INVALID;
+    }
+  }
+  *output_length -= left;
+  return TUTF8E_OK;
+}
+
+const uint16_t tutf8e_iso_8859_1_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+  0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
+};
+
+const uint16_t tutf8e_iso_8859_10_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x0104, 0x0112, 0x0122, 0x012a, 0x0128, 0x0136, 0x00a7, 0x013b, 0x0110, 0x0160, 0x0166, 0x017d, 0x00ad, 0x016a, 0x014a,
+  0x00b0, 0x0105, 0x0113, 0x0123, 0x012b, 0x0129, 0x0137, 0x00b7, 0x013c, 0x0111, 0x0161, 0x0167, 0x017e, 0x2015, 0x016b, 0x014b,
+  0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e, 0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x00cf,
+  0x00d0, 0x0145, 0x014c, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x0168, 0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+  0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f, 0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x00ef,
+  0x00f0, 0x0146, 0x014d, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x0169, 0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x0138,
+};
+
+const uint16_t tutf8e_iso_8859_11_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07, 0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f,
+  0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17, 0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f,
+  0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27, 0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f,
+  0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37, 0x0e38, 0x0e39, 0x0e3a, 0xffff, 0xffff, 0xffff, 0xffff, 0x0e3f,
+  0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47, 0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f,
+  0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57, 0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0xffff, 0xffff, 0xffff, 0xffff,
+};
+
+const uint16_t tutf8e_iso_8859_13_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x201d, 0x00a2, 0x00a3, 0x00a4, 0x201e, 0x00a6, 0x00a7, 0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x201c, 0x00b5, 0x00b6, 0x00b7, 0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6,
+  0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112, 0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b,
+  0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7, 0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df,
+  0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113, 0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c,
+  0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7, 0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x2019,
+};
+
+const uint16_t tutf8e_iso_8859_14_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x1e02, 0x1e03, 0x00a3, 0x010a, 0x010b, 0x1e0a, 0x00a7, 0x1e80, 0x00a9, 0x1e82, 0x1e0b, 0x1ef2, 0x00ad, 0x00ae, 0x0178,
+  0x1e1e, 0x1e1f, 0x0120, 0x0121, 0x1e40, 0x1e41, 0x00b6, 0x1e56, 0x1e81, 0x1e57, 0x1e83, 0x1e60, 0x1ef3, 0x1e84, 0x1e85, 0x1e61,
+  0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0x0174, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x1e6a, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x0176, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0x0175, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x1e6b, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x0177, 0x00ff,
+};
+
+const uint16_t tutf8e_iso_8859_15_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20ac, 0x00a5, 0x0160, 0x00a7, 0x0161, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x017d, 0x00b5, 0x00b6, 0x00b7, 0x017e, 0x00b9, 0x00ba, 0x00bb, 0x0152, 0x0153, 0x0178, 0x00bf,
+  0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
+};
+
+const uint16_t tutf8e_iso_8859_16_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x0104, 0x0105, 0x0141, 0x20ac, 0x201e, 0x0160, 0x00a7, 0x0161, 0x00a9, 0x0218, 0x00ab, 0x0179, 0x00ad, 0x017a, 0x017b,
+  0x00b0, 0x00b1, 0x010c, 0x0142, 0x017d, 0x201d, 0x00b6, 0x00b7, 0x017e, 0x010d, 0x0219, 0x00bb, 0x0152, 0x0153, 0x0178, 0x017c,
+  0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0106, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0x0110, 0x0143, 0x00d2, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x015a, 0x0170, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0118, 0x021a, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x0107, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0x0111, 0x0144, 0x00f2, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x015b, 0x0171, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0119, 0x021b, 0x00ff,
+};
+
+const uint16_t tutf8e_iso_8859_2_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7, 0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b,
+  0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7, 0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c,
+  0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7, 0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
+  0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7, 0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
+  0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7, 0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
+  0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7, 0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
+};
+
+const uint16_t tutf8e_iso_8859_3_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x0126, 0x02d8, 0x00a3, 0x00a4, 0xffff, 0x0124, 0x00a7, 0x00a8, 0x0130, 0x015e, 0x011e, 0x0134, 0x00ad, 0xffff, 0x017b,
+  0x00b0, 0x0127, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x0125, 0x00b7, 0x00b8, 0x0131, 0x015f, 0x011f, 0x0135, 0x00bd, 0xffff, 0x017c,
+  0x00c0, 0x00c1, 0x00c2, 0xffff, 0x00c4, 0x010a, 0x0108, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0xffff, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x0120, 0x00d6, 0x00d7, 0x011c, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x016c, 0x015c, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0xffff, 0x00e4, 0x010b, 0x0109, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0xffff, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x0121, 0x00f6, 0x00f7, 0x011d, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x016d, 0x015d, 0x02d9,
+};
+
+const uint16_t tutf8e_iso_8859_4_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x0104, 0x0138, 0x0156, 0x00a4, 0x0128, 0x013b, 0x00a7, 0x00a8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00ad, 0x017d, 0x00af,
+  0x00b0, 0x0105, 0x02db, 0x0157, 0x00b4, 0x0129, 0x013c, 0x02c7, 0x00b8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014a, 0x017e, 0x014b,
+  0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e, 0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x012a,
+  0x0110, 0x0145, 0x014c, 0x0136, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x0168, 0x016a, 0x00df,
+  0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f, 0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x012b,
+  0x0111, 0x0146, 0x014d, 0x0137, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x0169, 0x016b, 0x02d9,
+};
+
+const uint16_t tutf8e_iso_8859_5_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040b, 0x040c, 0x00ad, 0x040e, 0x040f,
+  0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
+  0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
+  0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
+  0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
+  0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045a, 0x045b, 0x045c, 0x00a7, 0x045e, 0x045f,
+};
+
+const uint16_t tutf8e_iso_8859_6_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0xffff, 0xffff, 0xffff, 0x00a4, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x060c, 0x00ad, 0xffff, 0xffff,
+  0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x061b, 0xffff, 0xffff, 0xffff, 0x061f,
+  0xffff, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f,
+  0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, 0x0638, 0x0639, 0x063a, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+  0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064a, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f,
+  0x0650, 0x0651, 0x0652, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+};
+
+const uint16_t tutf8e_iso_8859_7_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x2018, 0x2019, 0x00a3, 0x20ac, 0x20af, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x037a, 0x00ab, 0x00ac, 0x00ad, 0xffff, 0x2015,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x0385, 0x0386, 0x00b7, 0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
+  0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
+  0x03a0, 0x03a1, 0xffff, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
+  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
+  0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0xffff,
+};
+
+const uint16_t tutf8e_iso_8859_8_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0xffff, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0xffff,
+  0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+  0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x2017,
+  0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7, 0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
+  0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7, 0x05e8, 0x05e9, 0x05ea, 0xffff, 0xffff, 0x200e, 0x200f, 0xffff,
+};
+
+const uint16_t tutf8e_iso_8859_9_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+  0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+  0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff,
+};
+
+const uint16_t tutf8e_windows_1250_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0xffff, 0x201a, 0xffff, 0x201e, 0x2026, 0x2020, 0x2021, 0xffff, 0x2030, 0x0160, 0x2039, 0x015a, 0x0164, 0x017d, 0x0179,
+  0xffff, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0xffff, 0x2122, 0x0161, 0x203a, 0x015b, 0x0165, 0x017e, 0x017a,
+  0x00a0, 0x02c7, 0x02d8, 0x0141, 0x00a4, 0x0104, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x015e, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x017b,
+  0x00b0, 0x00b1, 0x02db, 0x0142, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x0105, 0x015f, 0x00bb, 0x013d, 0x02dd, 0x013e, 0x017c,
+  0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7, 0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
+  0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7, 0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
+  0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7, 0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
+  0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7, 0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
+};
+
+const uint16_t tutf8e_windows_1251_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x0402, 0x0403, 0x201a, 0x0453, 0x201e, 0x2026, 0x2020, 0x2021, 0x20ac, 0x2030, 0x0409, 0x2039, 0x040a, 0x040c, 0x040b, 0x040f,
+  0x0452, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0xffff, 0x2122, 0x0459, 0x203a, 0x045a, 0x045c, 0x045b, 0x045f,
+  0x00a0, 0x040e, 0x045e, 0x0408, 0x00a4, 0x0490, 0x00a6, 0x00a7, 0x0401, 0x00a9, 0x0404, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x0407,
+  0x00b0, 0x00b1, 0x0406, 0x0456, 0x0491, 0x00b5, 0x00b6, 0x00b7, 0x0451, 0x2116, 0x0454, 0x00bb, 0x0458, 0x0405, 0x0455, 0x0457,
+  0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
+  0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
+  0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
+  0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
+};
+
+const uint16_t tutf8e_windows_1252_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0xffff, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0xffff, 0x017d, 0xffff,
+  0xffff, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0xffff, 0x017e, 0x0178,
+  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+  0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
+};
+
+const uint16_t tutf8e_windows_1253_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0xffff, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0xffff, 0x2030, 0xffff, 0x2039, 0xffff, 0xffff, 0xffff, 0xffff,
+  0xffff, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0xffff, 0x2122, 0xffff, 0x203a, 0xffff, 0xffff, 0xffff, 0xffff,
+  0x00a0, 0x0385, 0x0386, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0xffff, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x2015,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x00b5, 0x00b6, 0x00b7, 0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
+  0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
+  0x03a0, 0x03a1, 0xffff, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
+  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
+  0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0xffff,
+};
+
+const uint16_t tutf8e_windows_1254_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0xffff, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0xffff, 0xffff, 0xffff,
+  0xffff, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0xffff, 0xffff, 0x0178,
+  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+  0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+  0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+  0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff,
+};
+
+const uint16_t tutf8e_windows_1255_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0xffff, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0xffff, 0x2039, 0xffff, 0xffff, 0xffff, 0xffff,
+  0xffff, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0x02dc, 0x2122, 0xffff, 0x203a, 0xffff, 0xffff, 0xffff, 0xffff,
+  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20aa, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+  0x05b0, 0x05b1, 0x05b2, 0x05b3, 0x05b4, 0x05b5, 0x05b6, 0x05b7, 0x05b8, 0x05b9, 0xffff, 0x05bb, 0x05bc, 0x05bd, 0x05be, 0x05bf,
+  0x05c0, 0x05c1, 0x05c2, 0x05c3, 0x05f0, 0x05f1, 0x05f2, 0x05f3, 0x05f4, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+  0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7, 0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
+  0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7, 0x05e8, 0x05e9, 0x05ea, 0xffff, 0xffff, 0x200e, 0x200f, 0xffff,
+};
+
+const uint16_t tutf8e_windows_1256_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0x067e, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0x0679, 0x2039, 0x0152, 0x0686, 0x0698, 0x0688,
+  0x06af, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0x06a9, 0x2122, 0x0691, 0x203a, 0x0153, 0x200c, 0x200d, 0x06ba,
+  0x00a0, 0x060c, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x06be, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x061b, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x061f,
+  0x06c1, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f,
+  0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x00d7, 0x0637, 0x0638, 0x0639, 0x063a, 0x0640, 0x0641, 0x0642, 0x0643,
+  0x00e0, 0x0644, 0x00e2, 0x0645, 0x0646, 0x0647, 0x0648, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x0649, 0x064a, 0x00ee, 0x00ef,
+  0x064b, 0x064c, 0x064d, 0x064e, 0x00f4, 0x064f, 0x0650, 0x00f7, 0x0651, 0x00f9, 0x0652, 0x00fb, 0x00fc, 0x200e, 0x200f, 0x06d2,
+};
+
+const uint16_t tutf8e_windows_1257_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0xffff, 0x201a, 0xffff, 0x201e, 0x2026, 0x2020, 0x2021, 0xffff, 0x2030, 0xffff, 0x2039, 0xffff, 0x00a8, 0x02c7, 0x00b8,
+  0xffff, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0xffff, 0x2122, 0xffff, 0x203a, 0xffff, 0x00af, 0x02db, 0xffff,
+  0x00a0, 0xffff, 0x00a2, 0x00a3, 0x00a4, 0xffff, 0x00a6, 0x00a7, 0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6,
+  0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112, 0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b,
+  0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7, 0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df,
+  0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113, 0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c,
+  0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7, 0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x02d9,
+};
+
+const uint16_t tutf8e_windows_1258_utf8[256] =
+{
+  0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
+  0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f,
+  0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+  0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+  0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+  0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+  0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+  0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
+  0x20ac, 0xffff, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0xffff, 0x2039, 0x0152, 0xffff, 0xffff, 0xffff,
+  0xffff, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0x02dc, 0x2122, 0xffff, 0x203a, 0x0153, 0xffff, 0xffff, 0x0178,
+  0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+  0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+  0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x0300, 0x00cd, 0x00ce, 0x00cf,
+  0x0110, 0x00d1, 0x0309, 0x00d3, 0x00d4, 0x01a0, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x01af, 0x0303, 0x00df,
+  0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x0301, 0x00ed, 0x00ee, 0x00ef,
+  0x0111, 0x00f1, 0x0323, 0x00f3, 0x00f4, 0x01a1, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x01b0, 0x20ab, 0x00ff,
+};
+
+const TUTF8encoder tutf8e_encoder_iso_8859_1 = (TUTF8encoder) tutf8e_iso_8859_1_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_10 = (TUTF8encoder) tutf8e_iso_8859_10_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_11 = (TUTF8encoder) tutf8e_iso_8859_11_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_13 = (TUTF8encoder) tutf8e_iso_8859_13_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_14 = (TUTF8encoder) tutf8e_iso_8859_14_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_15 = (TUTF8encoder) tutf8e_iso_8859_15_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_16 = (TUTF8encoder) tutf8e_iso_8859_16_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_2 = (TUTF8encoder) tutf8e_iso_8859_2_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_3 = (TUTF8encoder) tutf8e_iso_8859_3_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_4 = (TUTF8encoder) tutf8e_iso_8859_4_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_5 = (TUTF8encoder) tutf8e_iso_8859_5_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_6 = (TUTF8encoder) tutf8e_iso_8859_6_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_7 = (TUTF8encoder) tutf8e_iso_8859_7_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_8 = (TUTF8encoder) tutf8e_iso_8859_8_utf8;
+const TUTF8encoder tutf8e_encoder_iso_8859_9 = (TUTF8encoder) tutf8e_iso_8859_9_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1250 = (TUTF8encoder) tutf8e_windows_1250_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1251 = (TUTF8encoder) tutf8e_windows_1251_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1252 = (TUTF8encoder) tutf8e_windows_1252_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1253 = (TUTF8encoder) tutf8e_windows_1253_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1254 = (TUTF8encoder) tutf8e_windows_1254_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1255 = (TUTF8encoder) tutf8e_windows_1255_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1256 = (TUTF8encoder) tutf8e_windows_1256_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1257 = (TUTF8encoder) tutf8e_windows_1257_utf8;
+const TUTF8encoder tutf8e_encoder_windows_1258 = (TUTF8encoder) tutf8e_windows_1258_utf8;
+
+TUTF8encoder tutf8e_encoder(const char *encoding)
+{
+  if (!strcmp(encoding, "iso-8859-1")) return tutf8e_encoder_iso_8859_1;
+  if (!strcmp(encoding, "iso-8859-10")) return tutf8e_encoder_iso_8859_10;
+  if (!strcmp(encoding, "iso-8859-11")) return tutf8e_encoder_iso_8859_11;
+  if (!strcmp(encoding, "iso-8859-13")) return tutf8e_encoder_iso_8859_13;
+  if (!strcmp(encoding, "iso-8859-14")) return tutf8e_encoder_iso_8859_14;
+  if (!strcmp(encoding, "iso-8859-15")) return tutf8e_encoder_iso_8859_15;
+  if (!strcmp(encoding, "iso-8859-16")) return tutf8e_encoder_iso_8859_16;
+  if (!strcmp(encoding, "iso-8859-2")) return tutf8e_encoder_iso_8859_2;
+  if (!strcmp(encoding, "iso-8859-3")) return tutf8e_encoder_iso_8859_3;
+  if (!strcmp(encoding, "iso-8859-4")) return tutf8e_encoder_iso_8859_4;
+  if (!strcmp(encoding, "iso-8859-5")) return tutf8e_encoder_iso_8859_5;
+  if (!strcmp(encoding, "iso-8859-6")) return tutf8e_encoder_iso_8859_6;
+  if (!strcmp(encoding, "iso-8859-7")) return tutf8e_encoder_iso_8859_7;
+  if (!strcmp(encoding, "iso-8859-8")) return tutf8e_encoder_iso_8859_8;
+  if (!strcmp(encoding, "iso-8859-9")) return tutf8e_encoder_iso_8859_9;
+  if (!strcmp(encoding, "windows-1250")) return tutf8e_encoder_windows_1250;
+  if (!strcmp(encoding, "windows-1251")) return tutf8e_encoder_windows_1251;
+  if (!strcmp(encoding, "windows-1252")) return tutf8e_encoder_windows_1252;
+  if (!strcmp(encoding, "windows-1253")) return tutf8e_encoder_windows_1253;
+  if (!strcmp(encoding, "windows-1254")) return tutf8e_encoder_windows_1254;
+  if (!strcmp(encoding, "windows-1255")) return tutf8e_encoder_windows_1255;
+  if (!strcmp(encoding, "windows-1256")) return tutf8e_encoder_windows_1256;
+  if (!strcmp(encoding, "windows-1257")) return tutf8e_encoder_windows_1257;
+  if (!strcmp(encoding, "windows-1258")) return tutf8e_encoder_windows_1258;
+
+  return NULL;
+}

src/quickjs/tutf8e.h

@@ -0,0 +1,138 @@
+
+#ifndef TUTF8E_H
+#define TUTF8E_H
+
+#include <stddef.h>  /* size_t */
+#include <stdint.h>  /* uint16_t */
+
+/*************** Internal API ***************/
+
+/* NUL-terminated C-string API */
+
+extern int tutf8e_string_length(const uint16_t *table, const char *input, const char *invalid, size_t *input_length, size_t *output_length);
+extern int tutf8e_string_encode(const uint16_t *table, const char *input, const char *invalid, char *output, size_t *output_length);
+
+/* Known-length buffer API */
+
+extern int tutf8e_buffer_length(const uint16_t *table, const char *input, size_t input_length, const char *invalid, size_t *output_length);
+extern int tutf8e_buffer_encode(const uint16_t *table, const char *input, size_t input_length, const char *invalid, char *output, size_t *output_length);
+
+/*************** Public API ***************/
+
+/* Opaque handle type */
+
+typedef void *TUTF8encoder;
+
+/* Query encoder by name */
+
+extern TUTF8encoder tutf8e_encoder(const char *encoding);
+
+#define TUTF8E_OK      0 /* Success                    */
+#define TUTF8E_INVALID 1 /* Invalid input character    */
+#define TUTF8E_TOOLONG 2 /* Insufficient output buffer */
+
+/*
+ * tutf8e_encoder_string_length
+ *
+ * Determine the length of input and UTF8 encoded output of NUL-terminated string
+ * Performance: single pass O(n)
+ *
+ * output NUL terminator not counted
+ *
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_string_length(const TUTF8encoder encoder, const char *input, const char *invalid, size_t *input_length, size_t *output_length)
+{
+  return tutf8e_string_length((const uint16_t *) encoder, input, invalid, input_length, output_length);
+}
+
+/*
+ * tutf8e_encoder_string_encode
+ *
+ * UTF8 encode NUL-terminated string
+ * Performance: two pass O(n)
+ *
+ * output string is NUL terminated
+ * output_length is output buffer size for input
+ * output_length is encoded length for output, including NUL
+ *
+ * - TUTF8E_TOOLONG if output buffer insuficient
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_string_encode(const TUTF8encoder encoder, const char *input, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_string_encode((const uint16_t *) encoder, input, invalid, output, output_length);
+}
+
+/* Known-length buffer API */
+
+/*
+ * tutf8e_encoder_buffer_length
+ *
+ * Determine the length of input and UTF8 encoded output of string
+ * Performance: single pass O(n)
+ *
+ * output NUL terminator not counted
+ *
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_buffer_length(const TUTF8encoder encoder, const char *input, const char *invalid, size_t input_length, size_t *length)
+{
+  return tutf8e_buffer_length((const uint16_t *) encoder, input, input_length, invalid, length);
+}
+
+/*
+ * tutf8e_encoder_buffer_encode
+ *
+ * UTF8 encode string
+ * Performance: two pass O(n)
+ *
+ * output string is not NUL terminated
+ *
+ * output_length is output buffer size for input
+ * output_length is encoded length for output
+ *
+ * - TUTF8E_TOOLONG if output buffer insuficient
+ * - TUTF8E_INVALID if input character is not convertable
+ * - TUTF8E_OK for success
+ */
+
+static inline int tutf8e_encoder_buffer_encode(const TUTF8encoder encoder, const char *input, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_buffer_encode((const uint16_t *) encoder, input, input_length, invalid, output, output_length);
+}
+
+/* Supported encoders */
+
+extern const TUTF8encoder tutf8e_encoder_iso_8859_1;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_10;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_11;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_13;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_14;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_15;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_16;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_2;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_3;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_4;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_5;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_6;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_7;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_8;
+extern const TUTF8encoder tutf8e_encoder_iso_8859_9;
+extern const TUTF8encoder tutf8e_encoder_windows_1250;
+extern const TUTF8encoder tutf8e_encoder_windows_1251;
+extern const TUTF8encoder tutf8e_encoder_windows_1252;
+extern const TUTF8encoder tutf8e_encoder_windows_1253;
+extern const TUTF8encoder tutf8e_encoder_windows_1254;
+extern const TUTF8encoder tutf8e_encoder_windows_1255;
+extern const TUTF8encoder tutf8e_encoder_windows_1256;
+extern const TUTF8encoder tutf8e_encoder_windows_1257;
+extern const TUTF8encoder tutf8e_encoder_windows_1258;
+
+#endif

src/quickjs/vector.c

@@ -0,0 +1,299 @@
+#include "vector.h"
+#include "buffer-utils.h"
+#include "utils.h"
+#include <assert.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "debug.h"
+
+/**
+ * \addtogroup vector
+ * @{
+ */
+
+realloc2_helper(vector_realloc);
+js_realloc_helper(vector_js_realloc);
+js_realloc_rt_helper(vector_js_realloc_rt);
+
+#define HAVE_UINT128
+
+#if(defined(__GNUC__) && (__GNUC__ >= 5)) || defined(HAVE__BUILTIN_MUL_OVERFLOW)
+
+/*#elif defined(HAVE_UINT128)
+#warning No umult64 implementation*/
+#else
+int
+umult64(uint64_t a, uint64_t b, uint64_t* c) {
+  uint32_t ahi = a >> 32;
+  uint32_t alo = (a & 0xffffffff);
+  uint32_t bhi = b >> 32;
+  uint32_t blo = (b & 0xffffffff);
+
+  if(ahi && bhi)
+    return 0;
+
+  a = (uint64_t)(ahi)*blo + (uint64_t)(alo)*bhi;
+
+  if(a <= 0xffffffff) {
+    uint64_t x = (uint64_t)(alo)*blo;
+    if(x + (a << 32) < x)
+      return 0;
+    *c = x + (a << 32);
+    return 1;
+  }
+
+  return 0;
+}
+#endif
+
+void
+vector_free(Vector* vec) {
+  if(vec->data)
+    vec->realloc_func(vec->opaque, vec->data, 0);
+
+  vec->data = 0;
+  vec->capacity = vec->size = 0;
+}
+
+int32_t
+vector_indexof(const Vector* vec, size_t elsz, void* ptr) {
+  if(ptr < vector_begin(vec) || ptr > vector_back(vec, elsz))
+    return -1;
+
+  return ((size_t)vector_begin(vec) - (size_t)ptr) / elsz;
+}
+
+int32_t
+vector_find(const Vector* vec, size_t elsz, void* ptr) {
+  void* x;
+  int32_t i = 0;
+
+  if(vector_empty(vec))
+    return -1;
+
+  vector_foreach(vec, elsz, x) {
+    if(!memcmp(x, ptr, elsz))
+      return i;
+
+    i++;
+  }
+
+  return -1;
+}
+
+int32_t
+vector_finds(const Vector* vec, const char* str) {
+  char** x;
+  int32_t i = 0;
+
+  if(vector_empty(vec))
+    return -1;
+
+  vector_foreach_t(vec, x) {
+    if(!strcmp(*x, str))
+      return i;
+
+    i++;
+  }
+
+  return -1;
+}
+
+int
+vector_counts(const Vector* vec, const char* str) {
+  char** x;
+  int count = 0;
+
+  if(vector_empty(vec))
+    return 0;
+
+  vector_foreach_t(vec, x) if(!strcmp(*x, str))++ count;
+
+  return count;
+}
+
+void*
+vector_put(Vector* vec, const void* bytes, size_t len) {
+  size_t pos;
+
+  if(!len)
+    return 0;
+
+  pos = vec->size;
+
+  if(!vector_allocate(vec, 1, vec->size + len - 1))
+    return 0;
+
+  memcpy(vec->data + pos, bytes, len);
+
+  return vec->data + pos;
+}
+
+void __attribute__((format(printf, 2, 3))) vector_printf(Vector* vec, const char* fmt, ...) {
+  va_list ap;
+  char buf[128];
+  size_t len;
+
+  va_start(ap, fmt);
+  len = vsnprintf(buf, sizeof(buf), fmt, ap);
+  va_end(ap);
+
+  if(len < sizeof(buf)) {
+    vector_put(vec, buf, len);
+  } else {
+    size_t pos = vec->size;
+
+    if(!vector_allocate(vec, 1, vec->size + len))
+      return;
+
+    va_start(ap, fmt);
+    len = vsnprintf((char*)(vec->data + pos), len, fmt, ap);
+    va_end(ap);
+
+    vec->size += len;
+  }
+}
+
+void
+vector_diff(void* a, size_t m, void* b, size_t n, size_t elsz, Vector* out) {
+  char* ptr = a;
+  size_t i;
+
+  for(i = 0; i < m; i++) {
+    if(array_contains(b, n, elsz, ptr))
+      vector_put(out, ptr, elsz);
+
+    ptr += elsz;
+  }
+}
+
+void
+vector_symmetricdiff(void* a, size_t m, void* b, size_t n, size_t elsz, Vector* out_a, Vector* out_b) {
+  vector_diff(a, m, b, n, elsz, out_a);
+  vector_diff(b, n, a, m, elsz, out_b);
+}
+
+void
+vector_intersection(void* a, size_t m, void* b, size_t n, size_t elsz, Vector* out) {
+  size_t i, j = 0, k = 0;
+
+  for(i = 0; i < m + n; i++) {
+    void* aptr = (char*)a + j * elsz;
+    void* bptr = (char*)b + k * elsz;
+    int r = memcmp(aptr, bptr, elsz);
+
+    if(r < 0 && j < m) {
+      j++;
+    } else if(r > 0 && k < n) {
+      k++;
+    } else if(r == 0 && j < m && k < n) {
+      vector_put(out, aptr, elsz);
+      j++;
+      k++;
+    }
+  }
+}
+
+int
+vector_copy(Vector* dst, const Vector* src) {
+  dst->realloc_func = src->realloc_func;
+  dst->opaque = src->opaque;
+  dst->data = 0;
+  dst->capacity = 0;
+
+  if(!dbuf_realloc(&dst->dbuf, src->size)) {
+    memcpy(dst->data, src->data, src->size);
+    return 1;
+  }
+
+  return 0;
+}
+
+void
+vector_fwrite(const Vector* vec, size_t start, FILE* out) {
+  size_t i, len = vector_size(vec, sizeof(char*));
+
+  for(i = start; i < len; i++) {
+    const char* str = *(char**)vector_at(vec, sizeof(char*), i);
+
+    fputs(i > start ? "',\n  '" : "[\n  '", out);
+    fputs(str, out);
+
+    if(i + 1 == len)
+      fputs("'\n]", out);
+  }
+
+  fflush(out);
+}
+
+BOOL
+vector_grow(Vector* vec, size_t elsz, int32_t len) {
+  uint64_t need;
+
+  if(len < 0)
+    return FALSE;
+
+  if(!umult64(elsz, len, &need))
+    return FALSE;
+
+  if(need <= vec->size)
+    return FALSE;
+
+  vec->data = vec->realloc_func(vec->opaque, vec->data, need);
+  vec->size = need;
+  return TRUE;
+}
+
+char*
+vector_pushstring(Vector* vec, const char* str) {
+  char* s;
+
+  if((s = vec->realloc_func(vec->opaque, 0, strlen(str) + 1))) {
+    strcpy(s, str);
+    vector_push(vec, s);
+  }
+
+  return s;
+}
+
+char*
+vector_pushstringlen(Vector* vec, const char* str, size_t len) {
+  char* s;
+
+  if((s = vec->realloc_func(vec->opaque, 0, len + 1))) {
+    strncpy(s, str, len);
+    s[len] = '\0';
+    vector_push(vec, s);
+  }
+
+  return s;
+}
+
+void
+vector_clearstrings(Vector* vec) {
+  char** ptr;
+
+  vector_foreach_t(vec, ptr) free(*ptr);
+  vector_clear(vec);
+}
+
+void
+vector_dumpstrings(const Vector* vec, DynBuf* buf) {
+  size_t i, len = vector_size(vec, sizeof(char*));
+
+  for(i = 0; i < len; i++) {
+    const char* str = *(char**)vector_at(vec, sizeof(char*), i);
+
+    dbuf_putstr(buf, i > 0 ? "',\n  '" : "[\n  '");
+    dbuf_putstr(buf, str);
+
+    if(i + 1 == len)
+      dbuf_putstr(buf, "'\n]");
+  }
+}
+
+/**
+ * @}
+ */

src/quickjs/vector.h

@@ -0,0 +1,242 @@
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include <quickjs.h>
+#include <cutils.h>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "debug.h"
+
+/**
+ * \defgroup vector vector: Vector implementation
+ * @{
+ */
+#define roundto(n, mod) (((n) = (((n) + (mod)-1))), n = (n) - ((uint64_t)(n) % (uint64_t)(mod)))
+
+typedef union Vector {
+  DynBuf dbuf;
+  struct {
+    char* data;
+    size_t size;
+    size_t capacity;
+    BOOL error;
+    DynBufReallocFunc* realloc_func;
+    void* opaque;
+  };
+} Vector;
+
+#define VECTOR_INIT() \
+  { \
+    { 0, 0, 0, 0, &vector_realloc, 0 } \
+  }
+
+#define vector_init(vec, ctx) dbuf_init2(&((vec)->dbuf), (ctx), (DynBufReallocFunc*)&vector_js_realloc)
+#define vector_init_rt(vec, rt) dbuf_init2(&((vec)->dbuf), (rt), (DynBufReallocFunc*)&vector_js_realloc_rt)
+#define VECTOR(ctx) \
+  (Vector) { \
+    { 0, 0, 0, 0, (DynBufReallocFunc*)&vector_js_realloc, ctx } \
+  }
+#define VECTOR_RT(rt) \
+  (Vector) { \
+    { 0, 0, 0, 0, (DynBufReallocFunc*)&vector_js_realloc_rt, rt } \
+  }
+
+#define vector_begin(vec) ((void*)((vec)->data))
+#define vector_end(vec) ((void*)((vec)->data + (vec)->size))
+
+#define vector_begin_t(vec, t) ((t*)vector_begin(vec))
+#define vector_end_t(vec, t) ((t*)vector_end(vec))
+
+#define vector_foreach_t(a, p) for((p) = vector_begin(a); (p) != vector_end(a); ++(p))
+#define vector_foreach(a, msz, p) for((p) = vector_begin(a); (char*)(p) != (char*)vector_end(a); (p) = (void*)(((char*)p) + msz))
+
+#if(defined(__GNUC__) && (__GNUC__ >= 5)) || defined(HAVE__BUILTIN_MUL_OVERFLOW)
+static inline int
+umult64(uint64_t a, uint64_t b, uint64_t* c) {
+  return !__builtin_mul_overflow(a, b, c);
+}
+#elif defined(HAVE_UINT128)
+static inline int
+umult64(uint64_t a, uint64_t b, uint64_t* c) {
+  __uint128_t x = ((__uint128_t)a) * b;
+  if((*c = (uint64_t)x) != x)
+    return 0;
+  return 1;
+}
+#else
+extern int umult64(uint64_t a, uint64_t b, uint64_t* c);
+#endif
+
+void* vector_realloc(void*, void* ptr, size_t size);
+void* vector_js_realloc(JSContext* ctx, void* ptr, size_t size);
+void* vector_js_realloc_rt(JSRuntime* rt, void* ptr, size_t size);
+int32_t vector_indexof(const Vector* vec, size_t elsz, void* ptr);
+int32_t vector_find(const Vector* vec, size_t elsz, void* ptr);
+int32_t vector_finds(const Vector* vec, const char* str);
+int vector_counts(const Vector* vec, const char* str);
+void* vector_put(Vector* vec, const void* bytes, size_t len);
+void vector_free(Vector* vec);
+void vector_printf(Vector* vec, const char*, ...);
+void vector_intersection(void*, size_t, void*, size_t, size_t, Vector*);
+void vector_diff(void*, size_t, void*, size_t, size_t, Vector*);
+void vector_symmetricdiff(void*, size_t, void*, size_t, size_t, Vector*, Vector*);
+int vector_copy(Vector* dst, const Vector* src);
+void vector_fwrite(const Vector*, size_t, FILE* out);
+BOOL vector_grow(Vector* vec, size_t elsz, int32_t len);
+char* vector_pushstring(Vector*, const char*);
+char* vector_pushstringlen(Vector*, const char*, size_t);
+void vector_clearstrings(Vector*);
+void vector_dumpstrings(const Vector*, DynBuf* buf);
+
+#define vector_push(vec, elem) vector_put((vec), &(elem), sizeof((elem)))
+
+static inline void*
+vector_allocate(Vector* vec, size_t elsz, int32_t pos) {
+  uint64_t need;
+  size_t capacity;
+  if(pos < 0)
+    return 0;
+  if(!umult64(elsz, pos + 1, &need))
+    return 0;
+  if(need > vec->size) {
+    capacity = vec->capacity;
+    if(need > capacity) {
+      if(elsz < 8)
+        roundto(need, 1000);
+      else
+        roundto(need, 8000);
+      assert(need >= 1000);
+      if(dbuf_realloc(&vec->dbuf, need))
+        return 0;
+      if(vec->capacity > capacity)
+        memset(vec->data + capacity, 0, vec->capacity - capacity);
+    }
+    vec->size = ((uint32_t)pos + 1) * elsz;
+  }
+  return vec->data + (uint32_t)pos * elsz;
+}
+
+static inline BOOL
+vector_shrink(Vector* vec, size_t elsz, int32_t len) {
+  uint64_t need;
+  if(len < 0)
+    return FALSE;
+  if(!umult64(elsz, len, &need))
+    return FALSE;
+  if(need > vec->size)
+    return FALSE;
+  vec->size = need;
+  return TRUE;
+}
+
+static inline void*
+vector_at(const Vector* vec, size_t elsz, int32_t pos) {
+  uint64_t offs;
+  if(pos < 0)
+    return 0;
+  if(!umult64(elsz, pos, &offs))
+    return 0;
+  if(offs >= vec->size)
+    return 0;
+  return vec->data + offs;
+}
+
+static inline uint32_t
+vector_size(const Vector* vec, size_t elsz) {
+  return vec->size / elsz;
+}
+
+static inline int
+vector_empty(const Vector* vec) {
+  return vec->size == 0;
+}
+
+static inline void*
+vector_front(const Vector* vec, size_t elsz) {
+  assert(vec->size >= elsz);
+  return vec->data;
+}
+
+static inline void*
+vector_back(const Vector* vec, size_t elsz) {
+  uint32_t n = vector_size(vec, elsz);
+  assert(n);
+  return vector_at(vec, elsz, n - 1);
+}
+
+static inline void
+vector_clear(Vector* vec) {
+  vec->size = 0;
+}
+
+static inline void
+vector_freestrings(Vector* vec) {
+  vector_clearstrings(vec);
+  vector_free(vec);
+}
+
+static inline void*
+vector_emplace(Vector* vec, size_t elsz) {
+  uint32_t n = vector_size(vec, elsz);
+  return vector_allocate(vec, elsz, n);
+}
+
+static inline void*
+vector_pop(Vector* vec, size_t elsz) {
+  uint32_t n = vector_size(vec, elsz);
+  assert(n);
+  vector_shrink(vec, elsz, n - 1);
+  return vector_end(vec);
+}
+
+static inline void
+vector_puts(Vector* vec, const char* str) {
+  vector_put(vec, str, strlen(str));
+}
+
+static inline void
+vector_putc(Vector* vec, char c) {
+  vector_put(vec, &c, 1);
+}
+
+static inline void
+vector_put0(Vector* vec) {
+  vector_put(vec, "\0", 1);
+}
+
+static inline void
+vector_putlong(Vector* vec, long l, int radix) {
+  char buf[64];
+  size_t len = snprintf(buf, sizeof(buf), radix == 16 ? "%lx" : radix == 8 ? "%lo" : "%lu", l);
+  vector_put(vec, buf, len);
+}
+
+static inline void
+vector_putptr(Vector* vec, void* p) {
+  vector_put(vec, &p, sizeof(p));
+}
+
+void quicksort_r(void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*, void*), void* ptr);
+
+static inline void
+vector_sort(Vector* vec, size_t elsz, int (*compar)(const void*, const void*, void*), void* arg) {
+  quicksort_r(vector_begin(vec), vector_size(vec, elsz), elsz, compar, arg);
+}
+
+static inline void
+vector_catlong(Vector* vec, long l, int radix) {
+  char buf[64];
+  size_t len = snprintf(buf, sizeof(buf), radix == 16 ? "%lx" : radix == 8 ? "%lo" : "%lu", l);
+  vector_put(vec, buf, len);
+}
+
+/**
+ * @}
+ */
+#endif /* defined(VECTOR_H) */

src/quickjs/windows_1250.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1250_H
+#define TUTF8E_WINDOWS_1250_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1250_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1250, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1250_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1250, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1250_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1250, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1250_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1250, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1251.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1251_H
+#define TUTF8E_WINDOWS_1251_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1251_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1251, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1251_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1251, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1251_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1251, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1251_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1251, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1252.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1252_H
+#define TUTF8E_WINDOWS_1252_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1252_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1252, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1252_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1252, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1252_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1252, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1252_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1252, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1253.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1253_H
+#define TUTF8E_WINDOWS_1253_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1253_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1253, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1253_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1253, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1253_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1253, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1253_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1253, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1254.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1254_H
+#define TUTF8E_WINDOWS_1254_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1254_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1254, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1254_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1254, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1254_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1254, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1254_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1254, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1255.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1255_H
+#define TUTF8E_WINDOWS_1255_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1255_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1255, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1255_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1255, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1255_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1255, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1255_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1255, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1256.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1256_H
+#define TUTF8E_WINDOWS_1256_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1256_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1256, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1256_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1256, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1256_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1256, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1256_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1256, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1257.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1257_H
+#define TUTF8E_WINDOWS_1257_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1257_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1257, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1257_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1257, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1257_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1257, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1257_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1257, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/quickjs/windows_1258.h

@@ -0,0 +1,27 @@
+
+#ifndef TUTF8E_WINDOWS_1258_H
+#define TUTF8E_WINDOWS_1258_H
+
+#include <tutf8e.h>
+
+static inline int tutf8e_windows_1258_string_length(const char *input, size_t *input_length, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_length(tutf8e_encoder_windows_1258, input, input_length, invalid, output_length);
+}
+
+static inline int tutf8e_windows_1258_string_encode(const char *input, char *output, const char *invalid, size_t *output_length)
+{
+  return tutf8e_encoder_string_encode(tutf8e_encoder_windows_1258, input, invalid, output, output_length);
+}
+
+static inline int tutf8e_windows_1258_buffer_length(const char *i, size_t input_length, const char *invalid, size_t *length)
+{
+  return tutf8e_encoder_buffer_length(tutf8e_encoder_windows_1258, input, input_length, invalid, length);
+}
+
+static inline int tutf8e_windows_1258_buffer_encode(const char *i, size_t input_length, const char *invalid, char *output, size_t *output_length)
+{
+  return tutf8e_encoder_buffer_encode(tutf8e_encoder_windows_1258, input, input_length, invalid, output, output_length);
+}
+
+#endif

src/ripple/app/hook/applyHook.h

@@ -20,6 +20,10 @@
 #include "quickjs-libc.h"
 #include "quickjs-atom.h"
 
+extern "C" {
+    JSModuleDef* js_init_module_textdecoder(JSContext* ctx, const char* name);
+}
+
 namespace hook {
 struct HookContext;
 struct HookResult;
@@ -1313,6 +1317,8 @@ public:
             JS_AddIntrinsicMapSet(ctx);
             JS_AddIntrinsicTypedArrays(ctx);
             JS_AddIntrinsicBigInt(ctx);
+            ::js_init_module_textdecoder(ctx, "textdecoder");
+
             JS_SetMaxStackSize(rt, 65535);
             JS_SetMemoryLimit(rt, 16 * 1024 * 1024);