xbintsc 0.3.81 → 0.5.6

package/runtime/xt_typed_array/construction.inc

@@ -43,6 +43,10 @@ static xt_value xt_ta_proto(int kind) {
   xt_ta_define(proto, "keys", (void *)xt_ta_method_keys);
   xt_ta_define(proto, "values", (void *)xt_ta_method_values);
   xt_ta_define(proto, "entries", (void *)xt_ta_method_entries);
+  xt_value constructor = xt_builtin_constructor(xt_string_from_cstr(xt_ta_names[kind]));
+  if (constructor != XT_UNDEFINED) {
+    xt_object_set(proto, xt_string_from_cstr("constructor"), constructor);
+  }
   return proto;
 }
 
@@ -64,7 +68,7 @@ static int xt_ta_length_of(xt_value value, uint32_t *out) {
     return 1;
   }
   if (XT_IS_STRING(value)) {
-    *out = xt_as_string(value)->length;
+    *out = xt_string_code_point_count(xt_as_string(value));
     return 1;
   }
   if (xt_typed_array_kind_of(value) >= 0) {
@@ -86,8 +90,10 @@ static xt_value xt_ta_from_value(int kind, xt_value value, xt_value mapFn, xt_va
   uint32_t length = 0;
   if (!xt_ta_length_of(value, &length)) length = 0;
   xt_value array = xt_ta_new(kind, length);
+  xt_string *sourceString = XT_IS_STRING(value) ? xt_as_string(value) : NULL;
   for (uint32_t i = 0; i < length; i++) {
-    xt_value item = xt_get(value, xt_number((double)i));
+    xt_value item = sourceString ? xt_string_code_point_value(sourceString, (int32_t)i)
+                                 : xt_get(value, xt_number((double)i));
     if (haveMap) {
       xt_value args[3] = {item, xt_number((double)i), array};
       item = xt_call_with_this(mapFn, thisArg, 3, args);
@@ -140,3 +146,38 @@ XT_TA_CTOR(i32, XT_TA_I32)
 XT_TA_CTOR(f32, XT_TA_F32)
 XT_TA_CTOR(f64, XT_TA_F64)
 
+/* Dispatch by constructor name, used when a typed-array constructor is a
+ * first-class value (`const T = Uint8Array; new T(4)`). */
+static int xt_ta_kind_from_name(const char *name) {
+  if (!name) return -1;
+  if (strcmp(name, "Uint8Array") == 0) return XT_TA_U8;
+  if (strcmp(name, "Int8Array") == 0) return XT_TA_I8;
+  if (strcmp(name, "Uint8ClampedArray") == 0) return XT_TA_U8C;
+  if (strcmp(name, "Uint16Array") == 0) return XT_TA_U16;
+  if (strcmp(name, "Int16Array") == 0) return XT_TA_I16;
+  if (strcmp(name, "Uint32Array") == 0) return XT_TA_U32;
+  if (strcmp(name, "Int32Array") == 0) return XT_TA_I32;
+  if (strcmp(name, "Float32Array") == 0) return XT_TA_F32;
+  if (strcmp(name, "Float64Array") == 0) return XT_TA_F64;
+  return -1;
+}
+
+xt_value xt_typed_array_ctor_by_name(xt_value nameValue, int32_t argc, xt_value *argv) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_ctor_impl(kind, argc, argv);
+}
+
+xt_value xt_typed_array_static_by_name(xt_value nameValue, xt_value method, int32_t argc,
+                                       xt_value *argv) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_static_impl(kind, method, argc, argv);
+}
+
+xt_value xt_typed_array_prototype(xt_value nameValue) {
+  int kind = xt_ta_kind_from_name(XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : NULL);
+  if (kind < 0) return XT_UNDEFINED;
+  return xt_ta_proto(kind);
+}
+

package/runtime/xt_typed_array.c

@@ -34,6 +34,10 @@ enum {
 };
 
 static const int xt_ta_bytes[XT_TA_KIND_COUNT] = {1, 1, 1, 2, 2, 4, 4, 4, 8};
+static const char *const xt_ta_names[XT_TA_KIND_COUNT] = {
+    "Uint8Array", "Int8Array", "Uint8ClampedArray", "Uint16Array", "Int16Array",
+    "Uint32Array", "Int32Array", "Float32Array", "Float64Array",
+};
 
 static xt_value xt_ta_protos[XT_TA_KIND_COUNT];
 

package/runtime/xt_values/comparison.inc

@@ -33,7 +33,7 @@ xt_value xt_lt(xt_value a, xt_value b) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
     size_t n = x->length < y->length ? x->length : y->length;
-    int cmp = memcmp(x->data, y->data, n);
+    int cmp = memcmp(xt_string_bytes(x), xt_string_bytes(y), n);
     if (cmp == 0) return xt_bool(x->length < y->length);
     return xt_bool(cmp < 0);
   }
@@ -48,7 +48,7 @@ xt_value xt_le(xt_value a, xt_value b) {
     xt_string *x = xt_as_string(a);
     xt_string *y = xt_as_string(b);
     size_t n = x->length < y->length ? x->length : y->length;
-    int cmp = memcmp(x->data, y->data, n);
+    int cmp = memcmp(xt_string_bytes(x), xt_string_bytes(y), n);
     if (cmp == 0) return xt_bool(x->length <= y->length);
     return xt_bool(cmp < 0);
   }

package/runtime/xt_values/constructors.inc

@@ -10,19 +10,25 @@ xt_value xt_number(double d) { return xt_from_double(d); }
 xt_string *xt_string_alloc(size_t length) {
   xt_string *s = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
   s->length = (uint32_t)length;
+  s->utf16_length = 0;
+  s->code_point_count = 0;
+  /* Keep the terminator in the allocation: many consumers hand `flat` to libc. */
   s->capacity = (uint32_t)length + 1;
-  s->data = (char *)malloc(s->capacity);
-  if (!s->data) {
+  s->flat = (char *)malloc(s->capacity);
+  if (!s->flat) {
     fprintf(stderr, "xbintsc: out of memory allocating string\n");
     abort();
   }
-  s->data[length] = '\0';
+  s->flat[length] = '\0';
+  s->left = NULL;
+  s->right = NULL;
   return s;
 }
 
 xt_value xt_string_new(const char *data, size_t len) {
   xt_string *s = xt_string_alloc(len);
-  if (len > 0) memcpy(s->data, data, len);
+  if (len > 0) memcpy(s->flat, data, len);
+  xt_string_finish(s);
   return XT_FROM_PTR(XT_TAG_STRING, s);
 }
 
@@ -30,12 +36,19 @@ xt_value xt_string_from_cstr(const char *data) { return xt_string_new(data, strl
 
 xt_string *xt_as_string(xt_value v);
 
+char *xt_string_mutable(xt_string *s) { return s ? s->flat : NULL; }
+
 const char *xt_string_data(xt_value value) {
   xt_string *s = xt_as_string(value);
-  return s ? s->data : NULL;
+  return s ? xt_string_bytes(s) : NULL;
 }
 
 int32_t xt_string_length_value(xt_value value) {
   xt_string *s = xt_as_string(value);
   return s ? (int32_t)s->length : -1;
 }
+
+int32_t xt_string_utf16_length_value(xt_value value) {
+  xt_string *s = xt_as_string(value);
+  return s ? (int32_t)xt_string_utf16_length(s) : -1;
+}

package/runtime/xt_values/conversions.inc

@@ -24,8 +24,9 @@ double xt_to_number(xt_value v) {
   if (XT_IS_BIGINT(v)) return xt_bigint_to_double_value(v);
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
-    const char *begin = s->data;
-    const char *end = s->data + s->length;
+    const char *bytes = xt_string_bytes(s);
+    const char *begin = bytes;
+    const char *end = bytes + s->length;
     while (begin < end && isspace((unsigned char)*begin)) begin++;
     while (end > begin && isspace((unsigned char)end[-1])) end--;
     size_t length = (size_t)(end - begin);
@@ -83,7 +84,7 @@ xt_value xt_to_string(xt_value v) {
         out = (char *)realloc(out, capacity);
       }
       if (i > 0) out[length++] = ',';
-      memcpy(out + length, str->data, str->length);
+      memcpy(out + length, xt_string_bytes(str), str->length);
       length += str->length;
       out[length] = '\0';
     }

package/runtime/xt_values/strings.inc

@@ -2,6 +2,12 @@
 /* Strings                                                                   */
 /* ------------------------------------------------------------------------- */
 
+/* Concatenations up to this many bytes are copied eagerly. The copy is cheaper
+ * than a cons node for the short strings that dominate everyday code, and a
+ * loop that keeps appending crosses the threshold quickly, after which every
+ * append is O(1). */
+#define XT_STRING_CONS_THRESHOLD 32
+
 xt_string *xt_as_string(xt_value v) {
   if (XT_IS_STRING(v)) return (xt_string *)XT_GET_PTR(v);
   return NULL;
@@ -9,14 +15,98 @@ xt_string *xt_as_string(xt_value v) {
 
 int32_t xt_string_length(xt_string *s) { return (int32_t)s->length; }
 
+const char *xt_string_bytes(xt_string *s) {
+  if (!s) return NULL;
+  if (s->flat) return s->flat;
+
+  /* The tree is traversed depth-first without recursion: a loop that appends
+   * 100k times produces a 100k-deep left spine, which would overflow the C
+   * stack. Right children are pushed so the leftmost leaf is emitted first. */
+  size_t total = (size_t)s->length;
+  char *out = (char *)malloc(total + 1);
+  if (!out) {
+    fprintf(stderr, "xbintsc: out of memory flattening string\n");
+    abort();
+  }
+
+  size_t capacity = 64;
+  size_t count = 0;
+  xt_string **stack = (xt_string **)malloc(sizeof(xt_string *) * capacity);
+  if (!stack) {
+    fprintf(stderr, "xbintsc: out of memory flattening string\n");
+    abort();
+  }
+  stack[count++] = s;
+
+  size_t offset = 0;
+  while (count > 0) {
+    xt_string *node = stack[--count];
+    if (node->flat) {
+      memcpy(out + offset, node->flat, node->length);
+      offset += node->length;
+      continue;
+    }
+    if (count + 2 > capacity) {
+      while (count + 2 > capacity) capacity *= 2;
+      xt_string **grown = (xt_string **)realloc(stack, sizeof(xt_string *) * capacity);
+      if (!grown) {
+        fprintf(stderr, "xbintsc: out of memory flattening string\n");
+        abort();
+      }
+      stack = grown;
+    }
+    if (node->right) stack[count++] = node->right;
+    if (node->left) stack[count++] = node->left;
+  }
+  free(stack);
+
+  out[offset] = '\0';
+  s->flat = out;
+  s->length = (uint32_t)offset;
+  s->capacity = (uint32_t)(total + 1);
+  s->left = NULL;
+  s->right = NULL;
+  /* A concat boundary can split a surrogate pair; flattening is where the two
+   * halves meet, so normalise and record the UTF-16/code-point view now. */
+  xt_string_finish(s);
+  return s->flat;
+}
+
 static xt_value xt_string_concat(xt_string *a, xt_string *b) {
+  if (a->length == 0) return XT_FROM_PTR(XT_TAG_STRING, b);
+  if (b->length == 0) return XT_FROM_PTR(XT_TAG_STRING, a);
   size_t total = (size_t)a->length + (size_t)b->length;
-  xt_string *out = xt_string_alloc(total);
-  memcpy(out->data, a->data, a->length);
-  memcpy(out->data + a->length, b->data, b->length);
+  if (total <= XT_STRING_CONS_THRESHOLD) {
+    xt_string *out = xt_string_alloc(total);
+    const char *aBytes = xt_string_bytes(a);
+    uint32_t aLength = a->length;
+    const char *bBytes = xt_string_bytes(b);
+    uint32_t bLength = b->length;
+    memcpy(out->flat, aBytes, aLength);
+    memcpy(out->flat + aLength, bBytes, bLength);
+    xt_string_finish(out);
+    return XT_FROM_PTR(XT_TAG_STRING, out);
+  }
+  xt_string *out = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
+  out->length = (uint32_t)total;
+  /* UTF-16 length is additive even when the boundary joins a surrogate pair;
+   * the code-point count is not, so leave it to be recomputed after
+   * flattening. */
+  out->utf16_length = xt_string_utf16_length(a) + xt_string_utf16_length(b);
+  out->code_point_count = 0;
+  out->capacity = 0;
+  out->flat = NULL;
+  out->left = a;
+  out->right = b;
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
 int xt_string_equals(xt_string *a, xt_string *b) {
-  return a->length == b->length && memcmp(a->data, b->data, a->length) == 0;
+  /* Interned literals (property names above all) are shared, so identity is the
+   * common case and skips the length, flattening and byte comparison entirely. */
+  if (a == b) return 1;
+  const char *aBytes = xt_string_bytes(a);
+  const char *bBytes = xt_string_bytes(b);
+  if (a->length != b->length) return 0;
+  return memcmp(aBytes, bBytes, a->length) == 0;
 }

package/runtime/xt_values/utf16.inc

@@ -0,0 +1,340 @@
+/* ------------------------------------------------------------------------- */
+/* UTF-8 storage, UTF-16 view                                                */
+/* ------------------------------------------------------------------------- */
+/*
+ * Strings are stored as UTF-8, but JavaScript observes them as sequences of
+ * UTF-16 code units. The helpers here bridge the two views:
+ *
+ *   - a decoded code point above 0xFFFF occupies two UTF-16 units;
+ *   - a surrogate half that is not part of a pair (produced by indexing or
+ *     slicing through a pair) is stored as its own three-byte WTF-8 sequence;
+ *   - `xt_utf8_normalize_surrogates` recombines adjacent WTF-8 halves so that
+ *     concatenation and flattening keep the canonical four-byte form.
+ *
+ * Invalid UTF-8 bytes decode as U+FFFD with width 1, so a C extension that
+ * hands over arbitrary bytes can never make the walkers run off the end.
+ */
+
+uint32_t xt_utf8_decode(const char *data, size_t length, size_t *width) {
+  const unsigned char *bytes = (const unsigned char *)data;
+  if (length == 0) {
+    if (width) *width = 0;
+    return 0xFFFD;
+  }
+  unsigned char first = bytes[0];
+  if (first < 0x80) {
+    if (width) *width = 1;
+    return first;
+  }
+  if ((first & 0xE0) == 0xC0 && length >= 2 && (bytes[1] & 0xC0) == 0x80) {
+    if (width) *width = 2;
+    return ((uint32_t)(first & 0x1F) << 6) | (uint32_t)(bytes[1] & 0x3F);
+  }
+  if ((first & 0xF0) == 0xE0 && length >= 3 && (bytes[1] & 0xC0) == 0x80 &&
+      (bytes[2] & 0xC0) == 0x80) {
+    if (width) *width = 3;
+    return ((uint32_t)(first & 0x0F) << 12) | ((uint32_t)(bytes[1] & 0x3F) << 6) |
+           (uint32_t)(bytes[2] & 0x3F);
+  }
+  if ((first & 0xF8) == 0xF0 && length >= 4 && (bytes[1] & 0xC0) == 0x80 &&
+      (bytes[2] & 0xC0) == 0x80 && (bytes[3] & 0xC0) == 0x80) {
+    uint32_t code = ((uint32_t)(first & 0x07) << 18) | ((uint32_t)(bytes[1] & 0x3F) << 12) |
+                    ((uint32_t)(bytes[2] & 0x3F) << 6) | (uint32_t)(bytes[3] & 0x3F);
+    if (code >= 0x10000 && code <= 0x10FFFF) {
+      if (width) *width = 4;
+      return code;
+    }
+  }
+  /* Invalid or overlong sequence: consume one byte, report the replacement. */
+  if (width) *width = 1;
+  return 0xFFFD;
+}
+
+size_t xt_utf8_encode(uint32_t code, char *out) {
+  if (code < 0x80) {
+    out[0] = (char)code;
+    return 1;
+  }
+  if (code < 0x800) {
+    out[0] = (char)(0xC0 | (code >> 6));
+    out[1] = (char)(0x80 | (code & 0x3F));
+    return 2;
+  }
+  if (code < 0x10000) {
+    out[0] = (char)(0xE0 | (code >> 12));
+    out[1] = (char)(0x80 | ((code >> 6) & 0x3F));
+    out[2] = (char)(0x80 | (code & 0x3F));
+    return 3;
+  }
+  out[0] = (char)(0xF0 | ((code >> 18) & 0x07));
+  out[1] = (char)(0x80 | ((code >> 12) & 0x3F));
+  out[2] = (char)(0x80 | ((code >> 6) & 0x3F));
+  out[3] = (char)(0x80 | (code & 0x3F));
+  return 4;
+}
+
+void xt_utf8_measure(const char *data, size_t length, uint32_t *units, uint32_t *points) {
+  size_t offset = 0;
+  uint32_t unitCount = 0;
+  uint32_t pointCount = 0;
+  while (offset < length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(data + offset, length - offset, &width);
+    if (width == 0) break;
+    unitCount += code >= 0x10000 ? 2 : 1;
+    pointCount++;
+    offset += width;
+  }
+  if (units) *units = unitCount;
+  if (points) *points = pointCount;
+}
+
+uint32_t xt_utf8_utf16_length(const char *data, size_t length) {
+  uint32_t units = 0;
+  xt_utf8_measure(data, length, &units, NULL);
+  return units;
+}
+
+/* Both halves of a surrogate pair are encoded as three-byte WTF-8 sequences:
+ * `ED A0..AF xx` for D800-DBFF and `ED B0..BF xx` for DC00-DFFF. */
+static int xt_wtf8_surrogate(const unsigned char *bytes, size_t length, uint32_t *code, int *high) {
+  if (length < 3 || bytes[0] != 0xED || bytes[1] < 0xA0 || bytes[1] > 0xBF ||
+      bytes[2] < 0x80 || bytes[2] > 0xBF)
+    return 0;
+  *code = ((uint32_t)(bytes[0] & 0x0F) << 12) | ((uint32_t)(bytes[1] & 0x3F) << 6) |
+          (uint32_t)(bytes[2] & 0x3F);
+  *high = bytes[1] <= 0xAF;
+  return 1;
+}
+
+size_t xt_utf8_normalize_surrogates(char *data, size_t length) {
+  const unsigned char *source = (const unsigned char *)data;
+  unsigned char *write = (unsigned char *)data;
+  size_t offset = 0;
+  while (offset < length) {
+    uint32_t highCode = 0;
+    int high = 0;
+    if (xt_wtf8_surrogate(source + offset, length - offset, &highCode, &high) && high) {
+      uint32_t lowCode = 0;
+      int low = 0;
+      if (offset + 3 < length &&
+          xt_wtf8_surrogate(source + offset + 3, length - offset - 3, &lowCode, &low) && !low) {
+        uint32_t code = 0x10000 + ((highCode - 0xD800) << 10) + (lowCode - 0xDC00);
+        write += xt_utf8_encode(code, (char *)write);
+        offset += 6;
+        continue;
+      }
+    }
+    *write++ = source[offset++];
+  }
+  return (size_t)(write - (unsigned char *)data);
+}
+
+void xt_string_finish(xt_string *s) {
+  if (!s || !s->flat) return;
+  size_t length = xt_utf8_normalize_surrogates(s->flat, s->length);
+  s->length = (uint32_t)length;
+  s->flat[length] = '\0';
+  xt_utf8_measure(s->flat, length, &s->utf16_length, &s->code_point_count);
+}
+
+uint32_t xt_string_utf16_length(xt_string *s) {
+  if (!s || s->length == 0) return 0;
+  if (s->utf16_length) return s->utf16_length;
+  if (!s->flat) xt_string_bytes(s);
+  else xt_utf8_measure(s->flat, s->length, &s->utf16_length, &s->code_point_count);
+  return s->utf16_length;
+}
+
+uint32_t xt_string_code_point_count(xt_string *s) {
+  if (!s || s->length == 0) return 0;
+  if (s->code_point_count) return s->code_point_count;
+  if (!s->flat) xt_string_bytes(s);
+  else xt_utf8_measure(s->flat, s->length, &s->utf16_length, &s->code_point_count);
+  return s->code_point_count;
+}
+
+/* A string whose byte and UTF-16 lengths agree contains only ASCII, so the two
+ * index spaces coincide and every walker below can skip decoding. */
+static int xt_string_is_ascii(xt_string *s) {
+  return s->length == xt_string_utf16_length(s);
+}
+
+int32_t xt_string_code_unit(xt_string *s, int32_t index) {
+  if (!s || index < 0 || (uint32_t)index >= s->length) return -1;
+  if (xt_string_is_ascii(s)) return (int32_t)(unsigned char)xt_string_bytes(s)[index];
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    if (code >= 0x10000) {
+      uint32_t value = code - 0x10000;
+      if (unit == index) return (int32_t)(0xD800 + (value >> 10));
+      if (unit + 1 == index) return (int32_t)(0xDC00 + (value & 0x3FF));
+      unit += 2;
+    } else {
+      if (unit == index) return (int32_t)code;
+      unit += 1;
+    }
+    offset += width;
+  }
+  return -1;
+}
+
+int32_t xt_string_code_point_at(xt_string *s, int32_t index) {
+  if (!s || index < 0) return -1;
+  if (xt_string_is_ascii(s)) return index < (int32_t)s->length ? (int32_t)(unsigned char)xt_string_bytes(s)[index] : -1;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    int widthUnits = code >= 0x10000 ? 2 : 1;
+    if (unit == index) return (int32_t)code;
+    if (widthUnits == 2 && unit + 1 == index)
+      return (int32_t)(0xDC00 + ((code - 0x10000) & 0x3FF));
+    unit += widthUnits;
+    offset += width;
+  }
+  return -1;
+}
+
+xt_value xt_string_from_code_point(uint32_t code) {
+  char buffer[4];
+  size_t length = xt_utf8_encode(code, buffer);
+  return xt_string_new(buffer, length);
+}
+
+xt_value xt_string_from_units(const uint16_t *units, size_t count) {
+  size_t capacity = count * 4 + 1;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t length = 0;
+  for (size_t i = 0; i < count; i++) {
+    uint32_t code = units[i];
+    if (code >= 0xD800 && code <= 0xDBFF && i + 1 < count && units[i + 1] >= 0xDC00 &&
+        units[i + 1] <= 0xDFFF) {
+      code = 0x10000 + ((code - 0xD800) << 10) + ((uint32_t)units[i + 1] - 0xDC00);
+      i++;
+    }
+    length += xt_utf8_encode(code, out + length);
+  }
+  xt_value result = xt_string_new(out, length);
+  free(out);
+  return result;
+}
+
+xt_value xt_string_unit_value(xt_string *s, int32_t index) {
+  int32_t unit = xt_string_code_unit(s, index);
+  if (unit < 0) return xt_string_from_cstr("");
+  return xt_string_from_code_point((uint32_t)unit);
+}
+
+xt_value xt_string_code_point_value(xt_string *s, int32_t index) {
+  if (!s || index < 0) return XT_UNDEFINED;
+  if (xt_string_is_ascii(s))
+    return index < (int32_t)s->length
+               ? xt_string_from_code_point((uint32_t)(unsigned char)xt_string_bytes(s)[index])
+               : XT_UNDEFINED;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t point = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    if (point == index) return xt_string_from_code_point(code);
+    point++;
+    offset += width;
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_string_slice_units(xt_string *s, int32_t start, int32_t end) {
+  if (!s) return xt_string_from_cstr("");
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (start < 0) start = 0;
+  if (start > units) start = units;
+  if (end < 0) end = 0;
+  if (end > units) end = units;
+  if (start >= end) return xt_string_from_cstr("");
+  if (xt_string_is_ascii(s)) {
+    const char *ascii = xt_string_bytes(s);
+    return xt_string_new(ascii + start, (size_t)(end - start));
+  }
+
+  const char *bytes = xt_string_bytes(s);
+  /* Splitting a surrogate pair expands four bytes into two three-byte WTF-8
+   * halves, so leave two bytes of headroom. */
+  char *out = (char *)malloc((size_t)s->length + 8);
+  if (!out) abort();
+  size_t length = 0;
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    if (code >= 0x10000) {
+      uint32_t value = code - 0x10000;
+      if (start <= unit && end >= unit + 2) {
+        length += xt_utf8_encode(code, out + length);
+      } else if (start <= unit && end == unit + 1) {
+        length += xt_utf8_encode(0xD800 + (value >> 10), out + length);
+      } else if (start == unit + 1 && end >= unit + 2) {
+        length += xt_utf8_encode(0xDC00 + (value & 0x3FF), out + length);
+      }
+      unit += 2;
+    } else {
+      if (unit >= start && unit < end) length += xt_utf8_encode(code, out + length);
+      unit += 1;
+    }
+    offset += width;
+  }
+  xt_value result = xt_string_new(out, length);
+  free(out);
+  return result;
+}
+
+int32_t xt_string_byte_offset(xt_string *s, int32_t unit_index) {
+  if (!s || unit_index <= 0) return 0;
+  if (xt_string_is_ascii(s)) return unit_index < (int32_t)s->length ? unit_index : (int32_t)s->length;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < s->length) {
+    if (unit >= unit_index) return (int32_t)offset;
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    int widthUnits = code >= 0x10000 ? 2 : 1;
+    if (widthUnits == 2 && unit + 1 == unit_index) return (int32_t)offset;
+    unit += widthUnits;
+    offset += width;
+  }
+  return (int32_t)s->length;
+}
+
+int32_t xt_string_unit_offset(xt_string *s, int32_t byte_offset) {
+  if (!s || byte_offset <= 0) return 0;
+  if ((uint32_t)byte_offset >= s->length) return (int32_t)xt_string_utf16_length(s);
+  if (xt_string_is_ascii(s)) return byte_offset;
+  const char *bytes = xt_string_bytes(s);
+  size_t offset = 0;
+  int32_t unit = 0;
+  while (offset < (size_t)byte_offset && offset < s->length) {
+    size_t width = 0;
+    uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+    unit += code >= 0x10000 ? 2 : 1;
+    offset += width;
+  }
+  return unit;
+}
+
+int xt_string_is_boundary(xt_string *s, int32_t unit_index) {
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (unit_index <= 0 || unit_index >= units) return 1;
+  if (xt_string_is_ascii(s)) return 1;
+  int32_t byte = xt_string_byte_offset(s, unit_index);
+  return xt_string_unit_offset(s, byte) == unit_index;
+}

package/runtime/xt_values.c

@@ -19,6 +19,7 @@
 
 #include "xt_values/constructors.inc"
 #include "xt_values/strings.inc"
+#include "xt_values/utf16.inc"
 #include "xt_values/number-format.inc"
 #include "xt_values/conversions.inc"
 #include "xt_values/arithmetic.inc"