xbintsc 0.3.3 → 0.3.5

package/runtime/xt_stdlib2/arrays.inc

@@ -33,33 +33,63 @@ static xt_value xt_array_quantifier(xt_value value, xt_value fn, int every) {
   return xt_bool(every ? 1 : 0);
 }
 
-static int xt_array_compare_values(xt_value a, xt_value b) {
-  if (xt_truthy(xt_gt(a, b))) return 1;
-  if (xt_truthy(xt_lt(a, b))) return -1;
+/*
+ * Default `Array.prototype.sort` comparator. Per spec the elements are
+ * converted to strings and compared by UTF-16 code unit; `undefined` always
+ * sorts last and holes are handled by the caller. Because our strings are
+ * UTF-8, a byte-wise compare matches UTF-16 ordering for the BMP (and differs
+ * only for supplementary vs. U+E000..U+FFFF code points).
+ */
+static int xt_array_default_compare(xt_value a, xt_value b) {
+  if (a == XT_UNDEFINED) return b == XT_UNDEFINED ? 0 : 1;
+  if (b == XT_UNDEFINED) return -1;
+  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;
+  if (cmp != 0) return cmp < 0 ? -1 : 1;
+  if (sa->length == sb->length) return 0;
+  return sa->length < sb->length ? -1 : 1;
+}
+
+static int xt_array_sort_compare(xt_value fn, int hasFn, xt_value a, xt_value b) {
+  if (!hasFn) return xt_array_default_compare(a, b);
+  xt_value args[2] = {a, b};
+  double result = xt_to_number(xt_closure_call(fn, 2, args));
+  if (result < 0) return -1;
+  if (result > 0) return 1;
   return 0;
 }
 
+/* Stable bottom-up merge sort: O(n log n) and never reorders equal keys. */
+static void xt_array_merge_sort(xt_value *items, xt_value *scratch, uint32_t length, xt_value fn, int hasFn) {
+  for (uint32_t width = 1; width < length; width *= 2) {
+    for (uint32_t lo = 0; lo < length; lo += 2 * width) {
+      uint32_t mid = lo + width < length ? lo + width : length;
+      uint32_t hi = lo + 2 * width < length ? lo + 2 * width : length;
+      uint32_t i = lo, j = mid, k = lo;
+      while (i < mid && j < hi) {
+        if (xt_array_sort_compare(fn, hasFn, items[j], items[i]) < 0) scratch[k++] = items[j++];
+        else scratch[k++] = items[i++];
+      }
+      while (i < mid) scratch[k++] = items[i++];
+      while (j < hi) scratch[k++] = items[j++];
+      for (k = lo; k < hi; k++) items[k] = scratch[k];
+    }
+  }
+}
+
 static xt_value xt_array_sort(xt_value value, xt_value fn) {
   xt_array *array = xt_as_array(value);
   if (!array || array->length < 2) return value;
   int hasFn = XT_IS_FUNCTION(fn);
-  for (uint32_t i = 1; i < array->length; i++) {
-    xt_value key = array->items[i];
-    int32_t j = (int32_t)i - 1;
-    while (j >= 0) {
-      int cmp;
-      if (hasFn) {
-        xt_value args[2] = {array->items[j], key};
-        cmp = (int)xt_to_number(xt_closure_call(fn, 2, args));
-      } else {
-        cmp = xt_array_compare_values(array->items[j], key);
-      }
-      if (cmp <= 0) break;
-      array->items[j + 1] = array->items[j];
-      j--;
-    }
-    array->items[j + 1] = key;
+  xt_value *scratch = (xt_value *)malloc(sizeof(xt_value) * array->length);
+  if (!scratch) {
+    xt_throw(xt_string_from_cstr("RangeError: out of memory in Array.prototype.sort"));
+    return value;
   }
+  xt_array_merge_sort(array->items, scratch, array->length, fn, hasFn);
+  free(scratch);
   return value;
 }
 
@@ -130,6 +160,78 @@ static xt_value xt_array_copy_within(xt_value value, xt_value targetValue, xt_va
   return value;
 }
 
+static xt_value xt_array_splice(xt_value value, int32_t argc, xt_value *argv) {
+  xt_array *array = xt_as_array(value);
+  if (!array) return XT_UNDEFINED;
+  int32_t len = (int32_t)array->length;
+  int32_t start = argc >= 1 ? xt_to_int32(argv[0]) : 0;
+  if (start < 0) start += len;
+  if (start < 0) start = 0;
+  if (start > len) start = len;
+  int32_t deleteCount;
+  if (argc < 2) {
+    deleteCount = len - start;
+  } else {
+    deleteCount = xt_to_int32(argv[1]);
+    if (deleteCount < 0) deleteCount = 0;
+    if (deleteCount > len - start) deleteCount = len - start;
+  }
+  int32_t insertCount = argc > 2 ? argc - 2 : 0;
+  xt_value removed = xt_array_new(deleteCount, deleteCount > 0 ? array->items + start : NULL);
+  int32_t newLength = len - deleteCount + insertCount;
+  xt_array_reserve(array, (uint32_t)(newLength > 0 ? newLength : 0));
+  if (insertCount != deleteCount) {
+    memmove(array->items + start + insertCount, array->items + start + deleteCount,
+            sizeof(xt_value) * (size_t)(len - start - deleteCount));
+  }
+  for (int32_t i = 0; i < insertCount; i++) array->items[start + i] = argv[2 + i];
+  array->length = (uint32_t)newLength;
+  return removed;
+}
+
+/* Copy the own elements of `value` into a fresh array. */
+static xt_value xt_array_copy(xt_value value) {
+  xt_value out = xt_array_new(0, NULL);
+  xt_array *array = xt_as_array(value);
+  if (!array) return out;
+  for (uint32_t i = 0; i < array->length; i++) xt_array_push(out, array->items[i]);
+  return out;
+}
+
+static xt_value xt_array_to_reversed(xt_value value) {
+  xt_value copy = xt_array_copy(value);
+  xt_array *array = xt_as_array(copy);
+  for (uint32_t i = 0; i + 1 < array->length - i; i++) {
+    xt_value tmp = array->items[i];
+    array->items[i] = array->items[array->length - 1 - i];
+    array->items[array->length - 1 - i] = tmp;
+  }
+  return copy;
+}
+
+static xt_value xt_array_to_sorted(xt_value value, xt_value fn) {
+  return xt_array_sort(xt_array_copy(value), fn);
+}
+
+static xt_value xt_array_to_spliced(xt_value value, int32_t argc, xt_value *argv) {
+  xt_value copy = xt_array_copy(value);
+  xt_array_splice(copy, argc, argv);
+  return copy;
+}
+
+static xt_value xt_array_with(xt_value value, xt_value indexValue, xt_value newValue) {
+  xt_value copy = xt_array_copy(value);
+  xt_array *array = xt_as_array(copy);
+  int32_t index = xt_to_int32(indexValue);
+  if (index < 0) index += (int32_t)array->length;
+  if (index < 0 || index >= (int32_t)array->length) {
+    xt_throw(xt_add(xt_string_from_cstr("RangeError: Invalid index : "), xt_to_string(indexValue)));
+    return copy;
+  }
+  array->items[index] = newValue;
+  return copy;
+}
+
 xt_value xt_ext_array_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
   *handled = 1;
   if (strcmp(method, "at") == 0) return xt_array_at(target, xt_arg_at(argc, argv, 0));
@@ -151,6 +253,11 @@ xt_value xt_ext_array_method(xt_value target, const char *method, int32_t argc,
   if (strcmp(method, "lastIndexOf") == 0) return xt_array_last_index_of(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "fill") == 0) return xt_array_fill(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1), xt_arg_at(argc, argv, 2));
   if (strcmp(method, "copyWithin") == 0) return xt_array_copy_within(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1), xt_arg_at(argc, argv, 2));
