@scriptc/cli-darwin-arm64 0.2.0 → 0.2.2

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

@@ -763,6 +763,33 @@ ScrStr *scr_url_protocol(ScrUrl *u) {
   return ub_take(&b);
 }
 
+/* Input conversion is the caller's responsibility. Only parser errors are
+ * suppressed: user toString errors must still escape the public factories. */
+static ScrUrl *url_try_parse(ScrStr *input, ScrStr *base) {
+  ScrUrl *u = base ? scr_url_new_base(input, base) : scr_url_new(input);
+  if (!u) scr_exc_clear();
+  return u;
+}
+
+bool scr_url_can_parse_base(ScrStr *input, ScrStr *base) {
+  ScrUrl *u = url_try_parse(input, base);
+  bool valid = u != NULL;
+  scr_url_release(u);
+  return valid;
+}
+
+bool scr_url_can_parse(ScrStr *input) { return scr_url_can_parse_base(input, NULL); }
+
+ScrDyn *scr_url_parse_base(ScrStr *input, ScrStr *base) {
+  ScrUrl *u = url_try_parse(input, base);
+  if (!u) return scr_dyn_new_null();
+  ScrDyn *value = scr_dyn_native_url(u);
+  scr_url_release(u);
+  return value;
+}
+
+ScrDyn *scr_url_parse(ScrStr *input) { return scr_url_parse_base(input, NULL); }
+
 ScrStr *scr_url_pathname(ScrUrl *u) { return scr_str_retain(u->path); }
 
 /* WHATWG host getter: host[:port] — the port only when non-default (the
@@ -872,7 +899,7 @@ static int hex_val(char c) {
  * letter otherwise. The public wrappers below select by TARGET. */
 static ScrStr *scr_url_to_path_impl(ScrUrl *u, bool win32) {
   if (!(u->scheme->len == 4 && memcmp(u->scheme->data, "file", 4) == 0)) {
-    scr_throw_error_msg(SCR_ERR_TYPE, "The URL must be of scheme file", 30);
+    scr_throw_error_msg_code(SCR_ERR_TYPE, "The URL must be of scheme file", 30, "ERR_INVALID_URL_SCHEME");
     return NULL;
   }
   const char *p = u->path->data;
@@ -884,8 +911,8 @@ static ScrStr *scr_url_to_path_impl(ScrUrl *u, bool win32) {
       char c1 = p[n + 1];
       int third = (n + 2 < len ? (unsigned char)p[n + 2] : 0) | 0x20;
       if ((c1 == '2' && third == 'f') || (c1 == '5' && third == 'c')) {
-        scr_throw_error_msg(SCR_ERR_TYPE,
-                             "File URL path must not include encoded \\ or / characters", 56);
+        scr_throw_error_msg_code(SCR_ERR_TYPE,
+                             "File URL path must not include encoded \\ or / characters", 56, "ERR_INVALID_FILE_URL_PATH");
         return NULL;
       }
     }
@@ -916,7 +943,7 @@ static ScrStr *scr_url_to_path_impl(ScrUrl *u, bool win32) {
     char drive_sep = plen > 2 ? pp[2] : 0;
     if (letter < 'a' || letter > 'z' || drive_sep != ':') {
       free(out.data);
-      scr_throw_error_msg(SCR_ERR_TYPE, "File URL path must be absolute", 30);
+      scr_throw_error_msg_code(SCR_ERR_TYPE, "File URL path must be absolute", 30, "ERR_INVALID_FILE_URL_PATH");
       return NULL;
     }
     /* pathname.slice(1): the leading backslash drops. */
@@ -938,7 +965,7 @@ static ScrStr *scr_url_to_path_impl(ScrUrl *u, bool win32) {
 #endif
     char msg[96];
     int mlen = snprintf(msg, sizeof msg, "File URL host must be \"localhost\" or empty on %s", plat);
-    scr_throw_error_msg(SCR_ERR_TYPE, msg, (size_t)mlen);
+    scr_throw_error_msg_code(SCR_ERR_TYPE, msg, (size_t)mlen, "ERR_INVALID_FILE_URL_HOST");
     return NULL;
   }
   for (size_t i = 0; i < len; i++) {
@@ -948,8 +975,8 @@ static ScrStr *scr_url_to_path_impl(ScrUrl *u, bool win32) {
       if (hi >= 0 && lo >= 0) {
         unsigned char decoded = (unsigned char)((hi << 4) | lo);
         if (decoded == '/') {
-          scr_throw_error_msg(SCR_ERR_TYPE,
-                               "File URL path must not include encoded / characters", 51);
+          scr_throw_error_msg_code(SCR_ERR_TYPE,
+                               "File URL path must not include encoded / characters", 51, "ERR_INVALID_FILE_URL_PATH");
           return NULL;
         }
         i += 2;
@@ -1167,9 +1194,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 +1251,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);

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

@@ -62,43 +62,77 @@ static const char web_prelude[] =
     "   * (host.setTimer/host.clearTimer) — REF'd like Node's (an armed\n"
     "   * timer keeps the process alive), FIFO-ordered against static\n"
     "   * timers on one heap, Node's <1ms clamp. Returns a Timeout-shaped\n"
-    "   * object (ref/unref/refresh/close, numeric via toPrimitive) that\n"
-    "   * clearTimeout/clearInterval accept alongside plain ids; unref is\n"
-    "   * accepted but not honored (the entry stays ref'd — a documented\n"
-    "   * approximation). */\n"
+    "   * object with real ref/unref/refresh/close operations. Immediates\n"
+    "   * use the native check queue, independently of timer ids. */\n"
+    "  const timers = new Map();\n"
     "  class Timeout {\n"
-    "    constructor(fn, delay, repeat) {\n"
+    "    constructor(fn, delay, args, repeat) {\n"
     "      this._fn = fn;\n"
     "      this._delay = delay;\n"
+    "      this._args = args;\n"
     "      this._repeat = repeat;\n"
-    "      this._id = host.setTimer(fn, delay, repeat);\n"
+    "      this._reffed = true;\n"
+    "      this._closed = false;\n"
+    "      this._callback = () => {\n"
+    "        if (!this._repeat) { this._destroyed = true; timers.delete(this._id); }\n"
+    "        this._fn.apply(this, this._args);\n"
+    "      };\n"
+    "      this._arm();\n"
     "    }\n"
-    "    ref() { return this; }\n"
-    "    unref() { return this; }\n"
-    "    hasRef() { return true; }\n"
+    "    _arm() {\n"
+    "      this._destroyed = false;\n"
+    "      this._id = host.setTimer(this._callback, this._delay, this._repeat, false);\n"
+    "      timers.set(this._id, this);\n"
+    "      if (!this._reffed) host.refTimer(this._id, false, false);\n"
+    "    }\n"
+    "    ref() { this._reffed = true; host.refTimer(this._id, true, false); return this; }\n"
+    "    unref() { this._reffed = false; host.refTimer(this._id, false, false); return this; }\n"
+    "    hasRef() { return this._reffed; }\n"
     "    refresh() {\n"
-    "      host.clearTimer(this._id);\n"
-    "      this._id = host.setTimer(this._fn, this._delay, this._repeat);\n"
+    "      if (this._closed) return this;\n"
+    "      if (this._destroyed) this._arm();\n"
+    "      else host.refreshTimer(this._id);\n"
     "      return this;\n"
     "    }\n"
-    "    close() { host.clearTimer(this._id); return this; }\n"
+    "    close() { this._closed = true; this._destroyed = true; timers.delete(this._id); host.clearTimer(this._id, false); return this; }\n"
+    "    [Symbol.dispose]() { this.close(); }\n"
     "    [Symbol.toPrimitive]() { return this._id; }\n"
     "  }\n"
     "  const mkTimer = (fn, ms, args, repeat) => {\n"
     "    if (typeof fn !== 'function') {\n"
     "      throw new TypeError('The \"callback\" argument must be of type function. Received type ' + typeof fn);\n"
     "    }\n"
-    "    const cb = args.length === 0 ? fn : () => fn(...args);\n"
-    "    return new Timeout(cb, Number(ms), repeat);\n"
+    "    return new Timeout(fn, Number(ms), args, repeat);\n"
     "  };\n"
     "  g.setTimeout = (fn, ms, ...args) => mkTimer(fn, ms, args, false);\n"
     "  g.setInterval = (fn, ms, ...args) => mkTimer(fn, ms, args, true);\n"
     "  g.clearTimeout = (t) => {\n"
     "    if (t === undefined || t === null) return;\n"
     "    const id = typeof t === 'number' ? t : Number(t);\n"
-    "    if (Number.isFinite(id)) host.clearTimer(id);\n"
+    "    if (Number.isFinite(id)) {\n"
+    "      const timer = timers.get(id);\n"
+    "      if (timer) timer.close(); else host.clearTimer(id, false);\n"
+    "    }\n"
     "  };\n"
     "  g.clearInterval = g.clearTimeout;\n"
+    "  class Immediate {\n"
+    "    constructor(fn, args) {\n"
+    "      this._reffed = true; this._destroyed = false;\n"
+    "      this._id = host.setTimer(() => {\n"
+    "        this._destroyed = true; this._reffed = false; fn.apply(this, args);\n"
+    "      }, 0, false, true);\n"
+    "    }\n"
+    "    ref() { if (!this._destroyed) { this._reffed = true; host.refTimer(this._id, true, true); } return this; }\n"
+    "    unref() { if (!this._destroyed) { this._reffed = false; host.refTimer(this._id, false, true); } return this; }\n"
+    "    hasRef() { return this._reffed; }\n"
+    "    _close() { this._destroyed = true; this._reffed = false; host.clearTimer(this._id, true); }\n"
+    "    [Symbol.dispose]() { this._close(); }\n"
+    "  }\n"
+    "  g.setImmediate = (fn, ...args) => {\n"
+    "    if (typeof fn !== 'function') throw new TypeError('The \"callback\" argument must be of type function. Received type ' + typeof fn);\n"
+    "    return new Immediate(fn, args);\n"
+    "  };\n"
+    "  g.clearImmediate = (immediate) => { if (immediate instanceof Immediate) immediate._close(); };\n"
     "\n"
     "  class ReadableStream {\n"
     "    constructor(source, _strategy) {\n"
@@ -503,8 +537,41 @@ static const char web_prelude[] =
     "  g.TransformStream = TransformStream;\n"
     "\n"
     "\n"
+    "  const textEncoders = new WeakSet();\n"
     "  class TextEncoder {\n"
+    "    constructor() { textEncoders.add(this); }\n"
     "    get encoding() { return 'utf-8'; }\n"
+    "    encodeInto(src, dest) {\n"
+    "      const fail = (name, expected, value) => {\n"
+    "        let received;\n"
+    "        if (value === null || value === undefined) received = String(value);\n"
+    "        else if (typeof value === 'object' || typeof value === 'function') received = 'an instance of ' + (value.constructor && value.constructor.name || 'Object');\n"
+    "        else if (typeof value === 'string') received = \"type string ('\" + value + \"')\";\n"
+    "        else received = 'type ' + typeof value + ' (' + String(value) + (typeof value === 'bigint' ? 'n' : '') + ')';\n"
+    "        const error = new TypeError('The \"' + name + '\" argument must be ' + expected + '. Received ' + received);\n"
+    "        error.code = 'ERR_INVALID_ARG_TYPE'; throw error;\n"
+    "      };\n"
+    "      if (!textEncoders.has(this)) { const error = new TypeError('Value of \"this\" must be of type TextEncoder'); error.code = 'ERR_INVALID_THIS'; throw error; }\n"
+    "      if (typeof src !== 'string') fail('src', 'of type string', src);\n"
+    "      if (!(dest instanceof Uint8Array)) fail('dest', 'an instance of Uint8Array', dest);\n"
+    "      let read = 0, written = 0;\n"
+    "      while (read < src.length) {\n"
+    "        let cp = src.charCodeAt(read), units = 1;\n"
+    "        if (cp >= 0xd800 && cp <= 0xdbff) {\n"
+    "          const low = src.charCodeAt(read + 1);\n"
+    "          if (low >= 0xdc00 && low <= 0xdfff) { cp = 0x10000 + ((cp - 0xd800) << 10) + low - 0xdc00; units = 2; }\n"
+    "          else cp = 0xfffd;\n"
+    "        } else if (cp >= 0xdc00 && cp <= 0xdfff) cp = 0xfffd;\n"
+    "        const size = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;\n"
+    "        if (written + size > dest.length) break;\n"
+    "        if (size === 1) dest[written++] = cp;\n"
+    "        else if (size === 2) { dest[written++] = 0xc0 | (cp >> 6); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        else if (size === 3) { dest[written++] = 0xe0 | (cp >> 12); dest[written++] = 0x80 | ((cp >> 6) & 63); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        else { dest[written++] = 0xf0 | (cp >> 18); dest[written++] = 0x80 | ((cp >> 12) & 63); dest[written++] = 0x80 | ((cp >> 6) & 63); dest[written++] = 0x80 | (cp & 63); }\n"
+    "        read += units;\n"
+    "      }\n"
+    "      return { read, written };\n"
+    "    }\n"
     "    encode(input) {\n"
     "      const s = input === undefined ? '' : String(input);\n"
     "      const bytes = [];\n"
@@ -891,13 +958,14 @@ static const char web_prelude[] =
     "      const once = !!(options !== null && typeof options === 'object' && options.once);\n"
     "      const list = this._et[t] || (this._et[t] = []);\n"
     "      for (const e of list) { if (e.listener === listener) return; }\n"
-    "      list.push({ listener, once });\n"
+    "      const resistant = !!(options && options[Symbol.for('scriptc.events.resistStopPropagation')]);\n"
+    "      list.push({ listener, once, resistant });\n"
     "    }\n"
     "    removeEventListener(type, listener) {\n"
     "      const list = this._et[String(type)];\n"
     "      if (!list) return;\n"
     "      const i = list.findIndex((e) => e.listener === listener);\n"
-    "      if (i >= 0) list.splice(i, 1);\n"
+    "      if (i >= 0) list.splice(i, 1)[0].removed = true;\n"
     "    }\n"
     "    dispatchEvent(event) {\n"
     "      if (!(event instanceof Event)) throw new TypeError('The \"event\" argument must be an instance of Event.');\n"
@@ -907,7 +975,8 @@ static const char web_prelude[] =
     "      const list = this._et[event.type];\n"
     "      if (list) {\n"
     "        for (const e of [...list]) {\n"
-    "          if (event._stopImmediate) break;\n"
+    "          if (e.removed) continue;\n"
+    "          if (event._stopImmediate && !e.resistant) continue;\n"
     "          if (e.once) this.removeEventListener(event.type, e.listener);\n"
     "          if (typeof e.listener === 'function') e.listener.call(this, event);\n"
     "          else if (e.listener !== null && typeof e.listener.handleEvent === 'function') e.listener.handleEvent(event);\n"
@@ -1054,13 +1123,16 @@ static const char web_prelude[] =
     "    if (s._aborted) return;\n"
     "    s._aborted = true;\n"
     "    s._reason = reason === undefined ? mkAbortError() : reason;\n"
-    "    const ev = { type: 'abort', target: s, currentTarget: s };\n"
+    "    const ev = new Event('abort');\n"
+    "    ev.target = s; ev.currentTarget = s; ev.eventPhase = Event.AT_TARGET; ev.isTrusted = true;\n"
     "    let firstErr;\n"
     "    let threw = false;\n"
     "    if (s._onabort !== null) {\n"
     "      try { s._onabort.call(s, ev); } catch (e) { firstErr = e; threw = true; }\n"
     "    }\n"
     "    for (const l of s._listeners.slice()) {\n"
+    "      if (l.removed) continue;\n"
+    "      if (ev._stopImmediate && !l.resistant) continue;\n"
     "      if (l.once) s.removeEventListener('abort', l.fn);\n"
     "      try { l.fn.call(s, ev); } catch (e) { if (!threw) { firstErr = e; threw = true; } }\n"
     "    }\n"
@@ -1076,13 +1148,15 @@ static const char web_prelude[] =
     "    throwIfAborted() { if (this._aborted) throw this._reason; }\n"
     "    addEventListener(type, fn, options) {\n"
     "      if (String(type) !== 'abort' || typeof fn !== 'function') return;\n"
+    "      if (this._listeners.some(l => l.fn === fn)) return;\n"
     "      const once = options !== undefined && options !== null && !!options.once;\n"
-    "      this._listeners.push({ fn, once });\n"
+    "      const resistant = !!(options && options[Symbol.for('scriptc.events.resistStopPropagation')]);\n"
+    "      this._listeners.push({ fn, once, resistant });\n"
     "    }\n"
     "    removeEventListener(type, fn) {\n"
     "      if (String(type) !== 'abort') return;\n"
     "      const i = this._listeners.findIndex((l) => l.fn === fn);\n"
-    "      if (i >= 0) this._listeners.splice(i, 1);\n"
+    "      if (i >= 0) this._listeners.splice(i, 1)[0].removed = true;\n"
     "    }\n"
     "    static abort(reason) {\n"
     "      const s = mkSignal();\n"
@@ -1633,7 +1707,6 @@ static void web_timer_fire_cb(ScrClosure *env) {
 static JSValue web_host_set_timer(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv) {
   (void)this_val;
-  (void)argc;
   double ms = 0;
   if (JS_ToFloat64(ctx, &ms, argv[1])) return JS_EXCEPTION;
   bool repeat = JS_ToBool(ctx, argv[2]) > 0;
@@ -1649,17 +1722,45 @@ static JSValue web_host_set_timer(JSContext *ctx, JSValueConst this_val,
   scr_box_set_ref(box, h); /* the box owns the +1 */
   ScrClosure *cb = scr_closure_new((void *)web_timer_fire_cb, 1);
   cb->caps[0] = box;
-  double id = repeat ? scr_set_interval(cb, ms) : scr_set_timeout_handle(cb, ms);
+  bool immediate = argc > 3 && JS_ToBool(ctx, argv[3]) > 0;
+  double id = immediate ? scr_set_immediate(cb)
+                        : repeat ? scr_set_interval(cb, ms) : scr_set_timeout_handle(cb, ms);
   return JS_NewFloat64(ctx, id);
 }
 
 static JSValue web_host_clear_timer(JSContext *ctx, JSValueConst this_val,
                                     int argc, JSValueConst *argv) {
   (void)this_val;
+  double id = 0;
+  if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
+  if (argc > 1 && JS_ToBool(ctx, argv[1]) > 0) scr_clear_immediate(id);
+  else scr_clear_interval(id);
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_ref_timer(JSContext *ctx, JSValueConst this_val,
+                                int argc, JSValueConst *argv) {
+  (void)this_val;
+  (void)argc;
+  double id = 0;
+  if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
+  bool reffed = JS_ToBool(ctx, argv[1]) > 0;
+  bool immediate = JS_ToBool(ctx, argv[2]) > 0;
+  if (immediate) {
+    if (reffed) scr_immediate_ref(id); else scr_immediate_unref(id);
+  } else {
+    if (reffed) scr_timer_ref(id); else scr_timer_unref(id);
+  }
+  return JS_UNDEFINED;
+}
+
+static JSValue web_host_refresh_timer(JSContext *ctx, JSValueConst this_val,
+                                    int argc, JSValueConst *argv) {
+  (void)this_val;
   (void)argc;
   double id = 0;
   if (JS_ToFloat64(ctx, &id, argv[0])) return JS_EXCEPTION;
-  scr_clear_interval(id);
+  scr_timer_refresh(id);
   return JS_UNDEFINED;
 }
 
@@ -1837,8 +1938,10 @@ void scr_island_web_boot(void *jsctx) {
   JS_SetPropertyStr(ctx, host, "write", JS_NewCFunction(ctx, web_host_write, "write", 2));
   JS_SetPropertyStr(ctx, host, "tzname", JS_NewCFunction(ctx, web_host_tzname, "tzname", 1));
   JS_SetPropertyStr(ctx, host, "timer", JS_NewCFunction(ctx, web_host_timer, "timer", 2));
-  JS_SetPropertyStr(ctx, host, "setTimer", JS_NewCFunction(ctx, web_host_set_timer, "setTimer", 3));
-  JS_SetPropertyStr(ctx, host, "clearTimer", JS_NewCFunction(ctx, web_host_clear_timer, "clearTimer", 1));
+  JS_SetPropertyStr(ctx, host, "setTimer", JS_NewCFunction(ctx, web_host_set_timer, "setTimer", 4));
+  JS_SetPropertyStr(ctx, host, "clearTimer", JS_NewCFunction(ctx, web_host_clear_timer, "clearTimer", 2));
+  JS_SetPropertyStr(ctx, host, "refTimer", JS_NewCFunction(ctx, web_host_ref_timer, "refTimer", 3));
+  JS_SetPropertyStr(ctx, host, "refreshTimer", JS_NewCFunction(ctx, web_host_refresh_timer, "refreshTimer", 1));
   JSValue r = JS_Call(ctx, fn, JS_UNDEFINED, 1, (JSValueConst *)&host);
   JS_FreeValue(ctx, host);
   JS_FreeValue(ctx, fn);

package/dist/lib/runtime-sources/vendor/v8-number-radix/LICENSE

@@ -0,0 +1,61 @@
+This license applies to all parts of V8 that are not externally
+maintained libraries.  The externally maintained libraries used by V8
+are:
+
+  - PCRE test suite, located in
+    test/mjsunit/third_party/regexp-pcre/regexp-pcre.js.  This is based on the
+    test suite from PCRE-7.3, which is copyrighted by the University
+    of Cambridge and Google, Inc.  The copyright notice and license
+    are embedded in regexp-pcre.js.
+
+  - Layout tests, located in test/mjsunit/third_party/object-keys.  These are
+    based on layout tests from webkit.org which are copyrighted by
+    Apple Computer, Inc. and released under a 3-clause BSD license.
+
+  - Strongtalk assembler, the basis of the files assembler-arm-inl.h,
+    assembler-arm.cc, assembler-arm.h, assembler-ia32-inl.h,
+    assembler-ia32.cc, assembler-ia32.h, assembler-x64-inl.h,
+    assembler-x64.cc, assembler-x64.h, assembler.cc and assembler.h.
+    This code is copyrighted by Sun Microsystems Inc. and released
+    under a 3-clause BSD license.
+
+  - Valgrind client API header, located at third_party/valgrind/valgrind.h
+    This is released under the BSD license.
+
+  - The Wasm C/C++ API headers, located at third_party/wasm-api/wasm.{h,hh}
+    This is released under the Apache license. The API's upstream prototype
+    implementation also formed the basis of V8's implementation in
+    src/wasm/c-api.cc.
+
+These libraries have their own licenses; we recommend you read them,
+as their terms may differ from the terms below.
+
+Further license information can be found in LICENSE files located in
+sub-directories.
+
+Copyright 2014, the V8 project authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/cli-darwin-arm64",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Native scriptc compiler for darwin-arm64",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",