xbintsc 0.3.87 → 0.5.6

package/runtime/xt_stdlib/strings.inc

@@ -1,5 +1,6 @@
 /* -- string methods ------------------------------------------------------- */
 
+/* Byte-level search. `from` is a byte offset; returns a byte offset or -1. */
 static int32_t xt_string_find(xt_string *haystack, xt_string *needle, int32_t from) {
   if (from < 0) from = 0;
   if ((uint32_t)from > haystack->length) return -1;
@@ -12,44 +13,67 @@ static int32_t xt_string_find(xt_string *haystack, xt_string *needle, int32_t fr
   return -1;
 }
 
+/* JavaScript indexes strings in UTF-16 code units; the byte search above is
+ * still correct because every JS index maps to a code-point boundary. */
 static xt_value xt_string_char_at(xt_value value, xt_value indexValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
   int32_t index = xt_to_int32(indexValue);
-  if (index < 0 || (uint32_t)index >= s->length) return xt_string_from_cstr("");
-  return xt_string_new(xt_string_bytes(s) + index, 1);
+  if (index < 0 || (uint32_t)index >= xt_string_utf16_length(s)) return xt_string_from_cstr("");
+  return xt_string_unit_value(s, index);
 }
 
 static xt_value xt_string_char_code_at(xt_value value, xt_value indexValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_number(NAN);
   int32_t index = xt_to_int32(indexValue);
-  if (index < 0 || (uint32_t)index >= s->length) return xt_number(NAN);
-  return xt_number((double)(unsigned char)xt_string_bytes(s)[index]);
+  int32_t unit = xt_string_code_unit(s, index);
+  if (unit < 0) return xt_number(NAN);
+  return xt_number((double)unit);
+}
+
+static xt_value xt_string_code_point_at_value(xt_value value, xt_value indexValue) {
+  xt_string *s = xt_as_string(value);
+  if (!s) return XT_UNDEFINED;
+  int32_t index = xt_to_int32(indexValue);
+  int32_t code = xt_string_code_point_at(s, index);
+  if (code < 0) return XT_UNDEFINED;
+  return xt_number((double)code);
 }
 
 static xt_value xt_string_index_of(xt_value value, xt_value needleValue, xt_value fromValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_number(-1);
   xt_string *needle = xt_as_string(xt_to_string(needleValue));
+  int32_t units = (int32_t)xt_string_utf16_length(s);
   int32_t from = fromValue == XT_UNDEFINED ? 0 : xt_to_int32(fromValue);
-  return xt_number((double)xt_string_find(s, needle, from));
+  if (from < 0) from = 0;
+  if (from > units) from = units;
+  /* A start position inside a surrogate pair leaves a lone low half; slice the
+   * tail so a search for the whole pair correctly fails. */
+  if (!xt_string_is_boundary(s, from)) {
+    xt_string *tail = xt_as_string(xt_string_slice_units(s, from, units));
+    int32_t at = xt_string_find(tail, needle, 0);
+    return xt_number(at < 0 ? -1.0 : (double)(from + xt_string_unit_offset(tail, at)));
+  }
+  int32_t at = xt_string_find(s, needle, xt_string_byte_offset(s, from));
+  return xt_number(at < 0 ? -1.0 : (double)xt_string_unit_offset(s, at));
 }
 
 static xt_value xt_string_slice(xt_value value, xt_value startValue, xt_value endValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
-  int32_t len = (int32_t)s->length;
+  int32_t len = (int32_t)xt_string_utf16_length(s);
   int32_t start = startValue == XT_UNDEFINED ? 0 : xt_to_int32(startValue);
   int32_t end = endValue == XT_UNDEFINED ? len : xt_to_int32(endValue);
   xt_normalize_slice(len, &start, &end);
-  return xt_string_new(xt_string_bytes(s) + start, (size_t)(end - start));
+  return xt_string_slice_units(s, start, end);
 }
 
 static xt_value xt_string_substring(xt_value value, xt_value startValue, xt_value endValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
-  int32_t len = (int32_t)s->length;
+  int32_t len = (int32_t)xt_string_utf16_length(s);
   int32_t start = startValue == XT_UNDEFINED ? 0 : xt_to_int32(startValue);
   int32_t end = endValue == XT_UNDEFINED ? len : xt_to_int32(endValue);
   if (start < 0) start = 0;
@@ -61,13 +85,13 @@ static xt_value xt_string_substring(xt_value value, xt_value startValue, xt_valu
     start = end;
     end = swap;
   }
-  return xt_string_new(xt_string_bytes(s) + start, (size_t)(end - start));
+  return xt_string_slice_units(s, start, end);
 }
 
 static xt_value xt_string_substr(xt_value value, xt_value startValue, xt_value lengthValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return xt_string_from_cstr("");
-  int32_t len = (int32_t)s->length;
+  int32_t len = (int32_t)xt_string_utf16_length(s);
   int32_t start = startValue == XT_UNDEFINED ? 0 : xt_to_int32(startValue);
   if (start < 0) start += len;
   if (start < 0) start = 0;
@@ -75,7 +99,7 @@ static xt_value xt_string_substr(xt_value value, xt_value startValue, xt_value l
   int32_t length = lengthValue == XT_UNDEFINED ? len - start : xt_to_int32(lengthValue);
   if (length < 0) length = 0;
   if (start + length > len) length = len - start;
-  return xt_string_new(xt_string_bytes(s) + start, (size_t)length);
+  return xt_string_slice_units(s, start, start + length);
 }
 
 static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_value limitValue) {
@@ -92,7 +116,10 @@ static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_valu
   const char *bytes = xt_string_bytes(s);
   const char *sepBytes = xt_string_bytes(sep);
   if (sep->length == 0) {
-    for (uint32_t i = 0; i < s->length; i++) xt_array_push(result, xt_string_new(bytes + i, 1));
+    /* Splitting on the empty string yields one string per UTF-16 code unit,
+     * so an emoji becomes its two surrogate halves. */
+    int32_t units = (int32_t)xt_string_utf16_length(s);
+    for (int32_t i = 0; i < units; i++) xt_array_push(result, xt_string_unit_value(s, i));
   } else {
     uint32_t start = 0;
     uint32_t i = 0;
@@ -122,6 +149,7 @@ static xt_value xt_string_case(xt_value value, int upper) {
     unsigned char c = (unsigned char)bytes[i];
     mutable[i] = (char)(upper ? toupper((int)c) : tolower((int)c));
   }
+  xt_string_finish(out);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
@@ -153,6 +181,7 @@ static xt_value xt_string_replace(xt_value value, xt_value searchValue, xt_value
   memcpy(mutable + at, repl, replacement->length);
   memcpy(mutable + at + replacement->length, text + at + search->length,
          s->length - (size_t)at - search->length);
+  xt_string_finish(out);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
@@ -168,23 +197,51 @@ static xt_value xt_string_repeat(xt_value value, xt_value countValue) {
   const char *bytes = xt_string_bytes(s);
   char *mutable = xt_string_mutable(out);
   for (int32_t i = 0; i < count; i++) memcpy(mutable + (size_t)i * s->length, bytes, s->length);
+  xt_string_finish(out);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
-static xt_value xt_string_starts_with(xt_value value, xt_value searchValue) {
+static xt_value xt_string_starts_with(xt_value value, xt_value searchValue, xt_value positionValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
+  const char *sBytes = xt_string_bytes(s);
+  const char *searchBytes = xt_string_bytes(search);
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  int32_t position = positionValue == XT_UNDEFINED ? 0 : xt_to_int32(positionValue);
+  if (position < 0) position = 0;
+  if (position > units) position = units;
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(xt_string_bytes(s), xt_string_bytes(search), search->length) == 0);
+  if (!xt_string_is_boundary(s, position)) {
+    xt_string *tail = xt_as_string(xt_string_slice_units(s, position, units));
+    if (search->length > tail->length) return XT_FALSE;
+    return xt_bool(memcmp(xt_string_bytes(tail), searchBytes, search->length) == 0);
+  }
+  int32_t at = xt_string_byte_offset(s, position);
+  if ((uint32_t)at + search->length > s->length) return XT_FALSE;
+  return xt_bool(memcmp(sBytes + at, searchBytes, search->length) == 0);
 }
 
-static xt_value xt_string_ends_with(xt_value value, xt_value searchValue) {
+static xt_value xt_string_ends_with(xt_value value, xt_value searchValue, xt_value endValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
+  const char *sBytes = xt_string_bytes(s);
+  const char *searchBytes = xt_string_bytes(search);
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  int32_t end = endValue == XT_UNDEFINED ? units : xt_to_int32(endValue);
+  if (end < 0) end = 0;
+  if (end > units) end = units;
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(xt_string_bytes(s) + s->length - search->length, xt_string_bytes(search), search->length) == 0);
+  if (!xt_string_is_boundary(s, end)) {
+    xt_string *prefix = xt_as_string(xt_string_slice_units(s, 0, end));
+    if (search->length > prefix->length) return XT_FALSE;
+    return xt_bool(memcmp(xt_string_bytes(prefix) + prefix->length - search->length,
+                          searchBytes, search->length) == 0);
+  }
+  int32_t at = xt_string_byte_offset(s, end);
+  if ((uint32_t)at < search->length) return XT_FALSE;
+  return xt_bool(memcmp(sBytes + at - search->length, searchBytes, search->length) == 0);
 }
 
 static xt_value xt_string_concat_args(xt_value value, int32_t argc, xt_value *argv) {

package/runtime/xt_stdlib2/array-statics.inc

@@ -18,9 +18,9 @@ xt_value xt_array_static(xt_value name, int32_t argc, xt_value *argv) {
       }
     } else if (XT_IS_STRING(source)) {
       xt_string *s = xt_as_string(source);
-      const char *bytes = xt_string_bytes(s);
-      for (uint32_t i = 0; i < s->length; i++) {
-        xt_value item = xt_string_new(bytes + i, 1);
+      uint32_t points = xt_string_code_point_count(s);
+      for (uint32_t i = 0; i < points; i++) {
+        xt_value item = xt_string_code_point_value(s, (int32_t)i);
         if (XT_IS_FUNCTION(mapper)) { xt_value args[2] = {item, xt_number((double)i)}; item = xt_closure_call(mapper, 2, args); }
         xt_array_push(out, item);
       }

package/runtime/xt_stdlib2/error.inc

@@ -26,6 +26,8 @@ static xt_value xt_error_proto_for(const char *name) {
                   xt_string_from_cstr("Error"));
     xt_object_set(xt_error_root_proto, xt_string_from_cstr("message"),
                   xt_string_from_cstr(""));
+    xt_value constructor = xt_error_constructor(xt_string_from_cstr("Error"));
+    xt_object_set(xt_error_root_proto, xt_string_from_cstr("constructor"), constructor);
   }
   if (strcmp(name, "Error") == 0) return xt_error_root_proto;
   xt_value key = xt_string_from_cstr(name);
@@ -41,6 +43,8 @@ static xt_value xt_error_proto_for(const char *name) {
   xt_object_set(proto, xt_string_from_cstr("name"), key);
   xt_object_set(proto, xt_string_from_cstr("message"), xt_string_from_cstr(""));
   xt_object_set(registry, key, proto);
+  xt_value constructor = xt_error_constructor(key);
+  xt_object_set(proto, xt_string_from_cstr("constructor"), constructor);
   return proto;
 }
 
@@ -162,6 +166,13 @@ xt_value xt_aggregate_error_ctor(int32_t argc, xt_value *argv) {
   return xt_make_error("AggregateError", argc, argv);
 }
 
+/* Dispatch used by the first-class constructor factory (`const E = TypeError`). */
+xt_value xt_error_ctor_by_name(xt_value nameValue, int32_t argc, xt_value *argv) {
+  const char *name = XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : "Error";
+  if (!xt_error_is_family(name)) name = "Error";
+  return xt_make_error(name, argc, argv);
+}
+
 /* `super(message)` inside a subclass of the builtin Error family: initialize
  * the already-allocated instance instead of creating a fresh object. The
  * parent's name selects the default `name` (`TypeError`, ...). */

package/runtime/xt_stdlib2/json.inc

@@ -36,14 +36,31 @@ static xt_value xt_json_parse_string(xt_json_cursor *c) {
           else if (h >= 'a' && h <= 'f') code |= (unsigned)(h - 'a' + 10);
           else if (h >= 'A' && h <= 'F') code |= (unsigned)(h - 'A' + 10);
         }
+        /* A high surrogate followed by `\u` and a low surrogate denotes one
+         * supplementary code point, exactly like a JavaScript string. */
+        if (code >= 0xD800 && code <= 0xDBFF && c->pos + 5 < c->length &&
+            c->data[c->pos] == '\\' && c->data[c->pos + 1] == 'u') {
+          unsigned low = 0;
+          int valid = 1;
+          for (int i = 0; i < 4; i++) {
+            char h = c->data[c->pos + 2 + (size_t)i];
+            low <<= 4;
+            if (h >= '0' && h <= '9') low |= (unsigned)(h - '0');
+            else if (h >= 'a' && h <= 'f') low |= (unsigned)(h - 'a' + 10);
+            else if (h >= 'A' && h <= 'F') low |= (unsigned)(h - 'A' + 10);
+            else valid = 0;
+          }
+          if (valid && low >= 0xDC00 && low <= 0xDFFF) {
+            code = 0x10000 + ((code - 0xD800) << 10) + (low - 0xDC00);
+            c->pos += 6;
+          }
+        }
         if (code >= 0x80) {
           char tmp[4];
-          int bytes = 0;
-          if (code < 0x800) { tmp[bytes++] = (char)(0xC0 | (code >> 6)); tmp[bytes++] = (char)(0x80 | (code & 0x3F)); }
-          else { tmp[bytes++] = (char)(0xE0 | (code >> 12)); tmp[bytes++] = (char)(0x80 | ((code >> 6) & 0x3F)); tmp[bytes++] = (char)(0x80 | (code & 0x3F)); }
-          if (length + (size_t)bytes + 1 > capacity) { capacity = (length + (size_t)bytes + 1) * 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-          memcpy(out + length, tmp, (size_t)bytes);
-          length += (size_t)bytes;
+          size_t bytes = xt_utf8_encode(code, tmp);
+          if (length + bytes + 1 > capacity) { capacity = (length + bytes + 1) * 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
+          memcpy(out + length, tmp, bytes);
+          length += bytes;
           continue;
         }
         ch = (char)code;
@@ -195,14 +212,26 @@ static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_va
     xt_string *s = xt_as_string(value);
     const char *bytes = xt_string_bytes(s);
     *out = xt_add(*out, xt_string_from_cstr("\""));
-    for (uint32_t i = 0; i < s->length; i++) {
-      char ch = bytes[i];
-      if (ch == '"') *out = xt_add(*out, xt_string_from_cstr("\\\""));
-      else if (ch == '\\') *out = xt_add(*out, xt_string_from_cstr("\\\\"));
-      else if (ch == '\n') *out = xt_add(*out, xt_string_from_cstr("\\n"));
-      else if (ch == '\r') *out = xt_add(*out, xt_string_from_cstr("\\r"));
-      else if (ch == '\t') *out = xt_add(*out, xt_string_from_cstr("\\t"));
-      else *out = xt_add(*out, xt_string_new(&ch, 1));
+    size_t offset = 0;
+    while (offset < s->length) {
+      size_t width = 0;
+      uint32_t code = xt_utf8_decode(bytes + offset, s->length - offset, &width);
+      const char *escape = NULL;
+      char buffer[8];
+      if (code == '"') escape = "\\\"";
+      else if (code == '\\') escape = "\\\\";
+      else if (code == '\b') escape = "\\b";
+      else if (code == '\f') escape = "\\f";
+      else if (code == '\n') escape = "\\n";
+      else if (code == '\r') escape = "\\r";
+      else if (code == '\t') escape = "\\t";
+      else if (code < 0x20 || (code >= 0xD800 && code <= 0xDFFF)) {
+        snprintf(buffer, sizeof(buffer), "\\u%04x", (unsigned)code);
+        escape = buffer;
+      }
+      if (escape) *out = xt_add(*out, xt_string_from_cstr(escape));
+      else *out = xt_add(*out, xt_string_new(bytes + offset, width));
+      offset += width;
     }
     *out = xt_add(*out, xt_string_from_cstr("\""));
     return;
@@ -216,7 +245,7 @@ xt_value xt_json_stringify(int32_t argc, xt_value *argv) {
   int indent = 0;
   xt_value space = xt_arg_at(argc, argv, 1);
   if (XT_IS_NUMBER(space)) indent = xt_to_int32(space);
-  else if (XT_IS_STRING(space)) indent = (int)((xt_string *)XT_GET_PTR(space))->length;
+  else if (XT_IS_STRING(space)) indent = (int)xt_string_utf16_length((xt_string *)XT_GET_PTR(space));
   if (indent < 0) indent = 0;
   if (indent > 10) indent = 10;
   xt_value value = xt_arg_at(argc, argv, 0);

package/runtime/xt_stdlib2/number-string-statics.inc

@@ -41,24 +41,33 @@ xt_value xt_number_static(xt_value name, int32_t argc, xt_value *argv) {
 xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
-  if (strcmp(fn, "fromCharCode") == 0 || strcmp(fn, "fromCodePoint") == 0) {
-    xt_string *out = xt_string_alloc((size_t)argc * 4 + 1);
-    char *mutable = xt_string_mutable(out);
+  if (strcmp(fn, "fromCharCode") == 0) {
+    /* `fromCharCode` takes UTF-16 code units (modulo 65536) and joins adjacent
+     * high/low surrogates into one code point, like JavaScript. */
+    if (argc <= 0) return xt_string_from_cstr("");
+    uint16_t *units = (uint16_t *)malloc(sizeof(uint16_t) * (size_t)argc);
+    if (!units) abort();
+    for (int32_t i = 0; i < argc; i++) units[i] = (uint16_t)(xt_to_int32(argv[i]) & 0xFFFF);
+    xt_value result = xt_string_from_units(units, (size_t)argc);
+    free(units);
+    return result;
+  }
+  if (strcmp(fn, "fromCodePoint") == 0) {
+    char *out = (char *)malloc((size_t)argc * 4 + 1);
+    if (!out) abort();
     size_t length = 0;
     for (int32_t i = 0; i < argc; i++) {
-      unsigned code = (unsigned)xt_to_int32(argv[i]);
-      char buffer[4];
-      int bytes = 0;
-      if (code < 0x80) buffer[bytes++] = (char)code;
-      else if (code < 0x800) { buffer[bytes++] = (char)(0xC0 | (code >> 6)); buffer[bytes++] = (char)(0x80 | (code & 0x3F)); }
-      else if (code < 0x10000) { buffer[bytes++] = (char)(0xE0 | (code >> 12)); buffer[bytes++] = (char)(0x80 | ((code >> 6) & 0x3F)); buffer[bytes++] = (char)(0x80 | (code & 0x3F)); }
-      else { buffer[bytes++] = (char)(0xF0 | (code >> 18)); buffer[bytes++] = (char)(0x80 | ((code >> 12) & 0x3F)); buffer[bytes++] = (char)(0x80 | ((code >> 6) & 0x3F)); buffer[bytes++] = (char)(0x80 | (code & 0x3F)); }
-      memcpy(mutable + length, buffer, (size_t)bytes);
-      length += (size_t)bytes;
+      int32_t code = xt_to_int32(argv[i]);
+      if (code < 0 || code > 0x10FFFF) {
+        free(out);
+        xt_throw(xt_string_from_cstr("RangeError: Invalid code point"));
+        return XT_UNDEFINED;
+      }
+      length += xt_utf8_encode((uint32_t)code, out + length);
     }
-    mutable[length] = '\0';
-    out->length = (uint32_t)length;
-    return XT_FROM_PTR(XT_TAG_STRING, out);
+    xt_value result = xt_string_new(out, length);
+    free(out);
+    return result;
   }
   if (strcmp(fn, "raw") == 0) {
     xt_value strings = xt_arg_at(argc, argv, 0);

package/runtime/xt_stdlib2/objects.inc

@@ -64,7 +64,7 @@ xt_value xt_object_static(xt_value name, int32_t argc, xt_value *argv) {
   }
   if (strcmp(fn, "create") == 0) {
     xt_value proto = xt_arg_at(argc, argv, 0);
-    return xt_object_new_with_proto(proto == XT_NULL ? XT_UNDEFINED : proto);
+    return xt_object_new_with_proto(proto == XT_NULL ? XT_NULL : proto);
   }
   return XT_UNDEFINED;
 }

package/runtime/xt_stdlib2/regexp-match.inc

@@ -203,7 +203,7 @@ xt_value xt_regexp_exec(xt_value target, xt_value input) {
     }
     xt_array_push(out, groupValue);
   }
-  xt_set(out, xt_string_from_cstr("index"), xt_number((double)matches[0].rm_so));
+  xt_set(out, xt_string_from_cstr("index"), xt_number((double)xt_string_unit_offset(text, matches[0].rm_so)));
   xt_set(out, xt_string_from_cstr("input"), textValue);
   xt_set(out, xt_string_from_cstr("groups"), XT_UNDEFINED);
   free(matches);
@@ -351,7 +351,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
         }
         xt_array_push(argArray, groupValue);
       }
-      xt_array_push(argArray, xt_number((double)start));
+      xt_array_push(argArray, xt_number((double)xt_string_unit_offset(text, start)));
       xt_array_push(argArray, xt_to_string(value));
       xt_value produced = xt_closure_call(replacementValue, jsTotal + 3, xt_as_array(argArray)->items);
       xt_string *producedText = xt_as_string(xt_to_string(produced));

package/runtime/xt_stdlib2/set.inc

@@ -17,6 +17,8 @@ int32_t xt_set_size(xt_value value) {
 xt_value xt_iter_length(xt_value value) {
   if (xt_is_map(value)) return xt_number((double)xt_map_size(value));
   if (xt_is_set(value)) return xt_number((double)xt_set_size(value));
+  /* Strings iterate by code point, not by UTF-16 unit. */
+  if (XT_IS_STRING(value)) return xt_number((double)xt_string_code_point_count(xt_as_string(value)));
   return xt_array_length(value);
 }
 
@@ -70,12 +72,16 @@ xt_value xt_iter_has(xt_value value, xt_value index) {
   if (xt_is_generator(value)) return xt_bool(xt_generator_has_next(value));
   if (xt_is_map(value)) return xt_bool(xt_to_int32(index) < xt_map_size(value));
   if (xt_is_set(value)) return xt_bool(xt_to_int32(index) < xt_set_size(value));
+  if (XT_IS_STRING(value))
+    return xt_bool(xt_to_int32(index) <
+                   (int32_t)xt_string_code_point_count(xt_as_string(value)));
   return xt_bool(xt_to_int32(index) < xt_to_int32(xt_array_length(value)));
 }
 
 xt_value xt_iter_value(xt_value value, xt_value index) {
   if (xt_is_iterator_state(value)) return ((xt_iterator_state *)XT_GET_PTR(value))->cached;
   if (xt_is_generator(value)) return xt_generator_iter_value(value);
+  if (XT_IS_STRING(value)) return xt_string_code_point_value(xt_as_string(value), xt_to_int32(index));
   if (xt_is_map(value)) {
     xt_map *map = (xt_map *)XT_GET_PTR(value);
     int64_t i = (int64_t)xt_to_int32(index);

package/runtime/xt_stdlib2/strings.inc

@@ -1,26 +1,28 @@
 /* -- string methods ------------------------------------------------------- */
 
+/* `padStart`/`padEnd` measure the target length in UTF-16 code units and may
+ * cut the pad string through a surrogate pair. */
 static xt_value xt_string_pad(xt_value value, xt_value lengthValue, xt_value padValue, int start) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   int32_t target = xt_to_int32(lengthValue);
-  if (target <= (int32_t)s->length) return value;
-  xt_string *pad = xt_as_string(xt_to_string(padValue == XT_UNDEFINED ? xt_string_from_cstr(" ") : padValue));
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (target <= units) return value;
+  xt_value padSymbol = padValue == XT_UNDEFINED ? xt_string_from_cstr(" ") : padValue;
+  xt_string *pad = xt_as_string(xt_to_string(padSymbol));
   if (!pad || pad->length == 0) return value;
-  size_t total = (size_t)target;
-  xt_string *out = xt_string_alloc(total);
-  char *mutable = xt_string_mutable(out);
-  const char *text = xt_string_bytes(s);
-  const char *padBytes = xt_string_bytes(pad);
-  size_t needed = total - s->length;
-  if (start) {
-    for (size_t i = 0; i < needed; i++) mutable[i] = padBytes[i % pad->length];
-    memcpy(mutable + needed, text, s->length);
-  } else {
-    memcpy(mutable, text, s->length);
-    for (size_t i = 0; i < needed; i++) mutable[s->length + i] = padBytes[i % pad->length];
+  int32_t padUnits = (int32_t)xt_string_utf16_length(pad);
+  if (padUnits <= 0) return value;
+  uint32_t needed = (uint32_t)(target - units);
+  xt_value padding = xt_string_from_cstr("");
+  uint32_t filled = 0;
+  while (filled < needed) {
+    uint32_t remaining = needed - filled;
+    int32_t chunk = remaining < (uint32_t)padUnits ? (int32_t)remaining : padUnits;
+    padding = xt_add(padding, xt_string_slice_units(pad, 0, chunk));
+    filled += (uint32_t)chunk;
   }
-  return XT_FROM_PTR(XT_TAG_STRING, out);
+  return start ? xt_add(padding, value) : xt_add(value, padding);
 }
 
 static xt_value xt_string_trim_side(xt_value value, int start) {
@@ -37,10 +39,11 @@ static xt_value xt_string_trim_side(xt_value value, int start) {
 static xt_value xt_string_at(xt_value value, xt_value indexValue) {
   xt_string *s = xt_as_string(value);
   if (!s) return XT_UNDEFINED;
+  int32_t units = (int32_t)xt_string_utf16_length(s);
   int32_t index = indexValue == XT_UNDEFINED ? 0 : xt_to_int32(indexValue);
-  if (index < 0) index += (int32_t)s->length;
-  if (index < 0 || (uint32_t)index >= s->length) return XT_UNDEFINED;
-  return xt_string_new(xt_string_bytes(s) + index, 1);
+  if (index < 0) index += units;
+  if (index < 0 || index >= units) return XT_UNDEFINED;
+  return xt_string_unit_value(s, index);
 }
 
 static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_value replacementValue) {
@@ -49,7 +52,18 @@ static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_v
   if (!s) return value;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
   xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
-  if (!search || search->length == 0) return value;
+  if (!search || search->length == 0) {
+    /* An empty search inserts the replacement before every UTF-16 code unit
+     * and once at the end. */
+    int32_t units = (int32_t)xt_string_utf16_length(s);
+    xt_value replacementText = xt_to_string(replacementValue);
+    xt_value result = replacementText;
+    for (int32_t i = 0; i < units; i++) {
+      result = xt_add(result, xt_string_unit_value(s, i));
+      result = xt_add(result, replacementText);
+    }
+    return result;
+  }
   const char *text = xt_string_bytes(s);
   const char *needle = xt_string_bytes(search);
   const char *repl = xt_string_bytes(replacement);
@@ -74,6 +88,33 @@ static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_v
   return result;
 }
 
+/* `limit` is a UTF-16 index; the last possible match starts at or before it. */
+static xt_value xt_string_last_index_of(xt_string *s, xt_string *needle, int32_t limit) {
+  if (!s || !needle) return xt_number(-1);
+  const char *text = xt_string_bytes(s);
+  const char *need = xt_string_bytes(needle);
+  int32_t units = (int32_t)xt_string_utf16_length(s);
+  if (limit < 0) limit = 0;
+  if (limit > units) limit = units;
+  if (needle->length == 0) return xt_number((double)limit);
+  /* The low half of a surrogate pair is a match candidate of its own, but a
+   * byte search from the pair start cannot see it. */
+  if (!xt_string_is_boundary(s, limit)) {
+    xt_string *tail = xt_as_string(xt_string_slice_units(s, limit, units));
+    if (needle->length <= tail->length &&
+        memcmp(xt_string_bytes(tail), need, needle->length) == 0)
+      return xt_number((double)limit);
+  }
+  if (needle->length > s->length) return xt_number(-1);
+  int32_t i = xt_string_byte_offset(s, limit);
+  if (i > (int32_t)s->length - (int32_t)needle->length) i = (int32_t)s->length - (int32_t)needle->length;
+  for (; i >= 0; i--) {
+    if (((unsigned char)text[i] & 0xC0) == 0x80) continue; /* not a code-point boundary */
+    if (memcmp(text + i, need, needle->length) == 0) return xt_number((double)xt_string_unit_offset(s, i));
+  }
+  return xt_number(-1);
+}
+
 xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
   *handled = 1;
   if (strcmp(method, "at") == 0) return xt_string_at(target, xt_arg_at(argc, argv, 0));
@@ -93,34 +134,22 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     xt_value regexp = xt_arg_at(argc, argv, 0);
     if (xt_is_regexp(regexp)) {
       int32_t start = 0;
-      if (xt_regexp_find(regexp, target, 0, &start, NULL)) return xt_number((double)start);
+      if (xt_regexp_find(regexp, target, 0, &start, NULL)) {
+        xt_string *text = xt_as_string(xt_to_string(target));
+        return xt_number((double)xt_string_unit_offset(text, start));
+      }
       return xt_number(-1);
     }
     *handled = 0;
     return XT_UNDEFINED;
   }
-  if (strcmp(method, "replaceAll") == 0) {
-    xt_value searchValue = xt_arg_at(argc, argv, 0);
-    if (xt_is_regexp(searchValue)) return xt_regexp_replace(target, searchValue, xt_arg_at(argc, argv, 1));
-    *handled = 0;
-    return XT_UNDEFINED;
-  }
   if (strcmp(method, "lastIndexOf") == 0) {
     xt_string *s = xt_as_string(target);
     xt_string *needle = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
     if (!s || !needle) return xt_number(-1);
-    int32_t limit = (argc >= 2 && argv[1] != XT_UNDEFINED) ? xt_to_int32(argv[1]) : (int32_t)s->length;
-    if (limit > (int32_t)s->length) limit = (int32_t)s->length;
-    int32_t nlen = (int32_t)needle->length;
-    if (nlen == 0) return xt_number((double)(limit < 0 ? 0 : limit));
-    const char *text = xt_string_bytes(s);
-    const char *need = xt_string_bytes(needle);
-    int32_t i = limit;
-    if (i > (int32_t)s->length - nlen) i = (int32_t)s->length - nlen;
-    for (; i >= 0; i--) {
-      if (memcmp(text + i, need, (size_t)nlen) == 0) return xt_number((double)i);
-    }
-    return xt_number(-1);
+    int32_t limit = (argc >= 2 && argv[1] != XT_UNDEFINED) ? xt_to_int32(argv[1])
+                                                          : (int32_t)xt_string_utf16_length(s);
+    return xt_string_last_index_of(s, needle, limit);
   }
   if (strcmp(method, "localeCompare") == 0) {
     xt_string *a = xt_as_string(target);
@@ -132,8 +161,9 @@ xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc,
     xt_string *s = xt_as_string(target);
     if (!s) return XT_UNDEFINED;
     int32_t index = xt_to_int32(xt_arg_at(argc, argv, 0));
-    if (index < 0 || (uint32_t)index >= s->length) return XT_UNDEFINED;
-    return xt_number((double)(unsigned char)xt_string_bytes(s)[index]);
+    int32_t code = xt_string_code_point_at(s, index);
+    if (code < 0) return XT_UNDEFINED;
+    return xt_number((double)code);
   }
   if (strcmp(method, "valueOf") == 0 || strcmp(method, "toString") == 0) return target;
   *handled = 0;