+  if (strcmp(method, "splice") == 0) return xt_array_splice(target, argc, argv);
+  if (strcmp(method, "toReversed") == 0) return xt_array_to_reversed(target);
+  if (strcmp(method, "toSorted") == 0) return xt_array_to_sorted(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "toSpliced") == 0) return xt_array_to_spliced(target, argc, argv);
+  if (strcmp(method, "with") == 0) return xt_array_with(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "reduceRight") == 0) {
     xt_array *array = xt_as_array(target);
     if (!array) return XT_UNDEFINED;

package/runtime/xt_stdlib2/date.inc

@@ -40,18 +40,25 @@ xt_value xt_date_static(xt_value name, int32_t argc, xt_value *argv) {
 }
 
 static xt_value xt_date_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
+  (void)argc;
+  (void)argv;
   *handled = 1;
   xt_date *date = (xt_date *)XT_GET_PTR(target);
+  if (strcmp(method, "getTime") == 0 || strcmp(method, "valueOf") == 0) return xt_number(date->time);
   time_t seconds = (time_t)(date->time / 1000.0);
   struct tm tm;
-  xt_gmtime_r(&seconds, &tm);
-  if (strcmp(method, "getTime") == 0 || strcmp(method, "valueOf") == 0) return xt_number(date->time);
   const char *name = method;
   char utc[32];
+  int isUtc = 0;
   if (strncmp(method, "getUTC", 6) == 0) {
     snprintf(utc, sizeof(utc), "get%s", method + 6);
     name = utc;
+    isUtc = 1;
   }
+  /* Bare getters and `toString` report local time; `getUTC*` and
+   * `toISOString` report UTC. */
+  if (isUtc || strcmp(method, "toISOString") == 0) xt_gmtime_r(&seconds, &tm);
+  else xt_localtime_r(&seconds, &tm);
   if (strcmp(name, "getFullYear") == 0) return xt_number(tm.tm_year + 1900);
   if (strcmp(name, "getMonth") == 0) return xt_number(tm.tm_mon);
   if (strcmp(name, "getDate") == 0) return xt_number(tm.tm_mday);

package/runtime/xt_stdlib2/error.inc

@@ -1,21 +1,171 @@
-xt_value xt_error_ctor(int32_t argc, xt_value *argv) {
+/* ------------------------------------------------------------------------- */
+/* Error family: prototype chain, first-class constructors and formatting.    */
+
+/* Every constructor in the Error family shares one implementation; the name
+ * is what distinguishes them. Prototypes chain `TypeError.prototype` (etc.)
+ * to `Error.prototype`, so `instanceof Error` succeeds for every member. */
+static const char *const XT_ERROR_NAMES[] = {
+    "Error",     "TypeError", "RangeError",  "SyntaxError",
+    "ReferenceError", "EvalError", "URIError", "AggregateError",
+};
+
+static int xt_error_is_family(const char *name) {
+  for (size_t i = 0; i < sizeof(XT_ERROR_NAMES) / sizeof(XT_ERROR_NAMES[0]); i++) {
+    if (strcmp(name, XT_ERROR_NAMES[i]) == 0) return 1;
+  }
+  return 0;
+}
+
+static xt_value xt_error_root_proto = XT_UNDEFINED;
+
+static xt_value xt_error_proto_for(const char *name) {
+  if (!XT_IS_OBJECT(xt_error_root_proto)) {
+    xt_error_root_proto = xt_object_new();
+    xt_object_set(xt_error_root_proto, xt_string_from_cstr("name"),
+                  xt_string_from_cstr("Error"));
+    xt_object_set(xt_error_root_proto, xt_string_from_cstr("message"),
+                  xt_string_from_cstr(""));
+  }
+  if (strcmp(name, "Error") == 0) return xt_error_root_proto;
+  xt_value key = xt_string_from_cstr(name);
+  xt_value registry = xt_object_get(xt_error_root_proto, xt_string_from_cstr("__children"));
+  if (!XT_IS_OBJECT(registry)) {
+    registry = xt_object_new();
+    xt_object_set(xt_error_root_proto, xt_string_from_cstr("__children"), registry);
+  }
+  xt_value existing = xt_object_get(registry, key);
+  if (XT_IS_OBJECT(existing)) return existing;
+  xt_value proto = xt_object_new();
+  xt_object_set_prototype(proto, xt_error_root_proto);
+  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);
+  return proto;
+}
+
+xt_value xt_error_prototype(xt_value nameValue) {
+  const char *name = XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : "Error";
+  if (!xt_error_is_family(name)) name = "Error";
+  return xt_error_proto_for(name);
+}
+
+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();
-  xt_value name = xt_arg_at(argc, argv, 1);
-  xt_value message = xt_arg_at(argc, argv, 0);
-  xt_object_set(error, xt_string_from_cstr("name"),
-                name == XT_UNDEFINED ? xt_string_from_cstr("Error") : name);
+  ((xt_object *)XT_GET_PTR(error))->header.kind = XT_OBJECT_KIND_ERROR;
+  xt_object_set_prototype(error, xt_error_proto_for(name));
+  xt_value message;
+  if (strcmp(name, "AggregateError") == 0) {
+    xt_value errors = xt_arg_at(argc, argv, 0);
+    xt_object_set(error, xt_string_from_cstr("errors"),
+                  errors == XT_UNDEFINED ? xt_array_new(0, NULL) : errors);
+    message = xt_arg_at(argc, argv, 1);
+  } else {
+    message = xt_arg_at(argc, argv, 0);
+  }
+  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);
   return error;
 }
 
