@scriptc/cli-darwin-arm64 0.2.0 → 0.2.1

package/dist/lib/runtime-sources/src/scr_stream.c

@@ -2446,6 +2446,59 @@ void scr_stream_unshift_str(ScrStream *s, ScrStr *str) {
   scr_bytes_release(b);
 }
 
+static void scr_stream_listener_error(ScrClosure *adapter, ScrError *error) {
+  ScrDyn *fn = scr_dyn_listener_fn(adapter);
+  ScrDyn *arg = scr_dyn_from_error(error);
+  ScrDyn *answer = scr_dyn_call(fn, &arg, 1, "listener");
+  scr_dyn_release(answer);
+  scr_dyn_release(arg);
+  scr_dyn_release(fn);
+}
+
+static void scr_stream_listener_data(ScrClosure *adapter, ScrBytes *bytes, ScrStr *string) {
+  ScrDyn *fn = scr_dyn_listener_fn(adapter);
+  ScrDyn *arg = string ? scr_dyn_new_str(string) : scr_dyn_new_bytes(bytes);
+  ScrDyn *answer = scr_dyn_call(fn, &arg, 1, "listener");
+  scr_dyn_release(answer);
+  scr_dyn_release(arg);
+  scr_dyn_release(fn);
+}
+
+ScrStream *scr_stream_on_dyn(ScrStream *s, ScrStr *name, ScrDyn *cb, bool once, bool prepend) {
+  if (name->len == 4 && !memcmp(name->data, "data", 4)) {
+    return (ScrStream *)scr_emitter_on_dyn((ScrEmitter *)s, name, cb,
+      scr_dyn_listener_closure_fn(cb, (void *)scr_stream_listener_data),
+      scr_ee_inv_fixed2, once, prepend);
+  }
+  bool error = name->len == 5 && memcmp(name->data, "error", 5) == 0;
+  bool empty = (name->len == 8 && memcmp(name->data, "readable", 8) == 0) ||
+    (name->len == 3 && memcmp(name->data, "end", 3) == 0) ||
+    (name->len == 5 && memcmp(name->data, "close", 5) == 0) ||
+    (name->len == 6 && memcmp(name->data, "finish", 6) == 0) ||
+    (name->len == 5 && memcmp(name->data, "drain", 5) == 0) ||
+    (name->len == 6 && memcmp(name->data, "resume", 6) == 0) ||
+    (name->len == 5 && memcmp(name->data, "pause", 5) == 0) ||
+    (name->len == 9 && memcmp(name->data, "prefinish", 9) == 0);
+  if (error || empty) {
+    ScrClosure *adapter = error ? scr_dyn_listener_closure_fn(cb, (void *)&scr_stream_listener_error) : scr_dyn_listener_closure0(cb);
+    return (ScrStream *)scr_emitter_on_dyn((ScrEmitter *)s, name, cb, adapter,
+      error ? scr_ee_inv_fixed1 : scr_ee_inv_fixed0, once, prepend);
+  }
+  static const char message[] = "this stream event has no checked-dynamic listener adapter";
+  scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+  return NULL;
+}
+
+ScrDyn *scr_stream_read_dyn(ScrStream *s, ScrDyn *size) {
+  double n = size && size->kind != SCR_DYN_UNDEF ? scr_dyn_number_coerce(size) : -1;
+  if (scr_exc_pending()) return scr_dyn_undefined();
+  void *chunk = s->st->has_r ? scr_stream_read_n(s, n) : NULL;
+  if (!chunk) return scr_dyn_new_null();
+  ScrDyn *result = s->st->r.encoded ? scr_dyn_new_str(chunk) : scr_dyn_new_buffer(chunk);
+  scr_stream_entry_release(s->st, chunk);
+  return result;
+}
+
 ScrBytes *scr_stream_read(ScrStream *s, double size) {
   /* a destroyed readable still DRAINS its buffer (Node: destroy leaves
    * buffered chunks readable; only _read refills are blocked) */
@@ -3147,3 +3200,147 @@ void scr_stream_install(void) {
   scr_emitter_on_hook = &scr_stream_on_listener;
   scr_loop_set_stream(&scr_stream_ticks_pending, &scr_stream_dispatch);
 }
+
+/* Child stdio uses the standard stream machinery once it crosses generic
+ * storage. Child-only programs never reference this optional table. */
+static void scr_stream_child_read(ScrClosure *cb, ScrStream *s, double size) {
+  (void)cb; (void)s; (void)size;
+}
+static ScrStream *scr_stream_child_readable(void) {
+  return scr_stream_new_readable(-1, true, true,
+      scr_closure_new((void *)scr_stream_child_read, 0), scr_stream_child_read,
+      NULL, NULL);
+}
+static ScrStream *scr_stream_child_writable(ScrClosure *write, ScrStreamChunkInv write_inv,
+    ScrClosure *final_cb, ScrStreamPlainInv final_inv) {
+  return scr_stream_new_writable(-1, true, true, write, write_inv,
+      final_cb, final_inv, NULL, NULL);
+}
+const ScrChildStreamOps scr_stream_child_ops = {
+  scr_stream_child_readable, scr_stream_child_writable,
+  scr_stream_retain_v, scr_stream_release_v, scr_stream_trace,
+  scr_stream_push, scr_stream_push_null,
+  scr_stream_write_done, scr_stream_final_done,
+};
+
+static ScrStream *scr_stream_view_receiver(const ScrDyn *value) {
+  if (value->kind == SCR_DYN_TYPED_REF && value->v.typed_ref.type_key_len > 7 &&
+      !memcmp(value->v.typed_ref.type_key, "object:", 7)) {
+    ScrStream *stream = scr_dyn_typed_ref_unbox(value);
+    const ScrVt *vt = stream->vt;
+    if ((vt->pre >= scr_readable_vt.pre && vt->pre <= scr_readable_vt.post) ||
+        (vt->pre >= scr_writable_vt.pre && vt->pre <= scr_writable_vt.post)) return stream;
+    value->v.typed_ref.release(stream);
+  }
+  scr_dyn_arg_type_fail("destination", "an instance of Stream", value);
+  return NULL;
+}
+
+static ScrDyn *scr_stream_view_call(ScrClosure *cb, ScrDyn *const *args, size_t argc) {
+  ScrStream *stream = scr_box_get_ref(cb->caps[0]);
+  ScrStr *name = scr_box_get_ref(cb->caps[1]);
+  const char *method = name->data;
+  ScrDyn *result = NULL;
+  ScrDyn *first = argc ? args[0] : scr_dyn_undefined();
+  if (!strcmp(method, "on") || !strcmp(method, "once") || !strcmp(method, "addListener") ||
+      !strcmp(method, "prependListener") || !strcmp(method, "prependOnceListener")) {
+    if (first->kind != SCR_DYN_STR) scr_dyn_arg_type_fail("event", "of type string", first);
+    else {
+      ScrStream *registered = scr_stream_on_dyn(stream, first->v.str,
+          argc > 1 ? args[1] : scr_dyn_undefined(),
+          !strcmp(method, "once") || !strcmp(method, "prependOnceListener"),
+          !strncmp(method, "prepend", 7));
+      scr_stream_release(registered);
+    }
+  } else if (!strcmp(method, "off") || !strcmp(method, "removeListener")) {
+    if (first->kind != SCR_DYN_STR) scr_dyn_arg_type_fail("event", "of type string", first);
+    else {
+      ScrEmitter *registered = scr_emitter_off_dyn((ScrEmitter *)stream, first->v.str,
+          argc > 1 ? args[1] : scr_dyn_undefined());
+      scr_emitter_release(registered);
+    }
+  } else if (!strcmp(method, "pipe") || !strcmp(method, "unpipe")) {
+    ScrStream *destination = first->kind == SCR_DYN_UNDEF && !strcmp(method, "unpipe")
+      ? NULL : scr_stream_view_receiver(first);
+    if (!scr_exc_pending()) {
+      bool end = true;
+      if (argc > 1 && args[1]->kind != SCR_DYN_UNDEF) {
+        ScrDyn *option = scr_dyn_obj_read(args[1], "end", 3);
+        end = option->kind == SCR_DYN_UNDEF || scr_dyn_truthy(option);
+        scr_dyn_release(option);
+      }
+      ScrStream *returned = !strcmp(method, "pipe")
+          ? scr_stream_pipe(stream, destination, end) : scr_stream_unpipe(stream, destination);
+      scr_stream_release(returned);
+      if (!strcmp(method, "pipe") && !scr_exc_pending()) result = scr_dyn_retain(first);
+    }
+    scr_stream_release(destination);
+  } else if (!strcmp(method, "read")) result = scr_stream_read_dyn(stream, first);
+  else if (!strcmp(method, "pause") || !strcmp(method, "resume")) {
+    ScrStream *returned = !strcmp(method, "pause") ? scr_stream_pause(stream) : scr_stream_resume(stream);
+    scr_stream_release(returned);
+  } else if (!strcmp(method, "isPaused")) result = scr_dyn_new_bool(scr_stream_is_paused(stream));
+  else if (!strcmp(method, "setEncoding")) {
+    if (first->kind != SCR_DYN_STR) scr_dyn_arg_type_fail("encoding", "of type string", first);
+    else scr_stream_release(scr_stream_set_encoding(stream, first->v.str));
+  } else if (!strcmp(method, "write")) {
+    if (argc > 1 && args[1]->kind != SCR_DYN_UNDEF) {
+      static const char message[] = "Native stream method values with write encodings or callbacks have no lowering";
+      scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+    } else result = scr_dyn_new_bool(scr_stream_write_dyn(stream, first, NULL));
+  } else if (!strcmp(method, "end")) {
+    if (argc > 1 && args[1]->kind != SCR_DYN_UNDEF) {
+      static const char message[] = "Native stream method values with end encodings or callbacks have no lowering";
+      scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+    } else if (first->kind == SCR_DYN_UNDEF || first->kind == SCR_DYN_NULL) {
+      scr_stream_release(scr_stream_end(stream, NULL, NULL, NULL));
+    } else if (first->kind == SCR_DYN_STR) {
+      scr_stream_release(scr_stream_end(stream, NULL, first->v.str, NULL));
+    } else if (first->kind == SCR_DYN_BYTES) {
+      scr_stream_release(scr_stream_end(stream, first->v.bytes, NULL, NULL));
+    } else scr_dyn_arg_type_fail("chunk", "of type string or an instance of Buffer or Uint8Array", first);
+  } else if (!strcmp(method, "destroy")) {
+    ScrError *error = first->kind == SCR_DYN_UNDEF || first->kind == SCR_DYN_NULL ? NULL : scr_error_from_dyn(first);
+    scr_stream_release(scr_stream_destroy(stream, error));
+    scr_error_release(error);
+  } else if (!strcmp(method, "cork")) scr_stream_cork(stream);
+  else if (!strcmp(method, "uncork")) scr_stream_uncork(stream);
+  if (!result && !scr_exc_pending()) result = scr_dyn_this_get();
+  scr_str_release(name);
+  scr_stream_release(stream);
+  return result;
+}
+
+ScrDyn *scr_stream_dyn_view(ScrStream *stream) {
+  ScrDyn *view = scr_dyn_new_obj();
+  ScrDyn *prototype = scr_dyn_new_obj();
+  static const char *const methods[] = {
+    "on", "once", "addListener", "prependListener", "prependOnceListener",
+    "off", "removeListener", "pipe", "unpipe", "read", "pause", "resume", "isPaused",
+    "setEncoding", "write", "end", "destroy", "cork", "uncork",
+  };
+  for (size_t i = 0; i < sizeof methods / sizeof *methods; i++) {
+    ScrClosure *cb = scr_closure_new((void *)scr_stream_view_call, 2);
+    cb->caps[0] = scr_box_new_obj(scr_stream_retain_v, scr_stream_release_v, scr_stream_trace);
+    cb->caps[1] = scr_box_new(SCR_BOX_STR);
+    scr_box_set_ref(cb->caps[0], scr_stream_retain(stream));
+    scr_box_set_ref(cb->caps[1], scr_str_new(methods[i], strlen(methods[i])));
+    scr_dyn_obj_set(prototype, methods[i], strlen(methods[i]),
+        scr_dyn_new_func(cb, scr_stream_view_call, 0, "native stream method", methods[i]));
+  }
+  static const char *const properties[] = {
+    "readable", "readableEnded", "readableLength", "readableHighWaterMark",
+    "writable", "writableEnded", "writableFinished", "writableLength", "writableHighWaterMark",
+    "writableNeedDrain", "destroyed", "closed",
+  };
+  for (size_t i = 0; i < sizeof properties / sizeof *properties; i++) {
+    double value = scr_stream_prop(stream, properties[i]);
+    bool number = strstr(properties[i], "Length") || strstr(properties[i], "HighWaterMark");
+    scr_dyn_obj_set(view, properties[i], strlen(properties[i]),
+        number ? scr_dyn_new_num(value) : scr_dyn_new_bool(value != 0));
+  }
+  ScrDyn *attached = scr_dyn_set_prototype(view, prototype);
+  scr_dyn_release(attached);
+  scr_dyn_release(prototype);
+  return view;
+}

package/dist/lib/runtime-sources/src/scr_string.c

@@ -1790,7 +1790,7 @@ static int scr_uri_hex_byte(const char *p, size_t rem) {
  * querystring unit's unescape needs exactly the try/catch shape Node's
  * qsUnescape wraps around decodeURIComponent (scr_qs.c), and the throwing
  * entry point below stays byte-identical by rethrowing over NULL. */
-ScrStr *scr_str_decode_uri_component_try(ScrStr *s) {
+static ScrStr *scr_str_decode_uri_try(ScrStr *s, bool reserved) {
   /* Decoding only ever shrinks (%XX → 1 byte), so len is a safe cap. */
   ScrStr *out = scr_str_alloc_raw(0, s->len);
   size_t w = 0;
@@ -1805,6 +1805,11 @@ ScrStr *scr_str_decode_uri_component_try(ScrStr *s) {
     if (b0 < 0) goto malformed;
     i += 3;
     if (b0 < 0x80) {
+      if (reserved && b0 != 0 && strchr(";/?:@&=+$,#", b0)) {
+        memcpy(out->data + w, p + i - 3, 3);
+        w += 3;
+        continue;
+      }
       /* The empty component reserved set: every ASCII escape decodes. */
       out->data[w++] = (char)b0;
       continue;
@@ -1839,6 +1844,16 @@ malformed:
   return NULL;
 }
 
+ScrStr *scr_str_decode_uri_component_try(ScrStr *s) {
+  return scr_str_decode_uri_try(s, false);
+}
+
+ScrStr *scr_str_decode_uri(ScrStr *s) {
+  ScrStr *out = scr_str_decode_uri_try(s, true);
+  if (!out) scr_uri_malformed();
+  return out;
+}
+
 ScrStr *scr_str_decode_uri_component(ScrStr *s) {
   ScrStr *out = scr_str_decode_uri_component_try(s);
   if (!out) {

package/dist/lib/runtime-sources/src/scr_symbol.c

@@ -85,6 +85,11 @@ ScrSym *scr_sym_well_known(ScrStr *name) {
     scr_dyn_install_iterator_symbol(key);
     scr_dyn_release(key);
   }
+  if (name->len == 13 && !memcmp(name->data, "asyncIterator", 13)) {
+    ScrDyn *key = scr_dyn_new_symbol(symbol);
+    scr_dyn_install_async_iterator_symbol(key);
+    scr_dyn_release(key);
+  }
   return symbol;
 }
 

package/dist/lib/runtime-sources/src/scr_text_decoder_labels.h

@@ -0,0 +1,225 @@
+/* Generated by scripts/gen-text-decoder-labels.mts. Do not edit by hand. */
+static const struct { const char *label; int encoding; } scr_td_labels[] = {
+  {"unicode-1-1-utf-8", -1},
+  {"unicode11utf8", -1},
+  {"unicode20utf8", -1},
+  {"utf-8", -1},
+  {"utf8", -1},
+  {"x-unicode20utf8", -1},
+  {"866", 0},
+  {"cp866", 0},
+  {"csibm866", 0},
+  {"ibm866", 0},
+  {"csisolatin2", 1},
+  {"iso-8859-2", 1},
+  {"iso-ir-101", 1},
+  {"iso8859-2", 1},
+  {"iso88592", 1},
+  {"iso_8859-2", 1},
+  {"iso_8859-2:1987", 1},
+  {"l2", 1},
+  {"latin2", 1},
+  {"csisolatin3", 2},
+  {"iso-8859-3", 2},
+  {"iso-ir-109", 2},
+  {"iso8859-3", 2},
+  {"iso88593", 2},
+  {"iso_8859-3", 2},
+  {"iso_8859-3:1988", 2},
+  {"l3", 2},
+  {"latin3", 2},
+  {"csisolatin4", 3},
+  {"iso-8859-4", 3},
+  {"iso-ir-110", 3},
+  {"iso8859-4", 3},
+  {"iso88594", 3},
+  {"iso_8859-4", 3},
+  {"iso_8859-4:1988", 3},
+  {"l4", 3},
+  {"latin4", 3},
+  {"csisolatincyrillic", 4},
+  {"cyrillic", 4},
+  {"iso-8859-5", 4},
+  {"iso-ir-144", 4},
+  {"iso8859-5", 4},
+  {"iso88595", 4},
+  {"iso_8859-5", 4},
+  {"iso_8859-5:1988", 4},
+  {"arabic", 5},
+  {"asmo-708", 5},
+  {"csiso88596e", 5},
+  {"csiso88596i", 5},
+  {"csisolatinarabic", 5},
+  {"ecma-114", 5},
+  {"iso-8859-6", 5},
+  {"iso-8859-6-e", 5},
+  {"iso-8859-6-i", 5},
+  {"iso-ir-127", 5},
+  {"iso8859-6", 5},
+  {"iso88596", 5},
+  {"iso_8859-6", 5},
+  {"iso_8859-6:1987", 5},
+  {"csisolatingreek", 6},
+  {"ecma-118", 6},
+  {"elot_928", 6},
+  {"greek", 6},
+  {"greek8", 6},
+  {"iso-8859-7", 6},
+  {"iso-ir-126", 6},
+  {"iso8859-7", 6},
+  {"iso88597", 6},
+  {"iso_8859-7", 6},
+  {"iso_8859-7:1987", 6},
+  {"sun_eu_greek", 6},
+  {"csiso88598e", 7},
+  {"csiso88598i", 7},
+  {"csisolatinhebrew", 7},
+  {"hebrew", 7},
+  {"iso-8859-8", 7},
+  {"iso-8859-8-e", 7},
+  {"iso-8859-8-i", 7},
+  {"iso-ir-138", 7},
+  {"iso8859-8", 7},
+  {"iso88598", 7},
+  {"iso_8859-8", 7},
+  {"iso_8859-8:1988", 7},
+  {"logical", 7},
+  {"visual", 7},
+  {"csisolatin6", 8},
+  {"iso-8859-10", 8},
+  {"iso-ir-157", 8},
+  {"iso8859-10", 8},
+  {"iso885910", 8},
+  {"l6", 8},
+  {"latin6", 8},
+  {"iso-8859-13", 9},
+  {"iso8859-13", 9},
+  {"iso885913", 9},
+  {"iso-8859-14", 10},
+  {"iso8859-14", 10},
+  {"iso885914", 10},
+  {"csisolatin9", 11},
+  {"iso-8859-15", 11},
+  {"iso8859-15", 11},
+  {"iso885915", 11},
+  {"iso_8859-15", 11},
+  {"l9", 11},
+  {"iso-8859-16", 12},
+  {"cskoi8r", 13},
+  {"koi", 13},
+  {"koi8", 13},
+  {"koi8-r", 13},
+  {"koi8_r", 13},
+  {"koi8-ru", 14},
+  {"koi8-u", 14},
+  {"csmacintosh", 15},
+  {"mac", 15},
+  {"macintosh", 15},
+  {"x-mac-roman", 15},
+  {"dos-874", 16},
+  {"iso-8859-11", 16},
+  {"iso8859-11", 16},
+  {"iso885911", 16},
+  {"tis-620", 16},
+  {"windows-874", 16},
+  {"cp1250", 17},
+  {"windows-1250", 17},
+  {"x-cp1250", 17},
+  {"cp1251", 18},
+  {"windows-1251", 18},
+  {"x-cp1251", 18},
+  {"ansi_x3.4-1968", 19},
+  {"ascii", 19},
+  {"cp1252", 19},
+  {"cp819", 19},
+  {"csisolatin1", 19},
+  {"ibm819", 19},
+  {"iso-8859-1", 19},
+  {"iso-ir-100", 19},
+  {"iso8859-1", 19},
+  {"iso88591", 19},
+  {"iso_8859-1", 19},
+  {"iso_8859-1:1987", 19},
+  {"l1", 19},
+  {"latin1", 19},
+  {"us-ascii", 19},
+  {"windows-1252", 19},
+  {"x-cp1252", 19},
+  {"cp1253", 20},
+  {"windows-1253", 20},
+  {"x-cp1253", 20},
+  {"cp1254", 21},
+  {"csisolatin5", 21},
+  {"iso-8859-9", 21},
+  {"iso-ir-148", 21},
+  {"iso8859-9", 21},
+  {"iso88599", 21},
+  {"iso_8859-9", 21},
+  {"iso_8859-9:1989", 21},
+  {"l5", 21},
+  {"latin5", 21},
+  {"windows-1254", 21},
+  {"x-cp1254", 21},
+  {"cp1255", 22},
+  {"windows-1255", 22},
+  {"x-cp1255", 22},
+  {"cp1256", 23},
+  {"windows-1256", 23},
+  {"x-cp1256", 23},
+  {"cp1257", 24},
+  {"windows-1257", 24},
+  {"x-cp1257", 24},
+  {"cp1258", 25},
+  {"windows-1258", 25},
+  {"x-cp1258", 25},
+  {"x-mac-cyrillic", 26},
+  {"x-mac-ukrainian", 26},
+  {"x-user-defined", 27},
+  {"csunicode", 28},
+  {"iso-10646-ucs-2", 28},
+  {"ucs-2", 28},
+  {"unicode", 28},
+  {"unicodefeff", 28},
+  {"utf-16", 28},
+  {"utf-16le", 28},
+  {"unicodefffe", 29},
+  {"utf-16be", 29},
+  {"chinese", 30},
+  {"csgb2312", 30},
+  {"csiso58gb231280", 30},
+  {"gb18030", 30},
+  {"gb2312", 30},
+  {"gb_2312", 30},
+  {"gb_2312-80", 30},
+  {"gbk", 30},
+  {"iso-ir-58", 30},
+  {"x-gbk", 30},
+  {"big5", 31},
+  {"big5-hkscs", 31},
+  {"cn-big5", 31},
+  {"csbig5", 31},
+  {"x-x-big5", 31},
+  {"cseucpkdfmtjapanese", 32},
+  {"euc-jp", 32},
+  {"x-euc-jp", 32},
+  {"csiso2022jp", 33},
+  {"iso-2022-jp", 33},
+  {"csshiftjis", 34},
+  {"ms932", 34},
+  {"ms_kanji", 34},
+  {"shift-jis", 34},
+  {"shift_jis", 34},
+  {"sjis", 34},
+  {"windows-31j", 34},
+  {"x-sjis", 34},
+  {"cseuckr", 35},
+  {"csksc56011987", 35},
+  {"euc-kr", 35},
+  {"iso-ir-149", 35},
+  {"korean", 35},
+  {"ks_c_5601-1987", 35},
+  {"ks_c_5601-1989", 35},
+  {"ksc5601", 35},
+  {"ksc_5601", 35},
+  {"windows-949", 35},
+};

package/dist/lib/runtime-sources/src/scr_url.c

@@ -1167,9 +1167,10 @@ ScrStr *scr_url_hash(ScrUrl *u) {
 /* Checked native URL values preserve their handle across unknown storage. */
 static ScrDyn *scr_native_url_get(void *ptr, const char *key, size_t len) {
   if (len == 12 && !memcmp(key, "searchParams", len)) {
-    static const char message[] = "Checked URL.searchParams has no native lowering";
-    scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
-    return NULL;
+    ScrSearchParams *params = scr_url_search_params(ptr);
+    ScrDyn *result = scr_dyn_native_search_params(params);
+    scr_sp_release(params);
+    return result;
   }
   ScrStr *text = NULL;
 #define URL_GET(name) if (len == sizeof(#name) - 1 && memcmp(key, #name, len) == 0) text = scr_url_##name(ptr)
@@ -1223,6 +1224,174 @@ ScrUrl *scr_dyn_native_url_check(const ScrDyn *value, const ScrDynPath *path) {
   return scr_url_retain(value->v.handle.ptr);
 }
 
+static ScrDyn *scr_native_sp_get(void *ptr, const char *key, size_t len) {
+  if (len == 4 && !memcmp(key, "size", len)) return scr_dyn_new_num(scr_sp_size(ptr));
+  return scr_dyn_retain(scr_dyn_undefined());
+}
+
+static ScrDyn *scr_native_sp_step(void *ptr, double *index, unsigned selection) {
+  bool done = *index >= scr_sp_size(ptr);
+  ScrDyn *value = scr_dyn_retain(scr_dyn_undefined());
+  if (!done) {
+    scr_dyn_release(value);
+    ScrStr *key = scr_sp_key_at(ptr, *index), *text = scr_sp_val_at(ptr, *index);
+    (*index)++;
+    if (selection == 2) {
+      value = scr_dyn_new_arr();
+      scr_dyn_arr_push(value, scr_dyn_new_str(key));
+      scr_dyn_arr_push(value, scr_dyn_new_str(text));
+    } else value = scr_dyn_new_str(selection == 1 ? key : text);
+    scr_str_release(key); scr_str_release(text);
+  }
+  ScrDyn *result = scr_dyn_new_obj();
+  scr_dyn_obj_set(result, "done", 4, scr_dyn_new_bool(done));
+  scr_dyn_obj_set(result, "value", 5, value);
+  return result;
+}
+
+static ScrDyn *scr_native_sp_invoke(void *ptr, ScrDyn *self, const char *method,
+    ScrDyn *const *args, size_t argc, const char *what) {
+  if (!strcmp(method, "entries") || !strcmp(method, "keys") || !strcmp(method, "values"))
+    return scr_dyn_native_handle_iterator(self, !strcmp(method, "entries") ? 2 : !strcmp(method, "keys") ? 1 : 0);
+  if (!strcmp(method, "toString")) {
+    ScrStr *text = scr_sp_to_string(ptr);
+    ScrDyn *result = scr_dyn_new_str(text);
+    scr_str_release(text);
+    return result;
+  }
+  if (!strcmp(method, "sort")) { scr_sp_sort(ptr); return scr_dyn_retain(scr_dyn_undefined()); }
+  if (!strcmp(method, "forEach")) {
+    if (!argc) { scr_dyn_arg_type_fail("callback", "of type function", scr_dyn_undefined()); return NULL; }
+    for (double i = 0; i < scr_sp_size(ptr); i++) {
+      ScrStr *key = scr_sp_key_at(ptr, i), *value = scr_sp_val_at(ptr, i);
+      ScrDyn *argv[] = {scr_dyn_new_str(value), scr_dyn_new_str(key), self};
+      scr_str_release(key); scr_str_release(value);
+      scr_dyn_this_push_dyn(argc > 1 ? args[1] : NULL);
+      ScrDyn *called = scr_dyn_call(args[0], argv, 3, "callback");
+      scr_dyn_this_pop();
+      scr_dyn_release(called); scr_dyn_release(argv[0]); scr_dyn_release(argv[1]);
+      if (scr_exc_pending()) return NULL;
+    }
+    return scr_dyn_retain(scr_dyn_undefined());
+  }
+  bool two = !strcmp(method, "append") || !strcmp(method, "set");
+  bool one = !strcmp(method, "get") || !strcmp(method, "getAll") || !strcmp(method, "has") || !strcmp(method, "delete");
+  if (!one && !two) {
+    scr_dyn_arg_type_fail(what, "of type function", scr_dyn_undefined());
+    return NULL;
+  }
+  if (argc < (two ? 2 : 1)) {
+    static const char message[] = "Not enough arguments";
+    scr_throw_error_msg_code(SCR_ERR_TYPE, message, sizeof message - 1, "ERR_MISSING_ARGS");
+    return NULL;
+  }
+  ScrStr *key = scr_dyn_string_coerce_js(args[0]);
+  if (scr_exc_pending()) return NULL;
+  ScrStr *value = NULL;
+  if (two || argc > 1 && args[1]->kind != SCR_DYN_UNDEF) value = scr_dyn_string_coerce_js(args[1]);
+  if (scr_exc_pending()) { scr_str_release(key); return NULL; }
+  ScrDyn *result = NULL;
+  if (!strcmp(method, "get")) {
+    ScrStr *found = scr_sp_get(ptr, key);
+    result = found ? scr_dyn_new_str(found) : scr_dyn_new_null();
+    scr_str_release(found);
+  } else if (!strcmp(method, "getAll")) {
+    ScrArr *found = scr_sp_get_all(ptr, key);
+    result = scr_dyn_new_arr();
+    for (size_t i = 0; i < found->len; i++) {
+      ScrStr *text = scr_arr_get_ref(found, i);
+      scr_dyn_arr_push(result, scr_dyn_new_str(text));
+      scr_str_release(text);
+    }
+    scr_arr_release(found);
+  } else if (!strcmp(method, "has")) result = scr_dyn_new_bool(value ? scr_sp_has_value(ptr, key, value) : scr_sp_has(ptr, key));
+  else {
+    if (!strcmp(method, "append")) scr_sp_append(ptr, key, value);
+    else if (!strcmp(method, "set")) scr_sp_set(ptr, key, value);
+    else if (value) scr_sp_delete_value(ptr, key, value);
+    else scr_sp_delete(ptr, key);
+    result = scr_dyn_retain(scr_dyn_undefined());
+  }
+  scr_str_release(key); scr_str_release(value);
+  return result;
+}
+
+ScrDyn *scr_dyn_native_search_params(ScrSearchParams *value) {
+  static const ScrDynHandleOps ops = {
+    "URLSearchParams", &scr_sp_retain_v, &scr_sp_release_v, &scr_native_sp_invoke,
+    &scr_native_sp_get, NULL, NULL, NULL, &scr_native_sp_step,
+  };
+  scr_dyn_handle_install(SCR_DYNH_SEARCH_PARAMS, &ops);
+  return scr_dyn_new_handle(value, SCR_DYNH_SEARCH_PARAMS);
+}
+
+bool scr_dyn_native_search_params_is(const ScrDyn *value) {
+  return value && value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_SEARCH_PARAMS;
+}
+
+ScrSearchParams *scr_dyn_native_search_params_check(const ScrDyn *value, const ScrDynPath *path) {
+  if (!scr_dyn_native_search_params_is(value)) { scr_dyn_check_fail(path, "URLSearchParams", value); return NULL; }
+  return scr_sp_retain(value->v.handle.ptr);
+}
+
+ScrSearchParams *scr_sp_new_checked(const ScrDyn *value) {
+  if (!value || value->kind == SCR_DYN_UNDEF || value->kind == SCR_DYN_NULL) return scr_sp_new();
+  if (scr_dyn_native_search_params_is(value)) return scr_sp_copy(value->v.handle.ptr);
+  if (value->kind == SCR_DYN_OBJ || value->kind == SCR_DYN_ARR || value->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *iterator = scr_dyn_iterator_optional(value);
+    if (scr_exc_pending()) return NULL;
+    ScrSearchParams *result = scr_sp_new();
+    if (iterator) {
+      for (;;) {
+        ScrStr *next_key = scr_str_new("next", 4);
+        ScrDyn *next = iterator->kind == SCR_DYN_HANDLE ? scr_dyn_handle_key_get(iterator, next_key) : scr_dyn_obj_read(iterator, "next", 4);
+        scr_str_release(next_key);
+        scr_dyn_this_push_dyn(iterator);
+        ScrDyn *step = scr_exc_pending() ? NULL : scr_dyn_call(next, NULL, 0, "iterator.next");
+        scr_dyn_this_pop();
+        scr_dyn_release(next);
+        if (scr_exc_pending()) break;
+        ScrDyn *done = scr_dyn_obj_read(step, "done", 4);
+        bool end = scr_dyn_truthy(done);
+        scr_dyn_release(done);
+        if (end) { scr_dyn_release(step); scr_dyn_release(iterator); return result; }
+        ScrDyn *row = scr_dyn_obj_read(step, "value", 5);
+        ScrDyn *pair = scr_dyn_iter_pack(row, NULL);
+        scr_dyn_release(row); scr_dyn_release(step);
+        if (scr_exc_pending()) { scr_dyn_release(pair); break; }
+        if (!pair || pair->kind != SCR_DYN_ARR || pair->v.arr.len != 2) {
+          static const char message[] = "Each query pair must be an iterable [name, value] tuple";
+          scr_throw_error_msg_code(SCR_ERR_TYPE, message, sizeof message - 1, "ERR_INVALID_TUPLE");
+          scr_dyn_release(pair); break;
+        }
+        ScrStr *key = scr_dyn_string_coerce_js(pair->v.arr.items[0]);
+        ScrStr *text = scr_exc_pending() ? NULL : scr_dyn_string_coerce_js(pair->v.arr.items[1]);
+        if (!scr_exc_pending()) scr_sp_append(result, key, text);
+        scr_str_release(key); scr_str_release(text); scr_dyn_release(pair);
+        if (scr_exc_pending()) break;
+      }
+      scr_dyn_release(iterator); scr_sp_release(result); return NULL;
+    }
+    ScrDyn *keys = scr_dyn_obj_keys(value);
+    if (scr_exc_pending()) { scr_sp_release(result); return NULL; }
+    for (size_t i = 0; i < keys->v.arr.len; i++) {
+      ScrStr *key = keys->v.arr.items[i]->v.str;
+      ScrDyn *entry = scr_dyn_obj_read(value, key->data, key->len);
+      ScrStr *text = scr_exc_pending() ? NULL : scr_dyn_string_coerce_js(entry);
+      scr_dyn_release(entry);
+      if (!scr_exc_pending()) scr_sp_append(result, key, text);
+      scr_str_release(text);
+      if (scr_exc_pending()) { scr_dyn_release(keys); scr_sp_release(result); return NULL; }
+    }
+    scr_dyn_release(keys); return result;
+  }
+  ScrStr *text = scr_dyn_string_coerce_js(value);
+  if (scr_exc_pending()) return NULL;
+  ScrSearchParams *result = scr_sp_parse(text);
+  scr_str_release(text);
+  return result;
+}
+
 ScrStr *scr_url_checked_to_path(const ScrDyn *value) {
   if (scr_dyn_native_url_is(value)) return scr_url_to_path(value->v.handle.ptr);
   if (value->kind == SCR_DYN_STR) return scr_url_str_to_path(value->v.str);