xbintsc 0.2.9 → 0.3.3

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

@@ -0,0 +1,73 @@
+/* -- Number / String statics ---------------------------------------------- */
+
+xt_value xt_number_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, "isInteger") == 0) {
+    xt_value v = xt_arg_at(argc, argv, 0);
+    if (!XT_IS_NUMBER(v)) return XT_FALSE;
+    double d = xt_to_double(v);
+    return xt_bool(isfinite(d) && floor(d) == d);
+  }
+  if (strcmp(fn, "isSafeInteger") == 0) {
+    xt_value v = xt_arg_at(argc, argv, 0);
+    if (!XT_IS_NUMBER(v)) return XT_FALSE;
+    double d = xt_to_double(v);
+    return xt_bool(isfinite(d) && floor(d) == d && fabs(d) <= 9007199254740991.0);
+  }
+  if (strcmp(fn, "isFinite") == 0) {
+    xt_value v = xt_arg_at(argc, argv, 0);
+    if (!XT_IS_NUMBER(v)) return XT_FALSE;
+    return xt_bool(isfinite(xt_to_double(v)));
+  }
+  if (strcmp(fn, "isNaN") == 0) {
+    xt_value v = xt_arg_at(argc, argv, 0);
+    if (!XT_IS_NUMBER(v)) return XT_FALSE;
+    return xt_bool(isnan(xt_to_double(v)));
+  }
+  if (strcmp(fn, "parseFloat") == 0) return xt_parse_float(argc, argv);
+  if (strcmp(fn, "parseInt") == 0) return xt_parse_int(argc, argv);
+  if (strcmp(fn, "MAX_SAFE_INTEGER") == 0) return xt_number(9007199254740991.0);
+  if (strcmp(fn, "MIN_SAFE_INTEGER") == 0) return xt_number(-9007199254740991.0);
+  if (strcmp(fn, "MAX_VALUE") == 0) return xt_number(1.7976931348623157e308);
+  if (strcmp(fn, "MIN_VALUE") == 0) return xt_number(5e-324);
+  if (strcmp(fn, "EPSILON") == 0) return xt_number(2.220446049250313e-16);
+  if (strcmp(fn, "POSITIVE_INFINITY") == 0) return xt_number(INFINITY);
+  if (strcmp(fn, "NEGATIVE_INFINITY") == 0) return xt_number(-INFINITY);
+  if (strcmp(fn, "NaN") == 0) return xt_number(NAN);
+  return XT_UNDEFINED;
+}
+
+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);
+    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;
+    }
+    out->length = (uint32_t)length;
+    return XT_FROM_PTR(XT_TAG_STRING, out);
+  }
+  if (strcmp(fn, "raw") == 0) {
+    xt_value strings = xt_arg_at(argc, argv, 0);
+    xt_value raw = xt_object_get(strings, xt_string_from_cstr("raw"));
+    xt_value out = xt_string_from_cstr("");
+    double length = xt_to_number(xt_get(raw, xt_string_from_cstr("length")));
+    for (int32_t i = 0; i < (int32_t)length; i++) {
+      out = xt_add(out, xt_get(raw, xt_number((double)i)));
+      if (i + 1 < (int32_t)length && i + 1 < argc) out = xt_add(out, xt_to_string(argv[i + 1]));
+    }
+    return out;
+  }
+  return XT_UNDEFINED;
+}

package/runtime/xt_stdlib2/numbers.inc

@@ -0,0 +1,38 @@
+/* -- number methods ------------------------------------------------------- */
+
+xt_value xt_ext_number_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
+  *handled = 1;
+  double n = xt_to_double(target);
+  if (strcmp(method, "toFixed") == 0) {
+    int precision = argc >= 1 ? xt_to_int32(argv[0]) : 0;
+    if (precision < 0) precision = 0;
+    if (precision > 100) precision = 100;
+    char buffer[512];
+    snprintf(buffer, sizeof(buffer), "%.*f", precision, n);
+    return xt_string_from_cstr(buffer);
+  }
+  if (strcmp(method, "toPrecision") == 0) {
+    if (argc == 0 || argv[0] == XT_UNDEFINED) return xt_to_string(target);
+    int precision = xt_to_int32(argv[0]);
+    if (precision < 1) precision = 1;
+    if (precision > 100) precision = 100;
+    char buffer[512];
+    snprintf(buffer, sizeof(buffer), "%.*g", precision, n);
+    return xt_string_from_cstr(buffer);
+  }
+  if (strcmp(method, "toExponential") == 0) {
+    int precision = argc >= 1 ? xt_to_int32(argv[0]) : 6;
+    if (precision < 0) precision = 0;
+    if (precision > 100) precision = 100;
+    char buffer[512];
+    snprintf(buffer, sizeof(buffer), "%.*e", precision, n);
+    return xt_string_from_cstr(buffer);
+  }
+  if (strcmp(method, "toString") == 0) {
+    int radix = argc >= 1 ? xt_to_int32(argv[0]) : 10;
+    return xt_number_to_radix(n, radix);
+  }
+  if (strcmp(method, "valueOf") == 0) return target;
+  *handled = 0;
+  return XT_UNDEFINED;
+}

