@scriptc/cli-darwin-x64 0.2.1 → 0.2.3

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

@@ -649,6 +649,14 @@ void scr_map_dyn_set(ScrMap *map, const ScrDyn *key, const ScrDyn *value, bool s
   scr_map_release_key(map, key_slot);
 }
 
+ScrArr *scr_set_to_arr_dyn(const ScrMap *map) {
+  ScrArr *out = scr_arr_new_ref(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v, map->nlive);
+  for (size_t i = 0; i < map->nentries; i++) {
+    if (scr_map_iter_live(map, (double)i)) scr_arr_push_ref(out, scr_map_dyn_key(map, (double)i));
+  }
+  return out;
+}
+
 void *scr_map_iter_val_ref(const ScrMap *m, double i) {
   return m->val_retain(scr_map_slot_to_ptr(scr_map_iter_at(m, i)->val)); /* +1 */
 }

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

@@ -1,11 +1,89 @@
 /* Native builtin export objects. The compiler supplies the existing static
  * callable implementations; this unit owns lookup, identity, and mutations. */
 #include "scr_runtime.h"
+#include "scr_system_errors.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 
+typedef struct { int value; const char *name; const char *message; } ScrSystemError;
+#define SCR_SYSTEM_ERROR(name, message) { SCR_NODE_UV__##name, #name, message },
+static const ScrSystemError scr_system_errors[] = {
+  SCR_NODE_UV_ERRNO_MAP(SCR_SYSTEM_ERROR)
+};
+#undef SCR_SYSTEM_ERROR
+
+static bool scr_system_error_number(const ScrDyn *error, double *number) {
+  if (!error || error->kind != SCR_DYN_NUM) {
+    scr_dyn_arg_type_fail("err", "of type number", error ? error : scr_dyn_undefined());
+    return false;
+  }
+  double n = error->v.num;
+  if (!(isfinite(n) && n < 0 && trunc(n) == n && n >= -9007199254740991.0)) {
+    char received[48];
+    scr_num_received(n, received);
+    if (n == 0 && signbit(n)) strcpy(received, "-0");
+    ScrJsonBuf buffer;
+    scr_jb_init(&buffer);
+    scr_jb_puts(&buffer, "The value of \"err\" is out of range. It must be a negative integer. Received ");
+    scr_jb_puts(&buffer, received);
+    ScrStr *message = scr_jb_finish(&buffer);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, message->data, message->len, "ERR_OUT_OF_RANGE");
+    scr_str_release(message);
+    return false;
+  }
+  *number = n;
+  return true;
+}
+
+static ScrStr *scr_system_error_lookup(double number, bool message) {
+  /* Node's name helper looks up the original safe integer. Its message
+   * binding uses V8's saturating Int32 extraction instead. */
+  double lookup = message && number < -2147483648.0 ? -2147483648.0 : number;
+  for (size_t i = 0; i < sizeof scr_system_errors / sizeof scr_system_errors[0]; i++) {
+    if (lookup == scr_system_errors[i].value) {
+      const char *text = message ? scr_system_errors[i].message : scr_system_errors[i].name;
+      return scr_str_new(text, strlen(text));
+    }
+  }
+  ScrJsonBuf buffer;
+  scr_jb_init(&buffer);
+  scr_jb_puts(&buffer, "Unknown system error ");
+  ScrStr *rendered = scr_f64_to_scrstr(lookup);
+  scr_jb_put_str(&buffer, rendered);
+  scr_str_release(rendered);
+  return scr_jb_finish(&buffer);
+}
+
+ScrStr *scr_util_system_error_name(const ScrDyn *error) {
+  double number;
+  return scr_system_error_number(error, &number) ? scr_system_error_lookup(number, false) : NULL;
+}
+
+ScrStr *scr_util_system_error_message(const ScrDyn *error) {
+  double number;
+  return scr_system_error_number(error, &number) ? scr_system_error_lookup(number, true) : NULL;
+}
+
+ScrDyn *scr_util_system_error_entries(void) {
+  ScrDyn *entries = scr_dyn_new_arr();
+  for (size_t i = 0; i < sizeof scr_system_errors / sizeof scr_system_errors[0]; i++) {
+    const ScrSystemError *error = &scr_system_errors[i];
+    ScrDyn *entry = scr_dyn_new_arr(), *pair = scr_dyn_new_arr();
+    ScrStr *name = scr_str_new(error->name, strlen(error->name));
+    ScrStr *message = scr_str_new(error->message, strlen(error->message));
+    scr_dyn_arr_push(pair, scr_dyn_new_str(name));
+    scr_dyn_arr_push(pair, scr_dyn_new_str(message));
+    scr_str_release(name);
+    scr_str_release(message);
+    scr_dyn_arr_push(entry, scr_dyn_new_num(error->value));
+    scr_dyn_arr_push(entry, pair);
+    scr_dyn_arr_push(entries, entry);
+  }
+  return entries;
+}
+
 static SCR_TL ScrDyn *scr_global_known;
 static SCR_TL ScrDyn *scr_global_own;
 static SCR_TL bool scr_global_cleanup_registered;

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)));
@@ -719,6 +719,60 @@ ScrStr *scr_regex_replace(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   return scr_replace_impl(s, re, rep);
 }
 