-/* `super(message)` inside a subclass of the builtin `Error`: initialize the
- * already-allocated instance instead of creating a fresh object. */
-xt_value xt_error_init(xt_value thisValue, int32_t argc, xt_value *argv) {
-  xt_value name = xt_arg_at(argc, argv, 1);
-  xt_value message = xt_arg_at(argc, argv, 0);
-  xt_object_set(thisValue, xt_string_from_cstr("name"),
-                name == XT_UNDEFINED ? xt_string_from_cstr("Error") : name);
+static xt_value xt_error_ctor_invoke(xt_value thisValue, xt_value env, int32_t argc,
+                                     xt_value *argv) {
+  (void)thisValue;
+  xt_value name = xt_closure_env(env, 0);
+  return xt_make_error(xt_string_data(name), argc, argv);
+}
+
+/* The first-class value of a family constructor (used by `instanceof`,
+ * `typeof`, and `class X extends Error`). Cached on the prototype. */
+xt_value xt_error_constructor(xt_value nameValue) {
+  const char *name = XT_IS_STRING(nameValue) ? xt_string_data(nameValue) : "Error";
+  if (!xt_error_is_family(name)) name = "Error";
+  xt_value proto = xt_error_proto_for(name);
+  xt_value key = xt_string_from_cstr("__ctor");
+  /* Own-property lookup only: a prototype walk would find `Error`'s
+   * constructor (stored on the root prototype) for every child. */
+  xt_property *existing =
+      xt_object_find_property((xt_object *)XT_GET_PTR(proto), key);
+  if (existing && XT_IS_FUNCTION(existing->value)) return existing->value;
+  xt_value env[1];
+  env[0] = xt_string_from_cstr(name);
+  xt_value closure = xt_closure_new((void *)xt_error_ctor_invoke, 1, env);
+  xt_function_set_prototype(closure, proto);
+  xt_function_set_metadata(closure, env[0], 1);
+  xt_object_set(proto, key, closure);
+  return closure;
+}
+
+xt_value xt_error_to_string(xt_value error) {
+  xt_value name = xt_object_get(error, xt_string_from_cstr("name"));
+  xt_value message = xt_object_get(error, xt_string_from_cstr("message"));
+  xt_value nameStr = name == XT_UNDEFINED ? xt_string_from_cstr("Error") : xt_to_string(name);
+  xt_value messageStr =
+      message == XT_UNDEFINED ? xt_string_from_cstr("") : xt_to_string(message);
+  xt_string *ns = xt_as_string(nameStr);
+  xt_string *ms = xt_as_string(messageStr);
+  if (ns->length == 0) return messageStr;
+  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);
+  buffer[ns->length] = ':';
+  buffer[ns->length + 1] = ' ';
+  memcpy(buffer + ns->length + 2, ms->data, ms->length);
+  buffer[total] = '\0';
+  xt_value result = xt_string_new(buffer, total);
+  free(buffer);
+  return result;
+}
+
+xt_value xt_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("Error", argc, argv);
+}
+
+xt_value xt_type_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("TypeError", argc, argv);
+}
+
+xt_value xt_range_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("RangeError", argc, argv);
+}
+
+xt_value xt_syntax_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("SyntaxError", argc, argv);
+}
+
+xt_value xt_reference_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("ReferenceError", argc, argv);
+}
+
+xt_value xt_eval_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("EvalError", argc, argv);
+}
+
+xt_value xt_uri_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("URIError", argc, argv);
+}
+
+xt_value xt_aggregate_error_ctor(int32_t argc, xt_value *argv) {
+  return xt_make_error("AggregateError", 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`, ...). */
+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";
+  xt_object_set(thisValue, xt_string_from_cstr("name"), xt_string_from_cstr(name));
+  xt_value message;
+  if (strcmp(name, "AggregateError") == 0) {
+    xt_object_set(thisValue, xt_string_from_cstr("errors"), xt_arg_at(argc, argv, 0));
+    message = xt_arg_at(argc, argv, 1);
+  } 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);
   return thisValue;

package/runtime/xt_stdlib2/helpers.inc

@@ -9,9 +9,13 @@ static time_t xt_timegm(struct tm *tm) { return (time_t)_mkgmtime64(tm); }
 static struct tm *xt_gmtime_r(const time_t *timer, struct tm *buf) {
   return gmtime_s(buf, timer) == 0 ? buf : NULL;
 }
+static struct tm *xt_localtime_r(const time_t *timer, struct tm *buf) {
+  return localtime_s(buf, timer) == 0 ? buf : NULL;
+}
 #else
 static time_t xt_timegm(struct tm *tm) { return timegm(tm); }
 static struct tm *xt_gmtime_r(const time_t *timer, struct tm *buf) { return gmtime_r(timer, buf); }
+static struct tm *xt_localtime_r(const time_t *timer, struct tm *buf) { return localtime_r(timer, buf); }
 #endif
 
 int xt_value_equals(xt_value a, xt_value b) {

package/runtime/xt_stdlib2/json.inc

@@ -148,24 +148,35 @@ static void xt_json_stringify_array(xt_value value, int indent, int depth, xt_va
 static void xt_json_stringify_object(xt_value value, int indent, int depth, xt_value *out) {
   xt_value keys = xt_object_keys(value);
   xt_array *array = xt_as_array(keys);
-  if (!array || array->length == 0) { *out = xt_add(*out, xt_string_from_cstr("{}")); return; }
+  if (!array) { *out = xt_add(*out, xt_string_from_cstr("{}")); return; }
+  int any = 0;
+  for (uint32_t i = 0; i < array->length; i++) {
+    xt_value item = xt_object_get(value, array->items[i]);
+    if (item != XT_UNDEFINED && !XT_IS_FUNCTION(item) && !xt_is_symbol(item)) { any = 1; break; }
+  }
+  if (!any) { *out = xt_add(*out, xt_string_from_cstr("{}")); return; }
   *out = xt_add(*out, xt_string_from_cstr("{"));
+  int written = 0;
   for (uint32_t i = 0; i < array->length; i++) {
-    if (i > 0) *out = xt_add(*out, xt_string_from_cstr(","));
-    xt_json_indent(out, indent, depth + 1);
     xt_value key = array->items[i];
+    xt_value item = xt_object_get(value, key);
+    /* `undefined`, functions and symbols are omitted from objects. */
+    if (item == XT_UNDEFINED || XT_IS_FUNCTION(item) || xt_is_symbol(item)) continue;
+    if (written > 0) *out = xt_add(*out, xt_string_from_cstr(","));
+    written++;
+    xt_json_indent(out, indent, depth + 1);
     *out = xt_add(*out, xt_string_from_cstr("\""));
     *out = xt_add(*out, key);
     *out = xt_add(*out, xt_string_from_cstr("\":"));
     if (indent > 0) *out = xt_add(*out, xt_string_from_cstr(" "));
-    xt_json_stringify_value(xt_object_get(value, key), indent, depth + 1, out);
+    xt_json_stringify_value(item, indent, depth + 1, out);
   }
   xt_json_indent(out, indent, depth);
   *out = xt_add(*out, xt_string_from_cstr("}"));
 }
 
 static void xt_json_stringify_value(xt_value value, int indent, int depth, xt_value *out) {
-  if (value == XT_UNDEFINED || value == XT_NULL || XT_IS_FUNCTION(value)) {
+  if (value == XT_UNDEFINED || value == XT_NULL || XT_IS_FUNCTION(value) || xt_is_symbol(value)) {
     *out = xt_add(*out, xt_string_from_cstr("null"));
     return;
   }
@@ -207,7 +218,9 @@ xt_value xt_json_stringify(int32_t argc, xt_value *argv) {
   else if (XT_IS_STRING(space)) indent = (int)((xt_string *)XT_GET_PTR(space))->length;
   if (indent < 0) indent = 0;
   if (indent > 10) indent = 10;
+  xt_value value = xt_arg_at(argc, argv, 0);
+  if (value == XT_UNDEFINED || XT_IS_FUNCTION(value) || xt_is_symbol(value)) return XT_UNDEFINED;
   xt_value out = xt_string_from_cstr("");
-  xt_json_stringify_value(xt_arg_at(argc, argv, 0), indent, 0, &out);
+  xt_json_stringify_value(value, indent, 0, &out);
   return out;
 }

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

@@ -60,7 +60,7 @@ xt_value xt_string_static(xt_value name, int32_t argc, xt_value *argv) {
   }
   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 raw = xt_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++) {

package/runtime/xt_stdlib2/numbers.inc

@@ -8,7 +8,7 @@ xt_value xt_ext_number_method(xt_value target, const char *method, int32_t argc,
     if (precision < 0) precision = 0;
     if (precision > 100) precision = 100;
     char buffer[512];
-    snprintf(buffer, sizeof(buffer), "%.*f", precision, n);
+    xt_number_to_fixed(n, precision, buffer, sizeof(buffer));
     return xt_string_from_cstr(buffer);
   }
   if (strcmp(method, "toPrecision") == 0) {
@@ -17,15 +17,14 @@ xt_value xt_ext_number_method(xt_value target, const char *method, int32_t argc,
     if (precision < 1) precision = 1;
     if (precision > 100) precision = 100;
     char buffer[512];
-    snprintf(buffer, sizeof(buffer), "%.*g", precision, n);
+    xt_number_to_precision(n, precision, buffer, sizeof(buffer));
     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;
+    int precision = (argc >= 1 && argv[0] != XT_UNDEFINED) ? xt_to_int32(argv[0]) : -1;
     if (precision > 100) precision = 100;
     char buffer[512];
-    snprintf(buffer, sizeof(buffer), "%.*e", precision, n);
+    xt_number_to_exponential(n, precision, buffer, sizeof(buffer));
     return xt_string_from_cstr(buffer);
   }
   if (strcmp(method, "toString") == 0) {

package/runtime/xt_stdlib2/objects.inc

@@ -9,10 +9,39 @@ xt_value xt_ext_object_method(xt_value target, const char *method, int32_t argc,
 
 /* -- Object statics ------------------------------------------------------- */
 
+/* `Object.getOwnPropertyNames` differs from `Object.keys` only in that it also
+ * reports the non-enumerable `length` of arrays and strings. */
+static xt_value xt_object_own_property_names(xt_value value) {
+  xt_value names = xt_object_keys(value);
+  if (XT_IS_ARRAY(value) || XT_IS_STRING(value)) xt_array_push(names, xt_string_from_cstr("length"));
+  return names;
+}
+
+/* `Object.groupBy(items, fn)`: bucket each element by the key `fn` returns. */
+static xt_value xt_object_group_by(xt_value value, xt_value fn) {
+  xt_value result = xt_object_new();
+  xt_array *array = xt_as_array(value);
+  if (!array) return result;
+  for (uint32_t i = 0; i < array->length; i++) {
+    xt_value args[2] = {array->items[i], xt_number((double)i)};
+    xt_value keyString = xt_to_string(xt_closure_call(fn, 2, args));
+    xt_value group = xt_object_get(result, keyString);
+    if (!XT_IS_ARRAY(group)) {
+      group = xt_array_new(0, NULL);
+      xt_object_set(result, keyString, group);
+    }
+    xt_array_push(group, array->items[i]);
+  }
+  return result;
+}
+
 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, "getOwnPropertyNames") == 0) return xt_object_own_property_names(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "getOwnPropertySymbols") == 0) return xt_object_own_property_symbols(xt_arg_at(argc, argv, 0));
+  if (strcmp(fn, "groupBy") == 0) return xt_object_group_by(xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   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);