package/runtime/xt_stdlib2/objects.inc

@@ -0,0 +1,41 @@
+xt_value xt_ext_object_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
+  *handled = 1;
+  if (strcmp(method, "hasOwnProperty") == 0) return xt_object_has_own(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "toString") == 0) return xt_string_from_cstr("[object Object]");
+  if (strcmp(method, "valueOf") == 0) return target;
+  *handled = 0;
+  return XT_UNDEFINED;
+}
+
+/* -- Object statics ------------------------------------------------------- */
+
+xt_value xt_object_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, "keys") == 0) return xt_object_keys(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "values") == 0) return xt_object_values(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "entries") == 0) return xt_object_entries(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "assign") == 0) return xt_object_assign(argc, argv);
+  if (strcmp(fn, "freeze") == 0) return xt_object_freeze(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "isFrozen") == 0) return xt_bool(xt_object_is_frozen(xt_arg_at(argc, argv, 0)));
+  if (strcmp(fn, "fromEntries") == 0) return xt_object_from_entries(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "getPrototypeOf") == 0) return xt_object_get_prototype(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "setPrototypeOf") == 0) return xt_object_set_prototype(xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  if (strcmp(fn, "hasOwn") == 0) return xt_object_has_own(xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  if (strcmp(fn, "is") == 0) {
+    xt_value a = xt_arg_at(argc, argv, 0);
+    xt_value b = xt_arg_at(argc, argv, 1);
+    if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) {
+      double x = xt_to_double(a), y = xt_to_double(b);
+      if (isnan(x) && isnan(y)) return XT_TRUE;
+      if (x == 0 && y == 0) return xt_bool(signbit(x) == signbit(y));
+      return xt_bool(x == y);
+    }
+    return xt_seq(a, b);
+  }
+  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_UNDEFINED;
+}

package/runtime/xt_stdlib2/regexp-match.inc

