@scriptc/cli-darwin-arm64 0.2.0 → 0.2.2

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", 36},
+  {"csisolatinhebrew", 7},
+  {"hebrew", 7},
+  {"iso-8859-8", 7},
+  {"iso-8859-8-e", 7},
+  {"iso-8859-8-i", 36},
+  {"iso-ir-138", 7},
+  {"iso8859-8", 7},
+  {"iso88598", 7},
+  {"iso_8859-8", 7},
+  {"iso_8859-8:1988", 7},
+  {"logical", 36},
+  {"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", 37},
+  {"csgb2312", 37},
+  {"csiso58gb231280", 37},
+  {"gb18030", 30},
+  {"gb2312", 37},
+  {"gb_2312", 37},
+  {"gb_2312-80", 37},
+  {"gbk", 37},
+  {"iso-ir-58", 37},
+  {"x-gbk", 37},
+  {"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},
+};