@scriptc/cli-darwin-arm64 0.2.1 → 0.2.2

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

@@ -460,6 +460,12 @@ static void qs_stringify_value(QsBuf *b, const ScrDyn *v) {
 
 ScrStr *scr_qs_stringify(const ScrDyn *obj, const ScrStr *sep,
                          const ScrStr *eq) {
+  if (obj && obj->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(obj);
+    ScrStr *result = view && !scr_exc_pending() ? scr_qs_stringify(view, sep, eq) : NULL;
+    scr_dyn_release(view);
+    return result;
+  }
   const char *sep_b = (sep && sep->len) ? sep->data : "&";
   size_t sep_len = (sep && sep->len) ? sep->len : 1;
   const char *eq_b = (eq && eq->len) ? eq->data : "=";
@@ -475,6 +481,9 @@ ScrStr *scr_qs_stringify(const ScrDyn *obj, const ScrStr *sep,
     const ScrStr *k = kd->v.str;
     const ScrDyn *v = scr_dyn_obj_get(obj, k->data, k->len);
     if (!v) continue; /* unreachable: keys came from the object */
+    ScrDyn *view = v->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(v) : NULL;
+    if (view) v = view;
+    if (scr_exc_pending()) { scr_dyn_release(view); scr_dyn_release(keys); free(fields.data); return NULL; }
     ScrStr *ks = scr_str_encode_uri_component((ScrStr *)k);
     if (v->kind == SCR_DYN_ARR) {
       for (size_t j = 0; j < v->v.arr.len; j++) {
@@ -490,6 +499,7 @@ ScrStr *scr_qs_stringify(const ScrDyn *obj, const ScrStr *sep,
       qs_stringify_value(&fields, v);
     }
     scr_str_release(ks);
+    scr_dyn_release(view);
   }
   scr_dyn_release(keys);
   return qb_take(&fields);

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

@@ -439,8 +439,8 @@ static int scr_regex_start(ScrRegex *re, int len) {
 /* re.exec(s): a fresh string[] of [whole match, ...captures], or NULL
  * for no match (the compiler wraps the `string[] | null` union). Global
  * and sticky regexes start at lastIndex, set it to the match end, and
- * reset it on failure. Nonparticipating captures retain the documented
- * empty-string representation. */
+ * reset it on failure. Nonparticipating captures are present undefined
+ * elements, distinct from participating empty captures and array holes. */
 ScrArr *scr_regex_exec(ScrStr *s, ScrRegex *re) {
   uint8_t *bc = scr_regex_bc(re);
   bool stateful = (lre_get_flags(bc) & (LRE_FLAG_GLOBAL | LRE_FLAG_STICKY)) != 0;
@@ -462,7 +462,7 @@ ScrArr *scr_regex_exec(ScrStr *s, ScrRegex *re) {
     for (int k = 0; k < count; k++) {
       const uint8_t *cs = capture[2 * k], *ce = capture[2 * k + 1];
       if (cs == NULL || ce == NULL) {
-        scr_arr_push_ref(out, scr_str_new("", 0));
+        scr_arr_set_undefined(out, (double)out->len);
       } else {
         scr_arr_push_ref(
             out, scr_str_from_utf16(u, (int)((cs - ubase) >> 1), (int)((ce - ubase) >> 1)));
@@ -525,7 +525,7 @@ double scr_regex_search(ScrStr *s, ScrRegex *re) {
 }
 
 /* matchAll(re): every match as its honest slice string[] (whole match +
- * captures, nonparticipating = "" — match()'s rule) drained EAGERLY into
+ * captures, nonparticipating = undefined — match()'s rule) drained EAGERLY into
  * a fresh string[][]. The lazy iterator is unobservable across the
  * lowered surface: strings are immutable and the spec clones the regex at
  * the call, so nothing can perturb the drain. Non-global regexes throw
@@ -559,7 +559,7 @@ static ScrArr *scr_regex_match_all_core(ScrStr *s, ScrRegex *re, ScrArr *indices
     for (int k = 0; k < capture_count; k++) {
       const uint8_t *cs = capture[2 * k], *ce = capture[2 * k + 1];
       if (cs == NULL || ce == NULL) {
-        scr_arr_push_ref(row, scr_str_new("", 0));
+        scr_arr_set_undefined(row, (double)row->len);
       } else {
         scr_arr_push_ref(
             row, scr_str_from_utf16(u, (int)((cs - ubase) >> 1), (int)((ce - ubase) >> 1)));
@@ -923,6 +923,43 @@ static ScrStr *scr_str_case_conv(const ScrStr *s, int to_lower) {
 ScrStr *scr_str_to_lower(const ScrStr *s) { return scr_str_case_conv(s, 1); }
 ScrStr *scr_str_to_upper(const ScrStr *s) { return scr_str_case_conv(s, 0); }
 
+static void *scr_normalize_realloc(void *opaque, void *ptr, size_t size) {
+  (void)opaque;
+  if (!size) { free(ptr); return NULL; }
+  return realloc(ptr, size);
+}
+
+ScrStr *scr_str_normalize(const ScrStr *s, const ScrStr *form) {
+  UnicodeNormalizationEnum mode;
+  if (form->len == 3 && !memcmp(form->data, "NFC", 3)) mode = UNICODE_NFC;
+  else if (form->len == 3 && !memcmp(form->data, "NFD", 3)) mode = UNICODE_NFD;
+  else if (form->len == 4 && !memcmp(form->data, "NFKC", 4)) mode = UNICODE_NFKC;
+  else if (form->len == 4 && !memcmp(form->data, "NFKD", 4)) mode = UNICODE_NFKD;
+  else {
+    static const char message[] = "The normalization form should be one of NFC, NFD, NFKC, NFKD.";
+    scr_throw_error(SCR_ERR_RANGE, scr_str_new(message, sizeof message - 1));
+    return NULL;
+  }
+  if (s->len > INT32_MAX / sizeof(uint32_t)) scr_regex_oom();
+  uint32_t *input = malloc((s->len + 1) * sizeof(uint32_t));
+  if (!input) scr_regex_oom();
+  int length = 0;
+  for (size_t offset = 0; offset < s->len;) {
+    size_t step;
+    input[length++] = scr_case_decode(s->data + offset, &step);
+    offset += step;
+  }
+  uint32_t *output = NULL;
+  int count = unicode_normalize(&output, input, length, mode, NULL, scr_normalize_realloc);
+  free(input);
+  if (count < 0) scr_regex_oom();
+  ScrJsonBuf buffer;
+  scr_jb_init(&buffer);
+  for (int i = 0; i < count; i++) scr_case_put_cp(&buffer, output[i]);
+  free(output);
+  return scr_jb_finish(&buffer);
+}
+
 /* ── assert.match / assert.doesNotMatch ──────────────────────────────────
  * Lives here because it needs the matcher. Assertion matching follows
  * RegExp.test, including global and sticky lastIndex transitions. */

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

@@ -522,6 +522,13 @@ struct ScrDyn *scr_dyn_class_base_prototype(struct ScrDyn *constructor);
 struct ScrDyn *scr_dyn_class_inherit(struct ScrDyn *constructor, struct ScrDyn *base);
 void scr_dyn_class_super(struct ScrDyn *constructor, struct ScrDyn *receiver, struct ScrDyn *arguments);
 struct ScrDyn *scr_dyn_assign_prototype(struct ScrDyn *target, struct ScrDyn *sources, struct ScrDyn *protected_keys);
+struct ScrDyn *scr_dyn_bag_get(struct ScrDyn *bag, ScrStr *key, struct ScrDyn *receiver);
+struct ScrDyn *scr_dyn_reflect_get(struct ScrDyn *target, struct ScrDyn *key, struct ScrDyn *receiver);
+bool scr_dyn_reflect_set(struct ScrDyn *target, struct ScrDyn *key, struct ScrDyn *value, struct ScrDyn *receiver);
+bool scr_dyn_reflect_define(struct ScrDyn *receiver, struct ScrDyn *key, struct ScrDyn *value);
+bool scr_dyn_abstract_eq(const struct ScrDyn *left, const struct ScrDyn *right);
+int scr_dyn_function_kind(const struct ScrDyn *value);
+void scr_dyn_bag_set(struct ScrDyn *bag, ScrStr *key, struct ScrDyn *value, struct ScrDyn *receiver);
 /* The keyed-write miss on a fixed-shape record: throws the catchable
  * TypeError naming the key (JS would add the property — the documented
  * monomorphic-struct divergence). scr_object.c. */
@@ -772,6 +779,7 @@ ScrStr *scr_str_trim(ScrStr *s);
  * sets the regex link flag for case-conversion sites). Borrow s; +1. */
 ScrStr *scr_str_to_lower(const ScrStr *s);
 ScrStr *scr_str_to_upper(const ScrStr *s);
+ScrStr *scr_str_normalize(const ScrStr *s, const ScrStr *form);
 
 /* charAt(i): 1-code-unit string; out of range → empty string. Half of an
  * astral pair → U+FFFD (divergence, see above). Returns +1. */
@@ -904,6 +912,12 @@ void scr_qs_parse_into(ScrMap *out, const ScrStr *qs, const ScrStr *sep,
  * Borrows config; returns +1, or NULL with a Node-coded TypeError pending. */
 struct ScrDyn *scr_util_parse_args(const struct ScrDyn *config);
 
+/* Node 24's dotenv grammar, shared by util.parseEnv and process.loadEnvFile.
+ * Arguments are borrowed; parseEnv returns a fresh ordinary object (+1).
+ * Validation and file failures leave a coded exception pending. */
+struct ScrDyn *scr_util_parse_env(const struct ScrDyn *content);
+void scr_process_load_env_file(const struct ScrDyn *path);
+
 /* querystring.stringify — Node's stringify over a borrowed dyn value (the
  * frontend dynFroms the typed record; JS-world dyn values pass straight
  * through). Non-object dyn values answer "" like Node; object keys iterate in
@@ -1545,7 +1559,7 @@ typedef struct ScrClosure {
    * (like the dyn→closure edge): a cycle through it is merely never
    * collected. */
   ScrBox *props;
-  uint32_t function_kind; /* low bits: 0 ordinary, 1 generator, 2 async, 3 async generator; bit 2: ordinary own prototype */
+  uint32_t function_kind; /* low bits: 0 ordinary, 1 generator, 2 async, 3 async generator; bit 2: ordinary own prototype; bit 3: checked callable adapter in caps[0] */
   ScrBox *caps[];
 } ScrClosure;
 
@@ -2599,6 +2613,8 @@ ScrStats *scr_fs_lstat(ScrStr *path); /* +1, or throws; NO follow (lstat) */
 ScrStats *scr_fs_fstat(double fd); /* +1, or throws */
 void scr_fs_fchmod(double fd, double mode);
 void scr_fs_fsync(double fd);
+void scr_fs_fdatasync(double fd);
+void scr_fs_ftruncate(double fd, double length);
 void scr_fs_link(ScrStr *source, ScrStr *dest);
 ScrStats *scr_stats_retain(ScrStats *s);
 void scr_stats_release(ScrStats *s);
@@ -3053,22 +3069,33 @@ ScrBytes *scr_crypto_random_fill_rest(ScrBytes *bytes, double offset);
 double scr_crypto_random_int(double min, double max);
 ScrBytes *scr_crypto_pbkdf2(ScrBytes *password, ScrBytes *salt,
                             double iterations, double keylen, ScrStr *digest);
-typedef void (*ScrCryptoBytesFn)(ScrClosure *cb, ScrBytes *value /* moves */);
-void scr_crypto_defer_bytes(ScrBytes *value /* moves */, ScrClosure *cb /* moves */,
+ScrBytes *scr_crypto_hkdf_bytes(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                                ScrBytes *info, double keylen);
+ScrDyn *scr_crypto_hkdf(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                       ScrBytes *info, double keylen);
+ScrBytes *scr_crypto_scrypt(ScrBytes *password, ScrBytes *salt, double keylen, ScrDyn *options);
+ScrBytes *scr_crypto_scrypt_derive(ScrBytes *password, ScrBytes *salt, double keylen,
+                                  double n, double r, double p, double maxmem);
+typedef void (*ScrCryptoBytesFn)(ScrClosure *cb, ScrError *error /* borrowed */, ScrBytes *value /* moves */);
+void scr_crypto_defer_bytes(ScrBytes *value /* moves */, ScrError *error /* moves */, ScrClosure *cb /* moves */,
                             ScrCryptoBytesFn fn);
 void scr_crypto_random_bytes_async(double size, ScrClosure *cb /* moves */,
                                    ScrCryptoBytesFn fn);
 void scr_crypto_pbkdf2_async(ScrBytes *password, ScrBytes *salt,
                              double iterations, double keylen, ScrStr *digest,
                              ScrClosure *cb /* moves */, ScrCryptoBytesFn fn);
-/* One-shot raw digest/HMAC by algorithm name ("md5" | "sha1" | "sha256")
+void scr_crypto_hkdf_async(ScrStr *digest, ScrBytes *ikm, ScrBytes *salt,
+                           ScrBytes *info, double keylen, ScrClosure *cb, ScrCryptoBytesFn fn);
+void scr_crypto_scrypt_async(ScrBytes *password, ScrBytes *salt, double keylen,
+                             ScrDyn *options, ScrClosure *cb, ScrCryptoBytesFn fn);
+/* One-shot raw digest/HMAC by algorithm name ("md5", "sha1", and SHA-2)
  * — the island crypto shim's bridge (scr_island.c host hooks). Digest
- * bytes into out (≥32); returns the digest length, 0 for an unknown
+ * bytes into out (≥64); returns the digest length, 0 for an unknown
  * algorithm. */
 size_t scr_crypto_digest_raw(const char *alg, const unsigned char *data, size_t len,
-                             unsigned char out[32]);
+                             unsigned char out[64]);
 size_t scr_crypto_hmac_raw(const char *alg, const unsigned char *key, size_t keylen,
-                           const unsigned char *data, size_t len, unsigned char out[32]);
+                           const unsigned char *data, size_t len, unsigned char out[64]);
 /* The composed `new crypto.X509Certificate(data).fingerprint` read (the
  * handle never materializes): the SHA-1 of the DER, uppercase
  * colon-separated — PEM or raw-DER input; anything else throws Node's
@@ -3129,6 +3156,9 @@ ScrStr *scr_path_win32_to_namespaced_path(ScrStr *path);
  * The pair behind spawn's fd-stdio form. */
 double scr_fs_open(ScrStr *path, ScrStr *flags);
 double scr_fs_open_numeric(ScrStr *path, double flags, double mode);
+/* Engine callers supply the target OS's flags, rather than the frontend's
+ * portable constant mask. Argument validation happens before this seam. */
+double scr_fs_open_native(ScrStr *path, double flags, double mode);
 ScrFileHandle *scr_file_handle_open(ScrStr *path, ScrStr *flags, double mode);
 ScrFileHandle *scr_file_handle_retain(ScrFileHandle *h);
 void scr_file_handle_release(ScrFileHandle *h);
@@ -3136,6 +3166,12 @@ void *scr_file_handle_retain_v(void *p);
 void scr_file_handle_release_v(void *p);
 double scr_file_handle_fd(ScrFileHandle *h);
 void scr_file_handle_close(ScrFileHandle *h);
+ScrPromise *scr_file_handle_sync_promise(ScrFileHandle *h);
+ScrPromise *scr_file_handle_datasync_promise(ScrFileHandle *h);
+ScrPromise *scr_file_handle_truncate_promise(ScrFileHandle *h, double length);
+ScrPromise *scr_file_handle_chmod_promise(ScrFileHandle *h, double mode);
+double scr_file_handle_readv(ScrFileHandle *h, ScrArr *buffers, double position);
+double scr_file_handle_writev(ScrFileHandle *h, ScrArr *buffers, double position);
 double scr_file_handle_read(ScrFileHandle *h, ScrBytes *buf, double offset,
                             double length, double position, bool length_default);
 double scr_file_handle_write_bytes(ScrFileHandle *h, ScrBytes *buf,
@@ -3159,6 +3195,11 @@ double scr_fs_write_sync(double fd, ScrBytes *buf, double offset, double length,
                          double position);
 double scr_fs_write_str_sync(double fd, ScrStr *data, double position,
                              ScrStr *encoding);
+double scr_fs_readv_sync(double fd, ScrArr *buffers, double position);
+double scr_fs_writev_sync(double fd, ScrArr *buffers, double position);
+/* Unlike scalar readSync's zero-length fast path, a nonempty vector of
+ * empty views still tests the descriptor and positioned-read capability. */
+double scr_fs_read_zero(double fd, double position);
 void scr_fs_close(double fd);
 
 /* ── WHATWG URL (scr_url.c) ──────────────────────────────────────────
@@ -3177,6 +3218,10 @@ typedef struct ScrUrl ScrUrl;
 
 ScrUrl *scr_url_new(ScrStr *input); /* +1, or throws */
 ScrUrl *scr_url_new_base(ScrStr *input, ScrStr *base); /* +1, or throws */
+bool scr_url_can_parse(ScrStr *input);
+bool scr_url_can_parse_base(ScrStr *input, ScrStr *base);
+ScrDyn *scr_url_parse(ScrStr *input); /* +1 native URL or null; invalid URLs do not throw */
+ScrDyn *scr_url_parse_base(ScrStr *input, ScrStr *base);
 ScrUrl *scr_url_retain(ScrUrl *u);
 void scr_url_release(ScrUrl *u);
 void *scr_url_retain_v(void *p);
@@ -3607,7 +3652,7 @@ struct ScrDyn {
     ScrBigInt *bigint; /* owned (SCR_DYN_BIGINT) */
     /* Callbacks keep the optional symbol unit out of symbol-free binaries. */
     struct { ScrSym *value; void (*release)(ScrSym *); ScrStr *(*render)(ScrSym *); ScrStr *(*description)(ScrSym *); } symbol;
-    struct { size_t len; size_t cap; ScrDyn **items; struct ScrDyn *properties; bool sealed; bool frozen; } arr; /* owned */
+    struct { size_t len; size_t cap; ScrDyn **items; struct ScrDyn *properties; bool sealed; bool frozen; unsigned char *presence; } arr; /* owned; NULL presence means dense */
     struct {
       size_t len;
       size_t cap;
@@ -3781,6 +3826,7 @@ ScrSym *scr_sym_well_known(ScrStr *name);
 ScrDyn *scr_dyn_symbol_get(const ScrDyn *value, const ScrStr *key);
 ScrDyn *scr_dyn_symbol_key_get(const ScrDyn *value, const ScrDyn *key, bool optional);
 void scr_dyn_symbol_key_set(ScrDyn *value, ScrDyn *key, ScrDyn *stored);
+void scr_dyn_symbol_key_placeholder(ScrDyn *value, ScrDyn *key);
 bool scr_dyn_has_key_computed(const ScrDyn *value, const ScrDyn *key);
 bool scr_dyn_has_own_computed(const ScrDyn *value, const ScrDyn *key);
 bool scr_dyn_property_is_enumerable_computed(const ScrDyn *value, const ScrDyn *key);
@@ -3793,6 +3839,9 @@ ScrDyn *scr_dyn_increment(const ScrDyn *value, bool increment);
 ScrDyn *scr_dyn_symbol_ref(ScrSym *value, void (*release)(ScrSym *), ScrStr *(*render)(ScrSym *), ScrStr *(*description)(ScrSym *));
 ScrDyn *scr_dyn_new_str(ScrStr *s);
 ScrDyn *scr_dyn_new_arr(void);
+ScrDyn *scr_dyn_array_constructor(void);
+bool scr_dyn_arr_has_index(const ScrDyn *arr, size_t index);
+void scr_dyn_arr_push_hole(ScrDyn *arr);
 ScrDyn *scr_dyn_new_obj(void);
 ScrDyn *scr_dyn_iterator(const ScrDyn *value, const ScrStr *spell);
 ScrDyn *scr_dyn_iterator_optional(const ScrDyn *value);
@@ -3823,6 +3872,7 @@ bool scr_dyn_is_extensible(ScrDyn *object);
 ScrDyn *scr_dyn_seal(ScrDyn *object);
 bool scr_dyn_is_sealed(const ScrDyn *object);
 ScrDyn *scr_dyn_proxy_new(const ScrDyn *target, const ScrDyn *handler);
+bool scr_dyn_is_callable(const ScrDyn *value);
 ScrDyn *scr_dyn_proxy_get(const ScrDyn *proxy, const ScrStr *key);
 bool scr_dyn_proxy_has(const ScrDyn *proxy, const ScrStr *key);
 ScrDyn *scr_dyn_own_descriptor(const ScrDyn *value, const ScrStr *key);
@@ -3969,6 +4019,7 @@ bool scr_dyn_number_coerce_js(const ScrDyn *d, double *out);
 double scr_dyn_number_coerce(const ScrDyn *d);
 double scr_dyn_number_constructor(const ScrDyn *d);
 ScrBigInt *scr_dyn_bigint_constructor(const ScrDyn *d);
+ScrBigInt *scr_dyn_bigint_coerce(const ScrDyn *d);
 ScrDyn *scr_dyn_add(const ScrDyn *left, const ScrDyn *right); /* borrowed; +1 or NULL/pending */
 ScrDyn *scr_dyn_arithmetic(const ScrDyn *left, const ScrDyn *right, const ScrStr *operation);
 bool scr_dyn_compare(const ScrDyn *left, const ScrDyn *right, const ScrStr *operation);
@@ -4045,6 +4096,7 @@ ScrDyn *scr_dyn_fn_get(const ScrDyn *d, const char *key, size_t key_len);
  * Returns the target (+1, JS's return), or NULL with a pending catchable
  * TypeError (non-object target/descriptor — Node's messages). */
 ScrDyn *scr_dyn_define_props(ScrDyn *target, ScrDyn *descs);
+ScrDyn *scr_dyn_define_prototype_props(ScrDyn *target, ScrDyn *descs, ScrDyn *protected_keys);
 /* Boxes a closure as a callable dyn value. Ownership of `clo` MOVES in
  * (callers retain first when they keep their own reference); `sig`/`name`
  * must be static literals (the box never frees them; name may be NULL). */
@@ -4185,6 +4237,7 @@ ScrDyn *scr_dyn_new_promise_adapting(ScrPromise *src,
                                      void (*adapt)(ScrPromise *dst, ScrPromise *src));
 /* BORROWED peek at the boxed promise; NULL when d is not a promise box. */
 ScrPromise *scr_dyn_promise_of(const ScrDyn *d);
+ScrPromise *scr_dyn_promise_all(const ScrDyn *entries);
 
 /* ── island values in the checked-dynamic tree (SCR_DYN_JSVAL) ─────────────────────────
  * Engine routing ops for JSVAL nodes, installed by the gated constructor
@@ -4513,6 +4566,7 @@ void scr_promise_rethrow_top_level(ScrPromise *p);
  * payload as a dyn value (+1; void fulfillments answer the undefined
  * value), or NULL with the rejection re-thrown into the awaiter. */
 ScrDyn *scr_await_dyn(ScrPromise *p);
+ScrDyn *scr_await_dyn_value_settled(ScrDyn *value);
 void scr_promise_resolve_dyn(ScrPromise *destination, ScrDyn *value);
 /* `await v` over a checked-dynamic VALUE: dyn promises adopt, everything
  * else takes JS's one-hop non-thenable await and answers itself (+1). */
@@ -5821,6 +5875,11 @@ ScrStr *scr_bytes_to_str_checked_range(const ScrBytes *b, const ScrStr *enc, dou
  * stripped. Borrows; +1; never throws. */
 ScrStr *scr_text_decode(const ScrBytes *b);
 double scr_text_decoder_encoding(const ScrDyn *label);
+ScrStr *scr_text_decoder_name(double encoding);
+ScrDyn *scr_text_encode_into(const ScrDyn *source, const ScrDyn *destination);
+bool scr_buffer_is_ascii(const ScrDyn *input);
+bool scr_buffer_is_utf8(const ScrDyn *input);
+ScrBytes *scr_buffer_transcode(const ScrDyn *source, const ScrDyn *from, const ScrDyn *to);
 ScrBytes *scr_bytes_buffer_source(const ScrDyn *value);
 ScrStr *scr_text_decode_buffer_source(const ScrDyn *value);
 ScrStr *scr_text_decode_options(const ScrBytes *b, bool fatal, bool ignore_bom);

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

@@ -72,18 +72,18 @@ static const struct { const char *label; int encoding; } scr_td_labels[] = {
   {"iso_8859-7:1987", 6},
   {"sun_eu_greek", 6},
   {"csiso88598e", 7},
-  {"csiso88598i", 7},
+  {"csiso88598i", 36},
   {"csisolatinhebrew", 7},
   {"hebrew", 7},
   {"iso-8859-8", 7},
   {"iso-8859-8-e", 7},
-  {"iso-8859-8-i", 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", 7},
+  {"logical", 36},
   {"visual", 7},
   {"csisolatin6", 8},
   {"iso-8859-10", 8},
@@ -184,16 +184,16 @@ static const struct { const char *label; int encoding; } scr_td_labels[] = {
   {"utf-16le", 28},
   {"unicodefffe", 29},
   {"utf-16be", 29},
-  {"chinese", 30},
-  {"csgb2312", 30},
-  {"csiso58gb231280", 30},
+  {"chinese", 37},
+  {"csgb2312", 37},
+  {"csiso58gb231280", 37},
   {"gb18030", 30},
-  {"gb2312", 30},
-  {"gb_2312", 30},
-  {"gb_2312-80", 30},
-  {"gbk", 30},
-  {"iso-ir-58", 30},
-  {"x-gbk", 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},

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;