@@ -0,0 +1,204 @@
+/* Compile `regexp` and search `input` starting at byte offset `start`.
+ * Returns 1 and fills `matchStart`/`matchEnd` (absolute offsets into `input`)
+ * when a match is found, otherwise 0. */
+
+static int xt_regex_hex_digit(char c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+/* JavaScript regexes use escapes POSIX ERE does not understand (`\r`, `\n`,
+ * `\d`, `\w`, `\s`, `(?:...)`, ...). Rewrite the common ones into their POSIX
+ * equivalents before handing the pattern to the engine. Returns a malloc'd,
+ * NUL-terminated string the caller must free. */
+static char *xt_regexp_translate_js(const char *pattern) {
+  size_t length = strlen(pattern);
+  size_t capacity = length * 16 + 16;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t written = 0;
+  for (size_t i = 0; i < length; i++) {
+    char c = pattern[i];
+    const char *replacement = NULL;
+    char literal = 0;
+    int consume = 0;
+    if (c == '\\') {
+      char next = (i + 1 < length) ? pattern[i + 1] : '\0';
+      switch (next) {
+        case 'r': literal = '\r'; consume = 1; break;
+        case 'n': literal = '\n'; consume = 1; break;
+        case 't': literal = '\t'; consume = 1; break;
+        case 'f': literal = '\f'; consume = 1; break;
+        case 'v': literal = '\v'; consume = 1; break;
+        case 'd': replacement = "[0-9]"; consume = 1; break;
+        case 'D': replacement = "[^0-9]"; consume = 1; break;
+        case 'w': replacement = "[A-Za-z0-9_]"; consume = 1; break;
+        case 'W': replacement = "[^A-Za-z0-9_]"; consume = 1; break;
+        case 's': replacement = "[ \t\n\r\f\v]"; consume = 1; break;
+        case 'S': replacement = "[^ \t\n\r\f\v]"; consume = 1; break;
+        case 'x': {
+          int hi = (i + 2 < length) ? xt_regex_hex_digit(pattern[i + 2]) : -1;
+          int lo = (i + 3 < length) ? xt_regex_hex_digit(pattern[i + 3]) : -1;
+          if (hi >= 0 && lo >= 0) { literal = (char)(hi * 16 + lo); consume = 3; }
+          break;
+        }
+        default: break;
+      }
+    } else if (c == '(' && i + 2 < length && pattern[i + 1] == '?' && pattern[i + 2] == ':') {
+      /* POSIX ERE has no non-capturing groups; a capturing group matches the
+       * same text, only the capture bookkeeping differs. */
+      literal = '(';
+      consume = 2;
+    }
+    if (replacement) {
+      size_t addition = strlen(replacement);
+      if (written + addition + 1 > capacity) { capacity = (written + addition) * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      memcpy(out + written, replacement, addition);
+      written += addition;
+    } else if (consume || literal) {
+      if (written + 2 > capacity) { capacity = capacity * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      out[written++] = literal;
+    } else {
+      if (written + 2 > capacity) { capacity = capacity * 2 + 16; out = (char *)realloc(out, capacity); if (!out) abort(); }
+      out[written++] = c;
+    }
+    i += (size_t)consume;
+  }
+  out[written] = '\0';
+  return out;
+}
+
+int xt_regexp_find(xt_value regexpValue, xt_value input, int32_t start, int32_t *matchStart, int32_t *matchEnd) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(regexpValue);
+  xt_string *pattern = xt_as_string(regexp->source);
+  xt_string *text = xt_as_string(xt_to_string(input));
+  if (!pattern || !text) return 0;
+  if (start < 0) start = 0;
+  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);
+  if (!translated) return 0;
+  regex_t compiled;
+  if (regcomp(&compiled, translated, flags) != 0) {
+    free(translated);
+    return 0;
+  }
+  free(translated);
+  regmatch_t match;
+  match.rm_so = 0;
+  match.rm_eo = 0;
+  int ok = regexec(&compiled, text->data + start, 1, &match, 0) == 0;
+  regfree(&compiled);
+  if (!ok) return 0;
+  if (matchStart) *matchStart = start + (int32_t)match.rm_so;
+  if (matchEnd) *matchEnd = start + (int32_t)match.rm_eo;
+  return 1;
+}
+
+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;
+  return 0;
+}
+
+static xt_value xt_regexp_test(xt_value target, xt_value input) {
+  return xt_bool(xt_regexp_find(target, input, 0, NULL, NULL));
+}
+
+/* JavaScript-style match object: `[0]` is the matched text, `index` is the
+ * match offset and `input` is the searched string. */
+xt_value xt_regexp_exec(xt_value target, xt_value input) {
+  int32_t start = 0;
+  int32_t end = 0;
+  if (!xt_regexp_find(target, input, 0, &start, &end)) return XT_NULL;
+  xt_value textValue = xt_to_string(input);
+  xt_string *text = xt_as_string(textValue);
+  xt_value out = xt_object_new();
+  xt_object_set(out, xt_string_from_cstr("0"), xt_string_new(text->data + start, (int64_t)(end - start)));
+  xt_object_set(out, xt_string_from_cstr("index"), xt_number((double)start));
+  xt_object_set(out, xt_string_from_cstr("input"), textValue);
+  xt_object_set(out, xt_string_from_cstr("length"), xt_number(1));
+  return out;
+}
+
+/* `String.prototype.replace`/`replaceAll` with a RegExp search value. */
+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;
+  xt_string *replacement = xt_as_string(xt_to_string(replacementValue));
+  if (!replacement) return value;
+  int global = xt_regexp_is_global(regexpValue);
+  size_t capacity = text->length + replacement->length + 16;
+  char *out = (char *)malloc(capacity);
+  if (!out) abort();
+  size_t length = 0;
+  int32_t cursor = 0;
+  int replaced = 0;
+  for (;;) {
+    int32_t start = 0;
+    int32_t end = 0;
+    if (!xt_regexp_find(regexpValue, value, cursor, &start, &end)) break;
+    size_t prefix = (size_t)(start - cursor);
+    size_t needed = length + prefix + replacement->length + 2;
+    if (needed > capacity) {
+      capacity = needed * 2;
+      out = (char *)realloc(out, capacity);
+      if (!out) abort();
+    }
+    memcpy(out + length, text->data + cursor, prefix);
+    length += prefix;
+    memcpy(out + length, replacement->data, replacement->length);
+    length += replacement->length;
+    replaced = 1;
+    if (end > start) {
+      cursor = end;
+    } else {
+      /* Zero-width match: copy one byte so the scan always progresses. */
+      if (cursor >= (int32_t)text->length) break;
+      out[length++] = text->data[cursor++];
+    }
+    if (!global) break;
+  }
+  if (!replaced) {
+    free(out);
+    return value;
+  }
+  size_t tail = text->length - (size_t)cursor;
+  if (length + tail + 1 > capacity) {
+    capacity = length + tail + 1;
+    out = (char *)realloc(out, capacity);
+    if (!out) abort();
+  }
+  memcpy(out + length, text->data + cursor, tail);
+  length += tail;
+  xt_value result = xt_string_new(out, (int64_t)length);
+  free(out);
+  return result;
+}
+
+/* Property access (`re.source`, `re.flags`, `re.global`, ...). */
+xt_value xt_regexp_get_property(xt_value target, xt_value key) {
+  xt_regexp *regexp = (xt_regexp *)XT_GET_PTR(target);
+  if (!XT_IS_STRING(key)) return XT_UNDEFINED;
+  xt_string *k = xt_as_string(key);
+  xt_string *f = xt_as_string(regexp->flags);
+  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 (flag) {
+    if (f) for (uint32_t i = 0; i < f->length; i++) if (f->data[i] == flag) return XT_TRUE;
+    return XT_FALSE;
+  }
+  return XT_UNDEFINED;
+}

