xbintsc 0.3.87 → 0.5.20

package/runtime/xt_stdlib/dispatch.inc

@@ -1,5 +1,16 @@
 /* -- method dispatch ------------------------------------------------------ */
 
+/* A method that no built-in table recognises must throw, exactly like a
+ * missing property called as a function in JavaScript. Returning `undefined`
+ * made typos and unimplemented APIs (e.g. `"x".normalize()`) fail silently. */
+static _Noreturn void xt_throw_no_method(const char *type, const char *method) {
+  char message[256];
+  snprintf(message, sizeof(message), "TypeError: %s has no callable method '%s'", type, method);
+  xt_value argument = xt_string_from_cstr(message);
+  xt_throw(xt_type_error_ctor(1, &argument));
+  abort();
+}
+
 static xt_value xt_array_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled) {
   *handled = 1;
   if (strcmp(method, "push") == 0) {
@@ -40,6 +51,7 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   *handled = 1;
   if (strcmp(method, "charAt") == 0) return xt_string_char_at(target, xt_arg_at(argc, argv, 0));
   if (strcmp(method, "charCodeAt") == 0) return xt_string_char_code_at(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "codePointAt") == 0) return xt_string_code_point_at_value(target, xt_arg_at(argc, argv, 0));
   if (strcmp(method, "indexOf") == 0) return xt_string_index_of(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "includes") == 0) return xt_bool(xt_truthy(xt_ne(xt_string_index_of(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1)), xt_number(-1))));
   if (strcmp(method, "slice") == 0) return xt_string_slice(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
@@ -51,8 +63,8 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   if (strcmp(method, "trim") == 0) return xt_string_trim(target);
   if (strcmp(method, "replace") == 0) return xt_string_replace(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "repeat") == 0) return xt_string_repeat(target, xt_arg_at(argc, argv, 0));
-  if (strcmp(method, "startsWith") == 0) return xt_string_starts_with(target, xt_arg_at(argc, argv, 0));
-  if (strcmp(method, "endsWith") == 0) return xt_string_ends_with(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "startsWith") == 0) return xt_string_starts_with(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  if (strcmp(method, "endsWith") == 0) return xt_string_ends_with(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "concat") == 0) return xt_string_concat_args(target, argc, argv);
   *handled = 0;
   return XT_UNDEFINED;
@@ -91,7 +103,7 @@ static xt_value xt_method_value_invoke(xt_value thisValue, xt_value env, int32_t
     snprintf(message, sizeof(message),
              "TypeError: Cannot read properties of undefined (reading '%s')",
              method ? method : "method");
-    xt_throw(xt_string_from_cstr(message));
+    xt_throw(xt_error_from_message(message));
   }
   return xt_call_method(thisValue, name, argc, argv);
 }
@@ -158,6 +170,18 @@ static const xt_method_spec XT_SET_METHODS[] = {
   {"entries", 0}, {"forEach", 1},
 };
 
+static const xt_method_spec XT_WEAKMAP_METHODS[] = {
+  {"get", 1}, {"set", 2}, {"has", 1}, {"delete", 1},
+};
+
+static const xt_method_spec XT_WEAKSET_METHODS[] = {
+  {"add", 1}, {"has", 1}, {"delete", 1},
+};
+
+static const xt_method_spec XT_WEAKREF_METHODS[] = {
+  {"deref", 0},
+};
+
 static const xt_method_spec XT_REGEXP_METHODS[] = {
   {"test", 1}, {"exec", 1}, {"toString", 0},
 };
