xbintsc 0.3.81 → 0.3.87

package/runtime/xt_stdlib/dispatch.inc

@@ -322,7 +322,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
       /* Bound functions report `name` as "bound <target>" and reduce `length`
        * by the number of pre-bound arguments, like the specification. */
       xt_function *targetFn = (xt_function *)XT_GET_PTR(target);
-      const char *base = targetFn->name ? targetFn->name->data : "";
+      const char *base = targetFn->name ? xt_string_bytes(targetFn->name) : "";
       char boundName[256];
       snprintf(boundName, sizeof(boundName), "bound %s", base);
       int32_t prebound = argc > 1 ? argc - 1 : 0;
@@ -336,7 +336,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     if (strcmp(method, "toString") == 0) {
       /* Source text is not retained; report a native-style representation. */
       xt_function *self = (xt_function *)XT_GET_PTR(target);
-      const char *selfName = self->name ? self->name->data : "";
+      const char *selfName = self->name ? xt_string_bytes(self->name) : "";
       char buffer[256];
       snprintf(buffer, sizeof(buffer), "function %s() { [native code] }", selfName);
       return xt_string_from_cstr(buffer);

package/runtime/xt_stdlib/strings.inc

@@ -4,8 +4,10 @@ static int32_t xt_string_find(xt_string *haystack, xt_string *needle, int32_t fr
   if (from < 0) from = 0;
   if ((uint32_t)from > haystack->length) return -1;
   if (needle->length == 0) return from;
+  const char *hay = xt_string_bytes(haystack);
+  const char *need = xt_string_bytes(needle);
   for (uint32_t i = (uint32_t)from; i + needle->length <= haystack->length; i++) {
-    if (memcmp(haystack->data + i, needle->data, needle->length) == 0) return (int32_t)i;
+    if (memcmp(hay + i, need, needle->length) == 0) return (int32_t)i;
   }
   return -1;
 }
@@ -15,7 +17,7 @@ static xt_value xt_string_char_at(xt_value value, xt_value indexValue) {
   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(s->data + index, 1);
+  return xt_string_new(xt_string_bytes(s) + index, 1);
 }
 
 static xt_value xt_string_char_code_at(xt_value value, xt_value indexValue) {
@@ -23,7 +25,7 @@ static xt_value xt_string_char_code_at(xt_value value, xt_value indexValue) {
   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)s->data[index]);
+  return xt_number((double)(unsigned char)xt_string_bytes(s)[index]);
 }
 
 static xt_value xt_string_index_of(xt_value value, xt_value needleValue, xt_value fromValue) {
@@ -41,7 +43,7 @@ static xt_value xt_string_slice(xt_value value, xt_value startValue, xt_value en
   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(s->data + start, (size_t)(end - start));
+  return xt_string_new(xt_string_bytes(s) + start, (size_t)(end - start));
 }
 
 static xt_value xt_string_substring(xt_value value, xt_value startValue, xt_value endValue) {
@@ -59,7 +61,7 @@ static xt_value xt_string_substring(xt_value value, xt_value startValue, xt_valu
     start = end;
     end = swap;
   }
-  return xt_string_new(s->data + start, (size_t)(end - start));
+  return xt_string_new(xt_string_bytes(s) + start, (size_t)(end - start));
 }
 
 static xt_value xt_string_substr(xt_value value, xt_value startValue, xt_value lengthValue) {
@@ -73,7 +75,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(s->data + start, (size_t)length);
+  return xt_string_new(xt_string_bytes(s) + start, (size_t)length);
 }
 
 static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_value limitValue) {
@@ -87,21 +89,23 @@ static xt_value xt_string_split(xt_value value, xt_value separatorValue, xt_valu
     return result;
   }
   xt_string *sep = xt_as_string(xt_to_string(separatorValue));
+  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(s->data + i, 1));
+    for (uint32_t i = 0; i < s->length; i++) xt_array_push(result, xt_string_new(bytes + i, 1));
   } else {
     uint32_t start = 0;
     uint32_t i = 0;
     while (i + sep->length <= s->length) {
-      if (memcmp(s->data + i, sep->data, sep->length) == 0) {
-        xt_array_push(result, xt_string_new(s->data + start, i - start));
+      if (memcmp(bytes + i, sepBytes, sep->length) == 0) {
+        xt_array_push(result, xt_string_new(bytes + start, i - start));
         i += sep->length;
         start = i;
       } else {
         i++;
       }
     }
-    xt_array_push(result, xt_string_new(s->data + start, s->length - start));
+    xt_array_push(result, xt_string_new(bytes + start, s->length - start));
   }
   xt_array *array = xt_as_array(result);
   if ((int64_t)array->length > limit) array->length = (uint32_t)limit;
@@ -112,9 +116,11 @@ static xt_value xt_string_case(xt_value value, int upper) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
   xt_string *out = xt_string_alloc(s->length);
+  const char *bytes = xt_string_bytes(s);
+  char *mutable = xt_string_mutable(out);
   for (uint32_t i = 0; i < s->length; i++) {
-    unsigned char c = (unsigned char)s->data[i];
-    out->data[i] = (char)(upper ? toupper((int)c) : tolower((int)c));
+    unsigned char c = (unsigned char)bytes[i];
+    mutable[i] = (char)(upper ? toupper((int)c) : tolower((int)c));
   }
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
@@ -122,11 +128,12 @@ static xt_value xt_string_case(xt_value value, int upper) {
 static xt_value xt_string_trim(xt_value value) {
   xt_string *s = xt_as_string(value);
   if (!s) return value;
+  const char *bytes = xt_string_bytes(s);
   uint32_t start = 0;
   uint32_t end = s->length;
-  while (start < end && isspace((unsigned char)s->data[start])) start++;
-  while (end > start && isspace((unsigned char)s->data[end - 1])) end--;
-  return xt_string_new(s->data + start, end - start);
+  while (start < end && isspace((unsigned char)bytes[start])) start++;
+  while (end > start && isspace((unsigned char)bytes[end - 1])) end--;
+  return xt_string_new(bytes + start, end - start);
 }
 
 static xt_value xt_string_replace(xt_value value, xt_value searchValue, xt_value replacementValue) {
@@ -137,11 +144,14 @@ static xt_value xt_string_replace(xt_value value, xt_value searchValue, xt_value
   xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
   int32_t at = xt_string_find(s, search, 0);
   if (at < 0) return value;
+  const char *text = xt_string_bytes(s);
+  const char *repl = xt_string_bytes(replacement);
   size_t total = s->length - search->length + replacement->length;
   xt_string *out = xt_string_alloc(total);
-  memcpy(out->data, s->data, (size_t)at);
-  memcpy(out->data + at, replacement->data, replacement->length);
-  memcpy(out->data + at + replacement->length, s->data + at + search->length,
+  char *mutable = xt_string_mutable(out);
+  memcpy(mutable, text, (size_t)at);
+  memcpy(mutable + at, repl, replacement->length);
+  memcpy(mutable + at + replacement->length, text + at + search->length,
          s->length - (size_t)at - search->length);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
@@ -155,7 +165,9 @@ static xt_value xt_string_repeat(xt_value value, xt_value countValue) {
     return XT_UNDEFINED;
   }
   xt_string *out = xt_string_alloc((size_t)s->length * (size_t)count);
-  for (int32_t i = 0; i < count; i++) memcpy(out->data + (size_t)i * s->length, s->data, s->length);
+  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);
   return XT_FROM_PTR(XT_TAG_STRING, out);
 }
 
@@ -164,7 +176,7 @@ static xt_value xt_string_starts_with(xt_value value, xt_value searchValue) {
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(s->data, search->data, search->length) == 0);
+  return xt_bool(memcmp(xt_string_bytes(s), xt_string_bytes(search), search->length) == 0);
 }
 
 static xt_value xt_string_ends_with(xt_value value, xt_value searchValue) {
@@ -172,7 +184,7 @@ static xt_value xt_string_ends_with(xt_value value, xt_value searchValue) {
   if (!s) return XT_FALSE;
   xt_string *search = xt_as_string(xt_to_string(searchValue));
   if (search->length > s->length) return XT_FALSE;
-  return xt_bool(memcmp(s->data + s->length - search->length, search->data, search->length) == 0);
+  return xt_bool(memcmp(xt_string_bytes(s) + s->length - search->length, xt_string_bytes(search), 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,8 +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(s->data + i, 1);
+        xt_value item = xt_string_new(bytes + i, 1);
         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/arrays.inc

@@ -46,7 +46,7 @@ static int xt_array_default_compare(xt_value a, xt_value b) {
   xt_string *sa = xt_as_string(xt_to_string(a));
   xt_string *sb = xt_as_string(xt_to_string(b));
   uint32_t n = sa->length < sb->length ? sa->length : sb->length;
-  int cmp = n ? memcmp(sa->data, sb->data, n) : 0;
+  int cmp = n ? memcmp(xt_string_bytes(sa), xt_string_bytes(sb), n) : 0;
   if (cmp != 0) return cmp < 0 ? -1 : 1;
   if (sa->length == sb->length) return 0;
   return sa->length < sb->length ? -1 : 1;

package/runtime/xt_stdlib2/error.inc

@@ -50,6 +50,15 @@ xt_value xt_error_prototype(xt_value nameValue) {
   return xt_error_proto_for(name);
 }
 
+/* Capture `Error.stack` into the object's private field (not a property, so it
+ * stays out of Object.keys/JSON.stringify, like V8's own non-enumerable stack). */
+static void xt_error_capture_stack(xt_value error, const char *name, xt_value message) {
+  if (!XT_IS_OBJECT(error)) return;
+  xt_string *text = xt_as_string(xt_to_string(message));
+  xt_value stack = xt_stack_capture(name, text ? xt_string_bytes(text) : "");
+  ((xt_object *)XT_GET_PTR(error))->error_stack = stack;
+}
+
 static xt_value xt_make_error(const char *name, int32_t argc, xt_value *argv) {
   if (!xt_error_is_family(name)) name = "Error";
   xt_value error = xt_object_new();
@@ -64,9 +73,10 @@ static xt_value xt_make_error(const char *name, int32_t argc, xt_value *argv) {
   } else {
     message = xt_arg_at(argc, argv, 0);
   }
+  xt_value messageValue = message == XT_UNDEFINED ? xt_string_from_cstr("") : message;
   xt_object_set(error, xt_string_from_cstr("name"), xt_string_from_cstr(name));
-  xt_object_set(error, xt_string_from_cstr("message"),
-                message == XT_UNDEFINED ? xt_string_from_cstr("") : message);
+  xt_object_set(error, xt_string_from_cstr("message"), messageValue);
+  xt_error_capture_stack(error, name, messageValue);
   return error;
 }
 
@@ -110,10 +120,10 @@ xt_value xt_error_to_string(xt_value error) {
   if (ms->length == 0) return nameStr;
   size_t total = ns->length + 2 + ms->length;
   char *buffer = (char *)malloc(total + 1);
-  memcpy(buffer, ns->data, ns->length);
+  memcpy(buffer, xt_string_bytes(ns), ns->length);
   buffer[ns->length] = ':';
   buffer[ns->length + 1] = ' ';
-  memcpy(buffer + ns->length + 2, ms->data, ms->length);
+  memcpy(buffer + ns->length + 2, xt_string_bytes(ms), ms->length);
   buffer[total] = '\0';
   xt_value result = xt_string_new(buffer, total);
   free(buffer);
@@ -159,6 +169,11 @@ xt_value xt_error_init(xt_value thisValue, 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";
+  /* `class MyError extends Error` allocates a plain object first; mark it as an
+   * Error so `.stack` and the error-specific property access apply. */
+  if (XT_IS_OBJECT(thisValue)) {
+    ((xt_object *)XT_GET_PTR(thisValue))->header.kind = XT_OBJECT_KIND_ERROR;
+  }
   xt_object_set(thisValue, xt_string_from_cstr("name"), xt_string_from_cstr(name));
   xt_value message;
   if (strcmp(name, "AggregateError") == 0) {
@@ -167,7 +182,8 @@ xt_value xt_error_init(xt_value thisValue, xt_value nameValue, int32_t argc,
   } else {
     message = xt_arg_at(argc, argv, 0);
   }
-  xt_object_set(thisValue, xt_string_from_cstr("message"),
-                message == XT_UNDEFINED ? xt_string_from_cstr("") : message);
+  xt_value messageValue = message == XT_UNDEFINED ? xt_string_from_cstr("") : message;
+  xt_object_set(thisValue, xt_string_from_cstr("message"), messageValue);
+  xt_error_capture_stack(thisValue, name, messageValue);
   return thisValue;
 }

package/runtime/xt_stdlib2/json.inc

@@ -120,7 +120,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,9 +193,10 @@ 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];
+      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"));

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

@@ -43,6 +43,7 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
   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);
     size_t length = 0;
     for (int32_t i = 0; i < argc; i++) {
       unsigned code = (unsigned)xt_to_int32(argv[i]);
@@ -52,9 +53,10 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
       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);
+      memcpy(mutable + length, buffer, (size_t)bytes);
       length += (size_t)bytes;
     }
+    mutable[length] = '\0';
     out->length = (uint32_t)length;
     return XT_FROM_PTR(XT_TAG_STRING, out);
   }

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,13 +191,13 @@ 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;
     }
@@ -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,18 +334,18 @@ 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;
         }
@@ -345,7 +355,7 @@ xt_value xt_regexp_replace(xt_value value, xt_value regexpValue, xt_value replac
       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;