package/runtime/xt_stdlib2/regexp.inc

@@ -0,0 +1,20 @@
+/* -- RegExp (POSIX ERE subset) -------------------------------------------- */
+
+int xt_is_regexp(xt_value value) {
+  return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_REGEXP;
+}
+
+xt_value xt_regexp_ctor(int32_t argc, xt_value *argv) {
+  xt_regexp *regexp = (xt_regexp *)xt_alloc(sizeof(xt_regexp), XT_OBJECT_KIND_REGEXP);
+  xt_value source = xt_arg_at(argc, argv, 0);
+  xt_value flags = xt_arg_at(argc, argv, 1);
+  if (XT_IS_OBJECT(source) && ((xt_object *)XT_GET_PTR(source))->header.kind == XT_OBJECT_KIND_REGEXP) {
+    xt_regexp *other = (xt_regexp *)XT_GET_PTR(source);
+    regexp->source = other->source;
+    regexp->flags = flags == XT_UNDEFINED ? other->flags : xt_to_string(flags);
+  } else {
+    regexp->source = source == XT_UNDEFINED ? xt_string_from_cstr("(?:)") : xt_to_string(source);
+    regexp->flags = flags == XT_UNDEFINED ? xt_string_from_cstr("") : xt_to_string(flags);
+  }
+  return XT_FROM_PTR(XT_TAG_OBJECT, regexp);
+}

package/runtime/xt_stdlib2/set.inc