@@ -214,6 +238,12 @@ xt_value xt_method_value(xt_value target, xt_value name) {
       known = xt_method_lookup(XT_MAP_METHODS, XT_NAME_COUNT(XT_MAP_METHODS), method, &arity);
     } else if (kind == XT_OBJECT_KIND_SET) {
       known = xt_method_lookup(XT_SET_METHODS, XT_NAME_COUNT(XT_SET_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_WEAK_MAP) {
+      known = xt_method_lookup(XT_WEAKMAP_METHODS, XT_NAME_COUNT(XT_WEAKMAP_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_WEAK_SET) {
+      known = xt_method_lookup(XT_WEAKSET_METHODS, XT_NAME_COUNT(XT_WEAKSET_METHODS), method, &arity);
+    } else if (kind == XT_OBJECT_KIND_WEAK_REF) {
+      known = xt_method_lookup(XT_WEAKREF_METHODS, XT_NAME_COUNT(XT_WEAKREF_METHODS), method, &arity);
     } else if (kind == XT_OBJECT_KIND_REGEXP) {
       known = xt_method_lookup(XT_REGEXP_METHODS, XT_NAME_COUNT(XT_REGEXP_METHODS), method, &arity);
     } else if (kind == XT_OBJECT_KIND_PROMISE) {
@@ -239,7 +269,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
    * resolve it as an ordinary property and call it with `target` as `this`. */
   if (xt_is_symbol(name)) {
     if (target == XT_UNDEFINED || target == XT_NULL) {
-      xt_throw(xt_string_from_cstr("TypeError: Cannot read properties of null (reading a Symbol)"));
+      xt_throw(xt_error_from_message("TypeError: Cannot read properties of null (reading a Symbol)"));
     }
     xt_value fn = xt_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
@@ -252,7 +282,7 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
      * `target` as `this`, instead of silently returning undefined. */
     xt_value fn = xt_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
-    xt_throw(xt_string_from_cstr("TypeError: value at computed index is not a function"));
+    xt_throw(xt_error_from_message("TypeError: value at computed index is not a function"));
     return XT_UNDEFINED;
   }
   if (target == XT_UNDEFINED || target == XT_NULL) {
@@ -260,13 +290,13 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     char message[256];
     snprintf(message, sizeof(message),
              "TypeError: Cannot read properties of %s (reading '%s')", base, method);
-    xt_throw(xt_string_from_cstr(message));
+    xt_throw(xt_error_from_message(message));
   }
   int handled = 0;
   if (xt_is_symbol(target)) {
     if (strcmp(method, "toString") == 0) return xt_symbol_to_string(target);
     if (strcmp(method, "valueOf") == 0) return target;
-    return XT_UNDEFINED;
+    xt_throw_no_method("symbol", method);
   }
   if (XT_IS_OBJECT(target)) {
     xt_object *obj = (xt_object *)XT_GET_PTR(target);
@@ -286,15 +316,23 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     if (kind != XT_OBJECT_KIND_OBJECT && kind != XT_OBJECT_KIND_FUNCTION) {
       xt_value result = xt_ext_container_method(target, method, argc, argv, &handled);
       if (handled) return result;
+      /* Containers keep their methods in dedicated C dispatch tables, but
+       * still inherit `Object.prototype` (`new Map().toString()`). */
+      xt_value inherited = xt_get(target, name);
+      if (XT_IS_FUNCTION(inherited)) return xt_call_with_this(inherited, target, argc, argv);
     }
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
     xt_value result = xt_ext_object_method(target, method, argc, argv, &handled);
     if (handled) return result;
+    /* Inherited Object.prototype methods on containers without a property bag
+     * (`new Map().toString()`, ...). */
+    xt_value inherited = xt_get(target, name);
+    if (XT_IS_FUNCTION(inherited)) return xt_call_with_this(inherited, target, argc, argv);
     {
       char message[256];
       snprintf(message, sizeof(message), "TypeError: object has no callable method '%s'", method);
-      xt_throw(xt_string_from_cstr(message));
+      xt_throw(xt_error_from_message(message));
     }
     return XT_UNDEFINED;
   }
@@ -333,6 +371,13 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     }
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
+    /* Statics of a first-class built-in constructor (`const A = Array;
+     * A.isArray(x)`). */
+    xt_value builtinStatic = xt_builtin_static_value(target, name);
+    if (builtinStatic != XT_UNDEFINED) {
+      if (XT_IS_FUNCTION(builtinStatic)) return xt_call_with_this(builtinStatic, target, argc, argv);
+      return builtinStatic;
+    }
     if (strcmp(method, "toString") == 0) {
       /* Source text is not retained; report a native-style representation. */
       xt_function *self = (xt_function *)XT_GET_PTR(target);
@@ -344,32 +389,38 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     {
       char message[256];
       snprintf(message, sizeof(message), "TypeError: function has no callable method '%s'", method);
-      xt_throw(xt_string_from_cstr(message));
+      xt_throw(xt_error_from_message(message));
     }
     return XT_UNDEFINED;
   }
   if (XT_IS_ARRAY(target)) {
     xt_value result = xt_ext_array_method(target, method, argc, argv, &handled);
     if (handled) return result;
-    return xt_array_method(target, method, argc, argv, &handled);
+    result = xt_array_method(target, method, argc, argv, &handled);
+    if (handled) return result;
+    xt_throw_no_method("array", method);
   }
   if (XT_IS_STRING(target)) {
     xt_value result = xt_ext_string_method(target, method, argc, argv, &handled);
     if (handled) return result;
-    return xt_string_method(target, method, argc, argv, &handled);
+    result = xt_string_method(target, method, argc, argv, &handled);
+    if (handled) return result;
+    xt_throw_no_method("string", method);
   }
   if (XT_IS_BIGINT(target)) {
     xt_value result = xt_bigint_method(target, method, argc, argv, &handled);
     if (handled) return result;
+    xt_throw_no_method("bigint", method);
   }
   if (XT_IS_NUMBER(target)) {
     xt_value result = xt_ext_number_method(target, method, argc, argv, &handled);
     if (handled) return result;
+    xt_throw_no_method("number", method);
   }
   if (target == XT_TRUE || target == XT_FALSE) {
     if (strcmp(method, "toString") == 0) return target == XT_TRUE ? xt_string_from_cstr("true") : xt_string_from_cstr("false");
     if (strcmp(method, "valueOf") == 0) return target;
-    return XT_UNDEFINED;
+    xt_throw_no_method("boolean", method);
   }
-  return XT_UNDEFINED;
+  xt_throw_no_method("value", method);
 }

package/runtime/xt_stdlib/strings.inc

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

package/runtime/xt_stdlib2/array-statics.inc

@@ -1,5 +1,16 @@
 /* -- Array statics -------------------------------------------------------- */
 
+/* True when `Array.from` should consume the value through the iteration
+ * protocol instead of the array-like `length` path. Typed arrays stay on the
+ * length path because their indexed properties already work that way. */
+static int xt_array_from_is_iterable(xt_value value) {
+  if (xt_is_map(value) || xt_is_set(value) || xt_is_generator(value)) return 1;
+  if (XT_IS_OBJECT(value) && xt_typed_array_kind_of(value) < 0) {
+    return XT_IS_FUNCTION(xt_object_get(value, xt_symbol_well_known("iterator")));
+  }
+  return 0;
+}
+
 xt_value xt_array_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
@@ -18,12 +29,26 @@ xt_value xt_array_static(xt_value name, int32_t argc, xt_value *argv) {
       }
     } else if (XT_IS_STRING(source)) {
       xt_string *s = xt_as_string(source);
-      const char *bytes = xt_string_bytes(s);
-      for (uint32_t i = 0; i < s->length; i++) {
-        xt_value item = xt_string_new(bytes + i, 1);
+      uint32_t points = xt_string_code_point_count(s);
+      for (uint32_t i = 0; i < points; i++) {
+        xt_value item = xt_string_code_point_value(s, (int32_t)i);
         if (XT_IS_FUNCTION(mapper)) { xt_value args[2] = {item, xt_number((double)i)}; item = xt_closure_call(mapper, 2, args); }
         xt_array_push(out, item);
       }
+    } else if (xt_array_from_is_iterable(source)) {
+      /* Map, Set, generators, iterator objects and custom `[Symbol.iterator]`
+       * values do not expose a `length`; walk their `next()` protocol instead
+       * of silently producing an empty array. */
+      xt_value iterator = xt_iter_open(source);
+      for (uint32_t i = 0;; i++) {
+        if (!xt_truthy(xt_iter_has(iterator, xt_number((double)i)))) break;
+        xt_value item = xt_iter_value(iterator, xt_number((double)i));
+        if (XT_IS_FUNCTION(mapper)) {
+          xt_value args[2] = {item, xt_number((double)i)};
+          item = xt_closure_call(mapper, 2, args);
+        }
+        xt_array_push(out, item);
+      }
     } else {
       double length = xt_to_number(xt_get(source, xt_string_from_cstr("length")));
       for (int32_t i = 0; i < (int32_t)length; i++) {

package/runtime/xt_stdlib2/arrays.inc

@@ -85,7 +85,7 @@ static xt_value xt_array_sort(xt_value value, xt_value fn) {
   int hasFn = XT_IS_FUNCTION(fn);
   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"));
+    xt_throw(xt_error_from_message("RangeError: out of memory in Array.prototype.sort"));
     return value;
   }
   xt_array_merge_sort(array->items, scratch, array->length, fn, hasFn);
@@ -225,7 +225,9 @@ static xt_value xt_array_with(xt_value value, xt_value indexValue, xt_value newV
   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)));
+    xt_value message =
+        xt_add(xt_string_from_cstr("RangeError: Invalid index : "), xt_to_string(indexValue));
+    xt_throw(xt_error_from_message(xt_string_data(message)));
     return copy;
   }
   array->items[index] = newValue;
@@ -266,7 +268,7 @@ xt_value xt_ext_array_method(xt_value target, const char *method, int32_t argc,
     xt_value acc;
     if (argc >= 2) acc = argv[1];
     else if (array->length > 0) acc = array->items[i--];
-    else { xt_throw(xt_string_from_cstr("TypeError: Reduce of empty array with no initial value")); return XT_UNDEFINED; }
+    else { xt_throw(xt_error_from_message("TypeError: Reduce of empty array with no initial value")); return XT_UNDEFINED; }
     for (; i >= 0; i--) {
       xt_value args[4] = {acc, array->items[i], xt_number((double)i), target};
       acc = xt_closure_call(fn, 4, args);

package/runtime/xt_stdlib2/container.inc

@@ -2,6 +2,11 @@ xt_value xt_ext_container_method(xt_value target, const char *method, int32_t ar
   xt_object *obj = (xt_object *)XT_GET_PTR(target);
   if (obj->header.kind == XT_OBJECT_KIND_MAP) return xt_map_method(target, method, argc, argv, handled);
   if (obj->header.kind == XT_OBJECT_KIND_SET) return xt_set_method(target, method, argc, argv, handled);
+  if (obj->header.kind == XT_OBJECT_KIND_WEAK_MAP ||
+      obj->header.kind == XT_OBJECT_KIND_WEAK_SET ||
+      obj->header.kind == XT_OBJECT_KIND_WEAK_REF) {
+    return xt_weak_method(target, method, argc, argv, handled);
+  }
   if (obj->header.kind == XT_OBJECT_KIND_DATE) return xt_date_method(target, method, argc, argv, handled);
   if (obj->header.kind == XT_OBJECT_KIND_REGEXP) {
     xt_regexp *regexp = (xt_regexp *)obj;

package/runtime/xt_stdlib2/date.inc

@@ -4,11 +4,111 @@ int xt_is_date(xt_value value) {
   return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == XT_OBJECT_KIND_DATE;
 }
 
+/* Parse `YYYY-MM-DD`, optionally followed by `T`/space and
+ * `HH:MM[:SS[.mmm]]`, then `Z`, `+HH:MM`/`-HH:MM` (or the HHMM spelling).
+ * A date-only value is UTC; a date-time without an offset is local time, which
+ * is what ECMAScript specifies. Returns milliseconds since the epoch, or NaN
+ * for anything outside this subset. */
+static int xt_date_digits(const char *text, int count, int *out) {
+  int value = 0;
+  for (int i = 0; i < count; i++) {
+    if (text[i] < '0' || text[i] > '9') return 0;
+    value = value * 10 + (text[i] - '0');
+  }
+  *out = value;
+  return 1;
+}
+
+static double xt_date_parse_text(const char *text) {
+  size_t length = strlen(text);
+  size_t i = 0;
+  int year = 0, month = 0, day = 0;
+  if (length < 10 || !xt_date_digits(text, 4, &year) || text[4] != '-' ||
+      !xt_date_digits(text + 5, 2, &month) || text[7] != '-' ||
+      !xt_date_digits(text + 8, 2, &day)) {
+    return NAN;
+  }
+  i = 10;
+  int hour = 0, minute = 0, second = 0, millis = 0;
+  int hasTime = 0;
+  if (i < length && (text[i] == 'T' || text[i] == ' ')) {
+    hasTime = 1;
+    i++;
+    if (i + 5 > length || !xt_date_digits(text + i, 2, &hour) || text[i + 2] != ':' ||
+        !xt_date_digits(text + i + 3, 2, &minute)) {
+      return NAN;
+    }
+    i += 5;
+    if (i + 3 <= length && text[i] == ':') {
+      if (!xt_date_digits(text + i + 1, 2, &second)) return NAN;
+      i += 3;
+    }
+    if (i + 4 <= length && text[i] == '.') {
+      if (!xt_date_digits(text + i + 1, 3, &millis)) return NAN;
+      i += 4;
+    }
+  }
+  int utc = !hasTime;
+  int offsetSeconds = 0;
+  if (i < length) {
+    if (text[i] == 'Z') {
+      utc = 1;
+      i++;
+    } else if (text[i] == '+' || text[i] == '-') {
+      int sign = text[i] == '-' ? -1 : 1;
+      i++;
+      int offsetHour = 0, offsetMinute = 0;
+      if (i + 5 <= length && xt_date_digits(text + i, 2, &offsetHour) && text[i + 2] == ':' &&
+          xt_date_digits(text + i + 3, 2, &offsetMinute)) {
+        i += 5;
+      } else if (i + 4 <= length && xt_date_digits(text + i, 2, &offsetHour) &&
+                 xt_date_digits(text + i + 2, 2, &offsetMinute)) {
+        i += 4;
+      } else {
+        return NAN;
+      }
+      if (offsetHour > 23 || offsetMinute > 59) return NAN;
+      offsetSeconds = sign * (offsetHour * 3600 + offsetMinute * 60);
+      utc = 1;
+    } else {
+      return NAN;
+    }
+  }
+  if (i != length) return NAN;
+  if (month < 1 || month > 12 || day < 1 || day > 31 ||
+      hour > 23 || minute > 59 || second > 59) {
+    return NAN;
+  }
+  struct tm tm;
+  memset(&tm, 0, sizeof(tm));
+  tm.tm_year = year - 1900;
+  tm.tm_mon = month - 1;
+  tm.tm_mday = day;
+  tm.tm_hour = hour;
+  tm.tm_min = minute;
+  tm.tm_sec = second;
+  time_t seconds;
+  if (utc) {
+    seconds = xt_timegm(&tm);
+  } else {
+    tm.tm_isdst = -1;
+    seconds = mktime(&tm);
+    if (seconds == (time_t)-1) return NAN;
+  }
+  if (utc && offsetSeconds != 0) seconds -= offsetSeconds;
+  return (double)seconds * 1000.0 + (double)millis;
+}
+
 xt_value xt_date_ctor(int32_t argc, xt_value *argv) {
   xt_date *date = (xt_date *)xt_alloc(sizeof(xt_date), XT_OBJECT_KIND_DATE);
   if (argc == 0) date->time = (double)time(NULL) * 1000.0;
-  else if (argc == 1) date->time = XT_IS_STRING(argv[0]) ? 0.0 : xt_to_number(argv[0]);
-  else {
+  else if (argc == 1) {
+    if (XT_IS_STRING(argv[0])) {
+      date->time = xt_date_parse_text(xt_string_data(argv[0]));
+    } else {
+      date->time = xt_to_number(argv[0]);
+    }
+  } else {
     struct tm tm;
     memset(&tm, 0, sizeof(tm));
     tm.tm_year = xt_to_int32(argv[0]) - 1900;
@@ -27,7 +127,11 @@ xt_value xt_date_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, "now") == 0) return xt_number((double)time(NULL) * 1000.0);
-  if (strcmp(fn, "parse") == 0) return xt_number(0);
+  if (strcmp(fn, "parse") == 0) {
+    xt_value input = xt_arg_at(argc, argv, 0);
+    if (!XT_IS_STRING(input)) return xt_number(NAN);
+    return xt_number(xt_date_parse_text(xt_string_data(input)));
+  }
   if (strcmp(fn, "UTC") == 0) {
     struct tm tm;
     memset(&tm, 0, sizeof(tm));
@@ -68,6 +172,10 @@ static xt_value xt_date_method(xt_value target, const char *method, int32_t argc
   if (strcmp(name, "getSeconds") == 0) return xt_number(tm.tm_sec);
   if (strcmp(name, "getMilliseconds") == 0) return xt_number(fmod(date->time, 1000.0));
   if (strcmp(method, "toISOString") == 0) {
+    if (isnan(date->time)) {
+      xt_value message = xt_string_from_cstr("Invalid time value");
+      xt_throw(xt_range_error_ctor(1, &message));
+    }
     char buffer[64];
     snprintf(buffer, sizeof(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", tm.tm_year + 1900, tm.tm_mon + 1,
              tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, (int)fmod(date->time, 1000.0));