xbintsc 0.3.81 → 0.5.6

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;
@@ -120,7 +137,7 @@ xt_value xt_json_parse(int32_t argc, xt_value *argv) {
   xt_value input = xt_to_string(xt_arg_at(argc, argv, 0));
   xt_string *s = xt_as_string(input);
   if (!s) return XT_UNDEFINED;
-  xt_json_cursor cursor = {s->data, s->length, 0};
+  xt_json_cursor cursor = {xt_string_bytes(s), s->length, 0};
   return xt_json_parse_value(&cursor);
 }
 
@@ -193,15 +210,28 @@ static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_va
   }
   if (XT_IS_STRING(value)) {
     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 = s->data[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;
@@ -215,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,22 +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);
+  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(out->data + 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);
     }
-    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

@@ -109,8 +109,11 @@ static int xt_regexp_run(xt_value regexpValue, xt_value input, int32_t start,
   if ((uint32_t)start > text->length) return 0;
   int flags = REG_EXTENDED;
   xt_string *f = xt_as_string(regexp->flags);
-  if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'i') flags |= REG_ICASE;
-  char *translated = xt_regexp_translate_js(pattern->data, jsGroups, groupCount);
+  if (f) {
+    const char *flagBytes = xt_string_bytes(f);
+    for (uint32_t i = 0; i < f->length; i++) if (flagBytes[i] == 'i') flags |= REG_ICASE;
+  }
+  char *translated = xt_regexp_translate_js(xt_string_bytes(pattern), jsGroups, groupCount);
   if (!translated) return 0;
   regex_t compiled;
   if (regcomp(&compiled, translated, flags) != 0) {
@@ -118,7 +121,7 @@ static int xt_regexp_run(xt_value regexpValue, xt_value input, int32_t start,
     return 0;
   }
   free(translated);
-  int ok = regexec(&compiled, text->data + start, nmatch, matches, 0) == 0;
+  int ok = regexec(&compiled, xt_string_bytes(text) + start, nmatch, matches, 0) == 0;
   regfree(&compiled);
   if (!ok) return 0;
   for (size_t i = 0; i < nmatch; i++) {
@@ -142,7 +145,8 @@ static int xt_regexp_is_global(xt_value regexpValue) {
   xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
   xt_string *f = xt_as_string(regexp->flags);
   if (!f) return 0;
-  for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == 'g') return 1;
+  const char *flags = xt_string_bytes(f);
+  for (uint32_t i = 0; i < f->length; i++) if (flags[i] == 'g') return 1;
   return 0;
 }
 
@@ -154,7 +158,7 @@ static int xt_regexp_js_group_count(xt_value regexpValue) {
   int count = (int)pattern->length + 1;
   int *groups = (int *)malloc(sizeof(int) * (size_t)count);
   int groupCount = 0;
-  char *translated = xt_regexp_translate_js(pattern->data, groups, &groupCount);
+  char *translated = xt_regexp_translate_js(xt_string_bytes(pattern), groups, &groupCount);
   free(translated);
   int total = 0;
   for (int i = 0; i < groupCount; i++) if (groups[i] > total) total = groups[i];
@@ -177,6 +181,7 @@ xt_value xt_regexp_exec(xt_value target, xt_value input) {
   if (!matches || !groups) { free(matches); free(groups); return XT_NULL; }
   xt_value textValue = xt_to_string(input);
   xt_string *text = xt_as_string(textValue);
+  const char *textBytes = xt_string_bytes(text);
   int groupCount = 0;
   if (!xt_regexp_run(target, input, 0, matches, cap, groups, &groupCount)) {
     free(matches);
@@ -186,19 +191,19 @@ xt_value xt_regexp_exec(xt_value target, xt_value input) {
   int jsTotal = 0;
   for (int i = 0; i < groupCount; i++) if (groups[i] > jsTotal) jsTotal = groups[i];
   xt_value out = xt_array_new(0, NULL);
-  xt_array_push(out, xt_string_new(text->data + matches[0].rm_so, (int64_t)(matches[0].rm_eo - matches[0].rm_so)));
+  xt_array_push(out, xt_string_new(textBytes + matches[0].rm_so, (int64_t)(matches[0].rm_eo - matches[0].rm_so)));
   for (int g = 1; g <= jsTotal; g++) {
     xt_value groupValue = XT_UNDEFINED;
     for (int i = 0; i < groupCount; i++) {
       if (groups[i] != g) continue;
       if (matches[i + 1].rm_so >= 0) {
-        groupValue = xt_string_new(text->data + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
+        groupValue = xt_string_new(textBytes + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
       }
       break;
     }
     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);
@@ -212,6 +217,7 @@ xt_value xt_regexp_match(xt_value input, xt_value regexp) {
   if (!xt_regexp_is_global(regexp)) return xt_regexp_exec(regexp, input);
   xt_value textValue = xt_to_string(input);
   xt_string *text = xt_as_string(textValue);
+  const char *textBytes = xt_string_bytes(text);
   xt_value results = xt_array_new(0, NULL);
   int32_t cursor = 0;
   int found = 0;
@@ -220,7 +226,7 @@ xt_value xt_regexp_match(xt_value input, xt_value regexp) {
     int32_t end = 0;
     if (!xt_regexp_find(regexp, input, cursor, &start, &end)) break;
     found = 1;
-    xt_array_push(results, xt_string_new(text->data + start, (int64_t)(end - start)));
+    xt_array_push(results, xt_string_new(textBytes + start, (int64_t)(end - start)));
     cursor = end > start ? end : end + 1;
   }
   return found ? results : XT_NULL;
@@ -241,10 +247,11 @@ static void xt_regexp_append(char **out, size_t *length, size_t *capacity, const
 static void xt_regexp_append_group(char **out, size_t *length, size_t *capacity,
                                    xt_string *text, regmatch_t *matches, int *groups,
                                    int groupCount, int group) {
+  const char *textBytes = xt_string_bytes(text);
   for (int i = 0; i < groupCount; i++) {
     if (groups[i] != group) continue;
     if (matches[i + 1].rm_so >= 0) {
-      xt_regexp_append(out, length, capacity, text->data + matches[i + 1].rm_so,
+      xt_regexp_append(out, length, capacity, textBytes + matches[i + 1].rm_so,
                        (size_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
     }
     return;
@@ -255,32 +262,34 @@ static void xt_regexp_expand_replacement(char **out, size_t *length, size_t *cap
                                          xt_string *replacement, xt_string *text,
                                          regmatch_t *matches, int *groups, int groupCount,
                                          int jsTotal) {
+  const char *repl = xt_string_bytes(replacement);
+  const char *textBytes = xt_string_bytes(text);
   size_t start = (size_t)matches[0].rm_so;
   size_t end = (size_t)matches[0].rm_eo;
   for (size_t i = 0; i < replacement->length; i++) {
-    char c = replacement->data[i];
+    char c = repl[i];
     if (c != '$' || i + 1 >= replacement->length) {
       xt_regexp_append(out, length, capacity, &c, 1);
       continue;
     }
-    char next = replacement->data[i + 1];
+    char next = repl[i + 1];
     if (next == '$') {
       xt_regexp_append(out, length, capacity, "$", 1);
       i++;
     } else if (next == '&') {
-      xt_regexp_append(out, length, capacity, text->data + start, end - start);
+      xt_regexp_append(out, length, capacity, textBytes + start, end - start);
       i++;
     } else if (next == '`') {
-      xt_regexp_append(out, length, capacity, text->data, start);
+      xt_regexp_append(out, length, capacity, textBytes, start);
       i++;
     } else if (next == '\'') {
-      xt_regexp_append(out, length, capacity, text->data + end, text->length - end);
+      xt_regexp_append(out, length, capacity, textBytes + end, text->length - end);
       i++;
     } else if (next >= '0' && next <= '9') {
       int value = next - '0';
       int digits = 1;
-      if (i + 2 < replacement->length && replacement->data[i + 2] >= '0' && replacement->data[i + 2] <= '9') {
-        int two = value * 10 + (replacement->data[i + 2] - '0');
+      if (i + 2 < replacement->length && repl[i + 2] >= '0' && repl[i + 2] <= '9') {
+        int two = value * 10 + (repl[i + 2] - '0');
         if (two <= jsTotal) { value = two; digits = 2; }
       }
       if (value >= 1 && value <= jsTotal) {
@@ -299,6 +308,7 @@ static void xt_regexp_expand_replacement(char **out, size_t *length, size_t *cap
 xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replacementValue) {
   xt_string *text = xt_as_string(xt_to_string(value));
   if (!text) return value;
+  const char *textBytes = xt_string_bytes(text);
   int global = xt_regexp_is_global(regexpValue);
   int useFunction = XT_IS_FUNCTION(replacementValue);
   xt_string *replacement = NULL;
@@ -324,28 +334,28 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
     if (!xt_regexp_run(regexpValue, value, cursor, matches, cap, groups, &groupCount)) break;
     int32_t start = (int32_t)matches[0].rm_so;
     int32_t end = (int32_t)matches[0].rm_eo;
-    xt_regexp_append(&out, &length, &capacity, text->data + cursor, (size_t)(start - cursor));
+    xt_regexp_append(&out, &length, &capacity, textBytes + cursor, (size_t)(start - cursor));
     if (useFunction) {
       /* Accumulate in an `xt_array` so the earlier match/group strings stay
          reachable while later groups (and the callback itself) allocate. */
       xt_value argArray = xt_array_new(0, NULL);
-      xt_array_push(argArray, xt_string_new(text->data + start, (int64_t)(end - start)));
+      xt_array_push(argArray, xt_string_new(textBytes + start, (int64_t)(end - start)));
       for (int g = 1; g <= jsTotal; g++) {
         xt_value groupValue = XT_UNDEFINED;
         for (int i = 0; i < groupCount; i++) {
           if (groups[i] != g) continue;
           if (matches[i + 1].rm_so >= 0) {
-            groupValue = xt_string_new(text->data + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
+            groupValue = xt_string_new(textBytes + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
           }
           break;
         }
         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));
-      if (producedText) xt_regexp_append(&out, &length, &capacity, producedText->data, producedText->length);
+      if (producedText) xt_regexp_append(&out, &length, &capacity, xt_string_bytes(producedText), producedText->length);
     } else {
       xt_regexp_expand_replacement(&out, &length, &capacity, replacement, text, matches, groups, groupCount, jsTotal);
     }
@@ -355,7 +365,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
     } else {
       /* Zero-width match: copy one byte so the scan always progresses. */
       if (cursor >= (int32_t)text->length) break;
-      xt_regexp_append(&out, &length, &capacity, text->data + cursor, 1);
+      xt_regexp_append(&out, &length, &capacity, textBytes + cursor, 1);
       cursor++;
     }
     if (!global) break;
@@ -367,7 +377,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
     return value;
   }
   size_t tail = text->length - (size_t)cursor;
-  xt_regexp_append(&out, &length, &capacity, text->data + cursor, tail);
+  xt_regexp_append(&out, &length, &capacity, textBytes + cursor, tail);
   xt_value result = xt_string_new(out, (int64_t)length);
   free(out);
   free(matches);
@@ -381,6 +391,7 @@ xt_value xt_regexp_split(xt_value value, xt_value regexpValue, xt_value limitVal
   xt_value result = xt_array_new(0, NULL);
   xt_string *text = xt_as_string(xt_to_string(value));
   if (!text) return result;
+  const char *textBytes = xt_string_bytes(text);
   int64_t limit = limitValue == XT_UNDEFINED ? 0x7fffffff : (int64_t)xt_to_int32(limitValue);
   if (limit <= 0) return result;
   xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
@@ -400,14 +411,14 @@ xt_value xt_regexp_split(xt_value value, xt_value regexpValue, xt_value limitVal
     int32_t end = (int32_t)matches[0].rm_eo;
     if (start != q) { q++; continue; }
     if (end == p) { q++; continue; }
-    xt_array_push(result, xt_string_new(text->data + p, (int64_t)(q - p)));
+    xt_array_push(result, xt_string_new(textBytes + p, (int64_t)(q - p)));
     if ((int64_t)xt_as_array(result)->length >= limit) { free(matches); free(groups); return result; }
     for (int g = 1; g <= jsTotal; g++) {
       xt_value groupValue = XT_UNDEFINED;
       for (int i = 0; i < groupCount; i++) {
         if (groups[i] != g) continue;
         if (matches[i + 1].rm_so >= 0) {
-          groupValue = xt_string_new(text->data + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
+          groupValue = xt_string_new(textBytes + matches[i + 1].rm_so, (int64_t)(matches[i + 1].rm_eo - matches[i + 1].rm_so));
         }
         break;
       }
@@ -418,7 +429,7 @@ xt_value xt_regexp_split(xt_value value, xt_value regexpValue, xt_value limitVal
     q = p;
   }
   if ((int64_t)xt_as_array(result)->length < limit) {
-    xt_array_push(result, xt_string_new(text->data + p, (int64_t)(len - p)));
+    xt_array_push(result, xt_string_new(textBytes + p, (int64_t)(len - p)));
   }
   free(matches);
   free(groups);
@@ -431,16 +442,20 @@ xt_value xt_regexp_get_property(xt_value target, xt_value key) {
   if (!XT_IS_STRING(key)) return XT_UNDEFINED;
   xt_string *k = xt_as_string(key);
   xt_string *f = xt_as_string(regexp->flags);
+  const char *keyBytes = xt_string_bytes(k);
   int flag = 0;
-  if (k->length == 6 && memcmp(k->data, "source", 6) == 0) return regexp->source;
-  if (k->length == 5 && memcmp(k->data, "flags", 5) == 0) return regexp->flags;
-  if (k->length == 9 && memcmp(k->data, "lastIndex", 9) == 0) return xt_number(0);
-  if (k->length == 6 && memcmp(k->data, "global", 6) == 0) flag = 'g';
-  else if (k->length == 10 && memcmp(k->data, "ignoreCase", 10) == 0) flag = 'i';
-  else if (k->length == 9 && memcmp(k->data, "multiline", 9) == 0) flag = 'm';
-  else if (k->length == 6 && memcmp(k->data, "sticky", 6) == 0) flag = 'y';
+  if (k->length == 6 && memcmp(keyBytes, "source", 6) == 0) return regexp->source;
+  if (k->length == 5 && memcmp(keyBytes, "flags", 5) == 0) return regexp->flags;
+  if (k->length == 9 && memcmp(keyBytes, "lastIndex", 9) == 0) return xt_number(0);
+  if (k->length == 6 && memcmp(keyBytes, "global", 6) == 0) flag = 'g';
+  else if (k->length == 10 && memcmp(keyBytes, "ignoreCase", 10) == 0) flag = 'i';
+  else if (k->length == 9 && memcmp(keyBytes, "multiline", 9) == 0) flag = 'm';
+  else if (k->length == 6 && memcmp(keyBytes, "sticky", 6) == 0) flag = 'y';
   if (flag) {
-    if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == flag) return XT_TRUE;
+    if (f) {
+      const char *flags = xt_string_bytes(f);
+      for (uint32_t i = 0; i < f->length; i++) if (flags[i] == flag) return XT_TRUE;
+    }
     return XT_FALSE;
   }
   return XT_UNDEFINED;

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,42 +1,49 @@
 /* -- 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);
-  size_t needed = total - s->length;
-  if (start) {
-    for (size_t i = 0; i < needed; i++) out->data[i] = pad->data[i % pad->length];
-    memcpy(out->data + needed, s->data, s->length);
-  } else {
-    memcpy(out->data, s->data, s->length);
-    for (size_t i = 0; i < needed; i++) out->data[s->length + i] = pad->data[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) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
+  const char *bytes = xt_string_bytes(s);
   uint32_t begin = 0;
   uint32_t end = s->length;
-  if (start) { while (begin < end && isspace((unsigned char)s->data[begin])) begin++; }
-  else { while (end > begin && isspace((unsigned char)s->data[end - 1])) end--; }
-  return xt_string_new(s->data + begin, end - begin);
+  if (start) { while (begin < end && isspace((unsigned char)bytes[begin])) begin++; }
+  else { while (end > begin && isspace((unsigned char)bytes[end - 1])) end--; }
+  return xt_string_new(bytes + begin, end - begin);
 }
 
 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(s->data + 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) {
@@ -45,21 +52,35 @@ 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);
   size_t capacity = s->length + replacement->length * 4 + 16;
   char *out = (char *)malloc(capacity);
   if (!out) abort();
   size_t length = 0;
   uint32_t i = 0;
   while (i < s->length) {
-    if (i + search->length <= s->length && memcmp(s->data + i, search->data, search->length) == 0) {
+    if (i + search->length <= s->length && memcmp(text + i, needle, search->length) == 0) {
       if (length + replacement->length + 2 > capacity) { capacity = (length + replacement->length + 2) * 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-      memcpy(out + length, replacement->data, replacement->length);
+      memcpy(out + length, repl, replacement->length);
       length += replacement->length;
       i += search->length;
     } else {
       if (length + 2 > capacity) { capacity *= 2; out = (char *)realloc(out, capacity); if (!out) abort(); }
-      out[length++] = s->data[i++];
+      out[length++] = text[i++];
     }
   }
   xt_value result = xt_string_new(out, length);
@@ -67,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));
@@ -86,45 +134,36 @@ 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));
-    int32_t i = limit;
-    if (i > (int32_t)s->length - nlen) i = (int32_t)s->length - nlen;
-    for (; i >= 0; i--) {
-      if (memcmp(s->data + i, needle->data, (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);
     xt_string *b = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
-    int cmp = strcmp(a ? a->data : "", b ? b->data : "");
+    int cmp = strcmp(a ? xt_string_bytes(a) : "", b ? xt_string_bytes(b) : "");
     return xt_number(cmp < 0 ? -1 : cmp > 0 ? 1 : 0);
   }
   if (strcmp(method, "codePointAt") == 0) {
     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)s->data[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;

package/runtime/xt_symbol.c

@@ -98,7 +98,7 @@ xt_value xt_symbol_to_string(xt_value value) {
   char *buffer = (char *)malloc(8 + length);
   if (!buffer) abort();
   memcpy(buffer, "Symbol(", 7);
-  if (description) memcpy(buffer + 7, description->data, length);
+  if (description) memcpy(buffer + 7, xt_string_bytes(description), length);
   buffer[7 + length] = ')';
   xt_value result = xt_string_new(buffer, 8 + length);
   free(buffer);