@@ -0,0 +1,105 @@
+/* -- Set ------------------------------------------------------------------ */
+
+int xt_is_set(xt_value value) {
+  return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_SET;
+}
+
+int32_t xt_set_size(xt_value value) {
+  if (!xt_is_set(value)) return 0;
+  return (int32_t)((xt_set_object *)XT_GET_PTR(value))->count;
+}
+
+/* -- for...of iteration --------------------------------------------------- */
+
+/* `for...of` lowers to a length check plus an index lookup. Arrays and strings
+   index directly; Maps yield `[key, value]` pairs and Sets yield their values. */
+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));
+  return xt_array_length(value);
+}
+
+xt_value xt_iter_value(xt_value value, xt_value index) {
+  if (xt_is_map(value)) {
+    xt_map *map = (xt_map *)XT_GET_PTR(value);
+    int64_t i = (int64_t)xt_to_int32(index);
+    if (i < 0 || i >= (int64_t)map->count) return XT_UNDEFINED;
+    xt_value pair = xt_array_new(0, NULL);
+    xt_array_push(pair, map->keys[i]);
+    xt_array_push(pair, map->values[i]);
+    return pair;
+  }
+  if (xt_is_set(value)) {
+    xt_set_object *set = (xt_set_object *)XT_GET_PTR(value);
+    int64_t i = (int64_t)xt_to_int32(index);
+    if (i < 0 || i >= (int64_t)set->count) return XT_UNDEFINED;
+    return set->values[i];
+  }
+  return xt_get(value, index);
+}
+
+static int32_t xt_set_index(xt_set_object *set, xt_value key) {
+  for (uint32_t i = 0; i < set->count; i++) if (xt_value_equals(set->values[i], key)) return (int32_t)i;
+  return -1;
+}
+
+static void xt_set_add(xt_set_object *set, xt_value value) {
+  if (xt_set_index(set, value) >= 0) return;
+  if (set->count >= set->capacity) {
+    uint32_t capacity = set->capacity == 0 ? 8 : set->capacity * 2;
+    set->values = (xt_value *)realloc(set->values, sizeof(xt_value) * capacity);
+    if (!set->values) abort();
+    set->capacity = capacity;
+  }
+  set->values[set->count++] = value;
+}
+
+static int xt_set_delete(xt_set_object *set, xt_value value) {
+  int32_t index = xt_set_index(set, value);
+  if (index < 0) return 0;
+  for (uint32_t i = (uint32_t)index + 1; i < set->count; i++) set->values[i - 1] = set->values[i];
+  set->count--;
+  return 1;
+}
+
+xt_value xt_set_ctor(int32_t argc, xt_value *argv) {
+  xt_set_object *set = (xt_set_object *)xt_alloc(sizeof(xt_set_object), XT_OBJECT_KIND_SET);
+  set->values = NULL; set->count = 0; set->capacity = 0;
+  xt_value iterable = xt_arg_at(argc, argv, 0);
+  if (XT_IS_ARRAY(iterable)) {
+    xt_array *array = xt_as_array(iterable);
+    for (uint32_t i = 0; i < array->length; i++) xt_set_add(set, array->items[i]);
+  }
+  return XT_FROM_PTR(XT_TAG_OBJECT, set);
+}
+
+static xt_value xt_set_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
+  *handled = 1;
+  xt_set_object *set = (xt_set_object *)XT_GET_PTR(target);
+  if (strcmp(method, "add") == 0) { xt_set_add(set, xt_arg_at(argc, argv, 0)); return target; }
+  if (strcmp(method, "has") == 0) return xt_bool(xt_set_index(set, xt_arg_at(argc, argv, 0)) >= 0);
+  if (strcmp(method, "delete") == 0) return xt_bool(xt_set_delete(set, xt_arg_at(argc, argv, 0)));
+  if (strcmp(method, "clear") == 0) { set->count = 0; return XT_UNDEFINED; }
+  if (strcmp(method, "forEach") == 0) {
+    xt_value fn = xt_arg_at(argc, argv, 0);
+    for (uint32_t i = 0; i < set->count; i++) { xt_value args[3] = {set->values[i], set->values[i], target}; xt_closure_call(fn, 3, args); }
+    return XT_UNDEFINED;
+  }
+  if (strcmp(method, "values") == 0 || strcmp(method, "keys") == 0) {
+    xt_value out = xt_array_new(0, NULL);
+    for (uint32_t i = 0; i < set->count; i++) xt_array_push(out, set->values[i]);
+    return out;
+  }
+  if (strcmp(method, "entries") == 0) {
+    xt_value out = xt_array_new(0, NULL);
+    for (uint32_t i = 0; i < set->count; i++) {
+      xt_value pair = xt_array_new(0, NULL);
+      xt_array_push(pair, set->values[i]);
+      xt_array_push(pair, set->values[i]);
+      xt_array_push(out, pair);
+    }
+    return out;
+  }
+  *handled = 0;
+  return XT_UNDEFINED;
+}

package/runtime/xt_stdlib2/strings.inc

@@ -0,0 +1,94 @@
+/* -- string methods ------------------------------------------------------- */
+
+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));
+  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];
+  }
+  return XT_FROM_PTR(XT_TAG_STRING, out);
+}
+
+static xt_value xt_string_trim_side(xt_value value, int start) {
+  xt_string *s = xt_as_string(value);
+  if (!s) return value;
+  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);
+}
+
+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 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);
+}
+
+static xt_value xt_string_replace_all(xt_value value, xt_value searchValue, xt_value replacementValue) {
+  if (xt_is_regexp(searchValue)) return xt_regexp_replace(value, searchValue, replacementValue);
+  xt_string *s = xt_as_string(value);
+  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;
+  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 (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);
+      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++];
+    }
+  }
+  xt_value result = xt_string_new(out, length);
+  free(out);
+  return result;
+}
+
+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));
+  if (strcmp(method, "padStart") == 0) return xt_string_pad(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1), 1);
+  if (strcmp(method, "padEnd") == 0) return xt_string_pad(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1), 0);
+  if (strcmp(method, "trimStart") == 0) return xt_string_trim_side(target, 1);
+  if (strcmp(method, "trimEnd") == 0) return xt_string_trim_side(target, 0);
+  if (strcmp(method, "replaceAll") == 0) return xt_string_replace_all(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  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 : "");
+    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]);
+  }
+  if (strcmp(method, "valueOf") == 0 || strcmp(method, "toString") == 0) return target;
+  *handled = 0;
+  return XT_UNDEFINED;
+}