+
+/* The pinned Node ANSI matcher derives from ansi-regex, copyright (c)
+ * Sindre Sorhus <sindresorhus@gmail.com>, used under the MIT license:
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * Keep the pattern equivalent to Node v24.15.0 internal/util/inspect.js. */
+#define SCR_VT_PATTERN "[\\u001B\\u009B][[\\]()#;?]*" \
+  "(?:(?:(?:(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]+)*" \
+  "|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]*)*)?" \
+  "(?:\\u0007|\\u001B\\u005C|\\u009C))" \
+  "|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+
+ScrStr *scr_util_strip_vt(const ScrDyn *input) {
+  if (!input || input->kind != SCR_DYN_STR) {
+    scr_dyn_arg_type_fail("str", "of type string", input ? input : scr_dyn_undefined());
+    return NULL;
+  }
+  ScrStr *subject = input->v.str;
+  bool escape = false;
+  for (size_t i = 0; i < subject->len; i++) {
+    if (subject->data[i] == '\x1b' || ((unsigned char)subject->data[i] == 0xc2 &&
+        i + 1 < subject->len && (unsigned char)subject->data[i + 1] == 0x9b)) {
+      escape = true;
+      break;
+    }
+  }
+  if (!escape) return scr_str_retain(subject);
+  static const struct { size_t rc, len, cap; char data[sizeof SCR_VT_PATTERN]; }
+    source = { SIZE_MAX, sizeof SCR_VT_PATTERN - 1, sizeof SCR_VT_PATTERN - 1, SCR_VT_PATTERN };
+  static const struct { size_t rc, len, cap; char data[2]; }
+    flags = { SIZE_MAX, 1, 1, "g" };
+  static SCR_TL ScrRegex template = { SIZE_MAX, (ScrStr *)&source, (ScrStr *)&flags, NULL, 0, NULL };
+  ScrRegex *regex = scr_regex_literal(&template);
+  ScrStr *empty = scr_str_new("", 0);
+  ScrStr *result = scr_regex_replace(subject, regex, empty);
+  scr_str_release(empty);
+  scr_regex_release(regex);
+  return result;
+}
+#undef SCR_VT_PATTERN
+
 ScrStr *scr_regex_replace_all(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   if (!(lre_get_flags(scr_regex_bc(re)) & LRE_FLAG_GLOBAL)) {
     /* Node's exact TypeError — a real instance now: catch bindings narrow
@@ -923,6 +977,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. */
@@ -1021,6 +1112,17 @@ bool scr_assert_regex_err_test(ScrRegex *re, ScrError *err) {
   return matched;
 }
 
+bool scr_assert_regex_dyn_test(ScrRegex *re, ScrDyn *actual) {
+  // String(symbol) accepts a direct Symbol; object conversion uses the
+  // string hint, including Symbol.toPrimitive and custom Error formatters.
+  ScrStr *str = actual->kind == SCR_DYN_SYMBOL
+    ? scr_dyn_string_constructor(actual) : scr_util_to_usv_string(actual);
+  if (!str) return false;
+  bool matched = scr_assert_regex_hits(re, str);
+  scr_str_release(str);
+  return matched;
+}
+
 /* The regex-valued shape slot (assert.throws(fn, {message: /re/})):
  * test the stashed actual key eagerly and store verdict + rendering, so
  * scr_assert.c's comparison and diff stay libregexp-free. An absent