@mikrojs/quickjs 0.18.1 → 0.18.2

package/deps/quickjs/api-test.c

@@ -2,6 +2,7 @@
 #undef NDEBUG
 #endif
 #include <assert.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "quickjs.h"
@@ -928,6 +929,59 @@ static void new_errors(void)
     JS_FreeRuntime(rt);
 }
 
+// JS_NewContext() already installs DOMException by way of
+// JS_AddIntrinsicAToB(), so a host that also calls JS_AddIntrinsicDOMException()
+// explicitly installs it twice. The second install must release the prototype
+// the first one left in ctx->class_proto[] instead of overwriting the slot;
+// new_runtime() aborts at JS_FreeRuntime() if it does not.
+static void dom_exception_added_twice(void)
+{
+    JSValue ret;
+    const char *s;
+    int i;
+
+    JSRuntime *rt = new_runtime();
+    JSContext *ctx = JS_NewContext(rt);
+
+    // the implicit install left a working DOMException behind
+    ret = eval(ctx, "DOMException.prototype === "
+                    "Object.getPrototypeOf(new DOMException)");
+    assert(JS_ToBool(ctx, ret) == true);
+    JS_FreeValue(ctx, ret);
+
+    // installing it again, repeatedly, must not leak the previous prototype
+    for (i = 0; i < 3; i++)
+        assert(JS_AddIntrinsicDOMException(ctx) == 0);
+
+    // and the class prototype still matches the global constructor, i.e. the
+    // slot tracks the newest install rather than a freed or stale object
+    ret = eval(ctx, "DOMException.prototype === "
+                    "Object.getPrototypeOf(new DOMException)");
+    assert(JS_ToBool(ctx, ret) == true);
+    JS_FreeValue(ctx, ret);
+
+    ret = eval(ctx, "new DOMException('m', 'InvalidCharacterError').name");
+    assert(!JS_IsException(ret));
+    s = JS_ToCString(ctx, ret);
+    assert(s);
+    assert(!strcmp(s, "InvalidCharacterError"));
+    JS_FreeCString(ctx, s);
+    JS_FreeValue(ctx, ret);
+
+    // the internally thrown DOMExceptions pick up the current prototype too
+    ret = eval(ctx, "try { atob('a') } catch (e) { "
+                    "  e instanceof DOMException && e.name } ");
+    assert(!JS_IsException(ret));
+    s = JS_ToCString(ctx, ret);
+    assert(s);
+    assert(!strcmp(s, "InvalidCharacterError"));
+    JS_FreeCString(ctx, s);
+    JS_FreeValue(ctx, ret);
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
 static void backtrace_oom_callsite_array(void)
 {
     static const char setup_code[] =
@@ -1822,6 +1876,182 @@ static void transfer_default_managed_array_buffer(void)
     JS_FreeRuntime(rt);
 }
 
+static void get_class_name(void)
+{
+    static const struct {
+        const char *code;
+        const char *name;
+    } builtins[] = {
+        { "({})",               "Object" },
+        { "[]",                 "Array" },
+        { "new Error()",        "Error" },
+        { "new Date()",         "Date" },
+        { "/re/",               "RegExp" },
+        { "new Map()",          "Map" },
+        { "new ArrayBuffer(0)", "ArrayBuffer" },
+        { "new Uint8Array(0)",  "Uint8Array" },
+        { "(function(){})",     "Function" },
+    };
+    JSClassDef def = (JSClassDef){ .class_name = "MyClass" };
+    JSClassID class_id, unregistered_class_id;
+    JSAtom atom, expected;
+    JSRuntime *rt;
+    JSContext *ctx;
+    const char *s;
+    JSValue obj;
+    size_t i;
+
+    rt = new_runtime();
+    class_id = 0;
+    JS_NewClassID(rt, &class_id);
+    assert(0 == JS_NewClass(rt, class_id, &def));
+
+    /* handed out by JS_NewClassID() but never passed to JS_NewClass() */
+    unregistered_class_id = 0;
+    JS_NewClassID(rt, &unregistered_class_id);
+
+    ctx = JS_NewContext(rt);
+
+    /* the name of a class registered from C, not its class id */
+    expected = JS_NewAtom(ctx, "MyClass");
+    atom = JS_GetClassName(rt, class_id);
+    assert(atom == expected);
+    s = JS_AtomToCString(ctx, atom);
+    assert(s);
+    assert(!strcmp(s, "MyClass"));
+    JS_FreeCString(ctx, s);
+    JS_FreeAtom(ctx, atom);
+    JS_FreeAtom(ctx, expected);
+
+    /* the names of the built-in classes */
+    for (i = 0; i < countof(builtins); i++) {
+        obj = eval(ctx, builtins[i].code);
+        assert(!JS_IsException(obj));
+        atom = JS_GetClassName(rt, JS_GetClassID(obj));
+        assert(atom != JS_ATOM_NULL);
+        s = JS_AtomToCString(ctx, atom);
+        assert(s);
+        assert(!strcmp(s, builtins[i].name));
+        JS_FreeCString(ctx, s);
+        JS_FreeAtom(ctx, atom);
+        JS_FreeValue(ctx, obj);
+    }
+
+    /* class ids without a registered class have no name */
+    assert(JS_ATOM_NULL == JS_GetClassName(rt, JS_INVALID_CLASS_ID));
+    assert(JS_ATOM_NULL == JS_GetClassName(rt, unregistered_class_id));
+    assert(JS_ATOM_NULL == JS_GetClassName(rt, class_id + 4096));
+
+    /* the caller owns the returned atom; the class keeps its own reference,
+       so releasing it repeatedly doesn't free the name out from under it */
+    for (i = 0; i < 64; i++)
+        JS_FreeAtom(ctx, JS_GetClassName(rt, class_id));
+    atom = JS_GetClassName(rt, class_id);
+    s = JS_AtomToCString(ctx, atom);
+    assert(s);
+    assert(!strcmp(s, "MyClass"));
+    JS_FreeCString(ctx, s);
+    JS_FreeAtom(ctx, atom);
+
+    /* every registered class has a name, and it is a name rather than a
+       number: returning the class id instead produced a valid-looking atom,
+       either an unrelated predefined one for a small id or the id spelled out
+       in decimal for a large one, so check the whole table rather than the
+       handful of classes spelled out above */
+    {
+        JSClassID id;
+        int registered = 0;
+
+        for (id = 1; id < class_id + 16; id++) {
+            char decimal[32];
+            if (!JS_IsRegisteredClass(rt, id))
+                continue;
+            registered++;
+            atom = JS_GetClassName(rt, id);
+            assert(atom != JS_ATOM_NULL);
+            s = JS_AtomToCString(ctx, atom);
+            assert(s);
+            // a few internal classes are deliberately unnamed, but none is
+            // named after a number
+            snprintf(decimal, sizeof(decimal), "%u", (unsigned)id);
+            assert(strcmp(s, decimal));
+            assert(s[0] < '0' || s[0] > '9');
+            JS_FreeCString(ctx, s);
+            JS_FreeAtom(ctx, atom);
+        }
+        /* the built-ins alone are far more than this */
+        assert(registered > 20);
+    }
+
+    /* two classes sharing a name share the interned atom, and the name does
+       not depend on which context asks */
+    {
+        JSClassDef def2 = (JSClassDef){ .class_name = "MyClass" };
+        JSClassID class_id2 = 0;
+        JSContext *ctx2;
+        JSAtom a1, a2;
+
+        JS_NewClassID(rt, &class_id2);
+        assert(0 == JS_NewClass(rt, class_id2, &def2));
+        assert(class_id2 != class_id);
+
+        a1 = JS_GetClassName(rt, class_id);
+        a2 = JS_GetClassName(rt, class_id2);
+        assert(a1 == a2);
+        JS_FreeAtom(ctx, a1);
+        JS_FreeAtom(ctx, a2);
+
+        ctx2 = JS_NewContext(rt);
+        a1 = JS_GetClassName(rt, class_id);
+        a2 = JS_GetClassName(rt, class_id);
+        assert(a1 == a2);
+        JS_FreeAtom(ctx2, a1);
+        JS_FreeAtom(ctx2, a2);
+        JS_FreeContext(ctx2);
+    }
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+void object_from(void)
+{
+    JSRuntime *rt = new_runtime();
+    JSContext *ctx = JS_NewContext(rt);
+    JSValue t0 = JS_NewObject(ctx);
+    assert(!JS_IsException(t0));
+    assert(JS_IsObject(t0));
+    JSAtom prop = JS_NewAtomLen(ctx, "prop", 4);
+    assert(prop != JS_ATOM_NULL);
+    JSValue val = JS_NULL;
+    JSValue t1 = JS_NewObjectFrom(ctx, 1, &prop, &val);
+    assert(!JS_IsException(t1));
+    assert(JS_IsObject(t1));
+    uint32_t old_shape_hash_count = js_std_cmd(/*GetShapeHashCount*/4, rt);
+    JSValue t2 = JS_NewObjectFrom(ctx, 1, &prop, &val);
+    assert(!JS_IsException(t2));
+    assert(JS_IsObject(t2));
+    uint32_t new_shape_hash_count = js_std_cmd(/*GetShapeHashCount*/4, rt);
+    assert(old_shape_hash_count == new_shape_hash_count);
+    JS_FreeAtom(ctx, prop);
+    JS_FreeValue(ctx, t2);
+    JS_FreeValue(ctx, t1);
+    JS_FreeValue(ctx, t0);
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+void add_intrinsic_bigint(void)
+{
+    JSRuntime *rt = new_runtime();
+    JSContext *ctx = JS_NewContextRaw(rt);
+    JS_AddIntrinsicBaseObjects(ctx);
+    JS_AddIntrinsicBigInt(ctx);
+    assert(!JS_HasException(ctx));
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
 int main(void)
 {
     cfunctions();
@@ -1840,6 +2070,7 @@ int main(void)
     promise_hook();
     dump_memory_usage();
     new_errors();
+    dom_exception_added_twice();
     backtrace_oom_current_exception();
     backtrace_oom_callsite_array();
     proxy_own_keys_huge_length();
@@ -1855,5 +2086,8 @@ int main(void)
     transfer_external_array_buffer();
     resize_external_array_buffer();
     transfer_default_managed_array_buffer();
+    get_class_name();
+    object_from();
+    add_intrinsic_bigint();
     return 0;
 }

package/deps/quickjs/libregexp.c

@@ -1025,7 +1025,7 @@ static int parse_class_string_disjunction(REParseState *s, REStringList *cr,
     for(;;) {
         str.size = 0;
         while (*p != '}' && *p != '|') {
-            c = get_class_atom(s, NULL, &p, false);
+            c = get_class_atom(s, NULL, &p, true);
             if (c < 0)
                 goto fail;
             if (dbuf_put_u32(&str, c)) {
@@ -1119,6 +1119,23 @@ static int get_class_atom(REParseState *s, REStringList *cr,
             if (!inclass && s->is_unicode)
                 goto invalid_escape;
             break;
+        case '&':
+        case '!':
+        case '#':
+        case '%':
+        case ',':
+        case ':':
+        case ';':
+        case '<':
+        case '=':
+        case '>':
+        case '@':
+        case '`':
+        case '~':
+            if (s->is_unicode && (!inclass || !s->unicode_sets))
+                /* Only illegal if in unicode mode and not in a class */
+                goto invalid_escape;
+            break;
         case '^':
         case '$':
         case '\\':

package/deps/quickjs/libunicode-table.h

@@ -4067,6 +4067,76 @@ static const uint8_t unicode_prop_Changes_When_NFKC_Casefolded1_table[449] = {
     0xff,
 };
 
+static const uint8_t unicode_prop_Basic_Emoji1_table[144] = {
+    0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
+    0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
+    0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
+    0x0c, 0x0f, 0x04, 0x80, 0x94, 0x06, 0x08, 0x03,
+    0x01, 0x06, 0x03, 0x81, 0x9b, 0x80, 0xa2, 0x00,
+    0x03, 0x10, 0x80, 0xbc, 0x82, 0x97, 0x80, 0x8d,
+    0x80, 0x43, 0x5a, 0x81, 0xb2, 0x03, 0x80, 0x61,
+    0xc4, 0xad, 0x80, 0x40, 0xc9, 0x80, 0x40, 0xbd,
+    0x01, 0x89, 0xe5, 0x80, 0x97, 0x80, 0x93, 0x01,
+    0x20, 0x82, 0x94, 0x81, 0x40, 0xad, 0xa0, 0x8b,
+    0x88, 0x80, 0xc5, 0x80, 0x95, 0x8b, 0xaa, 0x1c,
+    0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80, 0x40,
+    0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91, 0x80,
+    0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf, 0xc5,
+    0x28, 0x12, 0x0b, 0x13, 0x8a, 0x0e, 0x88, 0x40,
+    0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89,
+    0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x8a, 0x82,
+    0xb8, 0x00, 0x83, 0x8f, 0x81, 0x8b, 0x83, 0x89,
+};
+
+static const uint8_t unicode_prop_Basic_Emoji2_table[183] = {
+    0x40, 0xa8, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b,
+    0x80, 0x40, 0xd7, 0x80, 0x95, 0x80, 0xd9, 0x85,
+    0x8e, 0x81, 0x41, 0x7c, 0x80, 0x40, 0xa5, 0x80,
+    0x9c, 0x10, 0x0c, 0x82, 0x40, 0xc6, 0x80, 0x40,
+    0xe6, 0x81, 0x89, 0x80, 0x88, 0x80, 0xb9, 0x0a,
+    0x84, 0x88, 0x01, 0x05, 0x03, 0x01, 0x00, 0x09,
+    0x02, 0x02, 0x0f, 0x14, 0x00, 0x80, 0x9b, 0x09,
+    0x00, 0x08, 0x80, 0x91, 0x01, 0x80, 0x92, 0x00,
+    0x18, 0x00, 0x0a, 0x05, 0x07, 0x81, 0x95, 0x05,
+    0x00, 0x00, 0x80, 0x94, 0x05, 0x09, 0x01, 0x17,
+    0x04, 0x09, 0x08, 0x01, 0x00, 0x00, 0x05, 0x02,
+    0x80, 0x90, 0x81, 0x8e, 0x01, 0x80, 0x9a, 0x81,
+    0xbb, 0x80, 0x41, 0x91, 0x81, 0x41, 0xce, 0x82,
+    0x45, 0x27, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00,
+    0x80, 0x61, 0xbe, 0xd5, 0x81, 0x8b, 0x81, 0x40,
+    0x81, 0x80, 0xb3, 0x80, 0x40, 0xe8, 0x01, 0x88,
+    0x88, 0x80, 0xc5, 0x80, 0x97, 0x08, 0x11, 0x81,
+    0xaa, 0x1c, 0x8b, 0x92, 0x00, 0x00, 0x80, 0xc6,
+    0x00, 0x80, 0x40, 0xba, 0x80, 0xca, 0x81, 0xa3,
+    0x09, 0x86, 0x8c, 0x01, 0x19, 0x80, 0x93, 0x01,
+    0x07, 0x81, 0x88, 0x04, 0x82, 0x8b, 0x17, 0x11,
+    0x00, 0x03, 0x05, 0x02, 0x05, 0x80, 0x40, 0xcf,
+    0x00, 0x82, 0x8f, 0x2a, 0x05, 0x01, 0x80,
+};
+
+static const uint8_t unicode_prop_RGI_Emoji_Flag_Sequence_table[128] = {
+    0x0c, 0x00, 0x09, 0x00, 0x04, 0x01, 0x02, 0x06,
+    0x03, 0x03, 0x01, 0x02, 0x01, 0x03, 0x07, 0x0d,
+    0x18, 0x00, 0x09, 0x00, 0x00, 0x89, 0x08, 0x00,
+    0x00, 0x81, 0x88, 0x83, 0x8c, 0x10, 0x00, 0x01,
+    0x07, 0x08, 0x29, 0x10, 0x28, 0x00, 0x80, 0x8a,
+    0x00, 0x0a, 0x00, 0x0e, 0x15, 0x18, 0x83, 0x89,
+    0x06, 0x00, 0x81, 0x8d, 0x00, 0x12, 0x08, 0x00,
+    0x03, 0x00, 0x24, 0x00, 0x05, 0x21, 0x00, 0x00,
+    0x29, 0x90, 0x00, 0x02, 0x00, 0x08, 0x09, 0x00,
+    0x08, 0x18, 0x8b, 0x80, 0x8c, 0x02, 0x19, 0x1a,
+    0x11, 0x00, 0x00, 0x80, 0x9c, 0x80, 0x88, 0x02,
+    0x00, 0x00, 0x02, 0x20, 0x88, 0x0a, 0x00, 0x03,
+    0x01, 0x02, 0x05, 0x08, 0x00, 0x01, 0x09, 0x20,
+    0x21, 0x18, 0x22, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x28, 0x89, 0x80, 0x8b, 0x80, 0x90, 0x80, 0x92,
+    0x80, 0x8d, 0x05, 0x80, 0x8a, 0x80, 0x88, 0x80,
+};
+
+static const uint8_t unicode_prop_Emoji_Keycap_Sequence_table[4] = {
+    0xa2, 0x05, 0x04, 0x89,
+};
+
 static const uint8_t unicode_prop_ASCII_Hex_Digit_table[5] = {
     0xaf, 0x89, 0x35, 0x99, 0x85,
 };
@@ -4641,89 +4711,6 @@ static const char unicode_prop_name_table[] =
     "XID_Start,XIDS"                     "\0"
 ;
 
-/* RGI emoji sequence support */
-static const uint8_t unicode_prop_Basic_Emoji1_table[144] = {
-    0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01,
-    0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
-    0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90,
-    0x0c, 0x0f, 0x04, 0x80, 0x94, 0x06, 0x08, 0x03,
-    0x01, 0x06, 0x03, 0x81, 0x9b, 0x80, 0xa2, 0x00,
-    0x03, 0x10, 0x80, 0xbc, 0x82, 0x97, 0x80, 0x8d,
-    0x80, 0x43, 0x5a, 0x81, 0xb2, 0x03, 0x80, 0x61,
-    0xc4, 0xad, 0x80, 0x40, 0xc9, 0x80, 0x40, 0xbd,
-    0x01, 0x89, 0xe5, 0x80, 0x97, 0x80, 0x93, 0x01,
-    0x20, 0x82, 0x94, 0x81, 0x40, 0xad, 0xa0, 0x8b,
-    0x88, 0x80, 0xc5, 0x80, 0x95, 0x8b, 0xaa, 0x1c,
-    0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80, 0x40,
-    0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91, 0x80,
-    0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf, 0xc5,
-    0x28, 0x12, 0x0b, 0x13, 0x8a, 0x0e, 0x88, 0x40,
-    0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89,
-    0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x8a, 0x82,
-    0xb8, 0x00, 0x83, 0x8f, 0x81, 0x8b, 0x83, 0x89,
-};
-
-static const uint8_t unicode_prop_Basic_Emoji2_table[183] = {
-    0x40, 0xa8, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b,
-    0x80, 0x40, 0xd7, 0x80, 0x95, 0x80, 0xd9, 0x85,
-    0x8e, 0x81, 0x41, 0x7c, 0x80, 0x40, 0xa5, 0x80,
-    0x9c, 0x10, 0x0c, 0x82, 0x40, 0xc6, 0x80, 0x40,
-    0xe6, 0x81, 0x89, 0x80, 0x88, 0x80, 0xb9, 0x0a,
-    0x84, 0x88, 0x01, 0x05, 0x03, 0x01, 0x00, 0x09,
-    0x02, 0x02, 0x0f, 0x14, 0x00, 0x80, 0x9b, 0x09,
-    0x00, 0x08, 0x80, 0x91, 0x01, 0x80, 0x92, 0x00,
-    0x18, 0x00, 0x0a, 0x05, 0x07, 0x81, 0x95, 0x05,
-    0x00, 0x00, 0x80, 0x94, 0x05, 0x09, 0x01, 0x17,
-    0x04, 0x09, 0x08, 0x01, 0x00, 0x00, 0x05, 0x02,
-    0x80, 0x90, 0x81, 0x8e, 0x01, 0x80, 0x9a, 0x81,
-    0xbb, 0x80, 0x41, 0x91, 0x81, 0x41, 0xce, 0x82,
-    0x45, 0x27, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00,
-    0x80, 0x61, 0xbe, 0xd5, 0x81, 0x8b, 0x81, 0x40,
-    0x81, 0x80, 0xb3, 0x80, 0x40, 0xe8, 0x01, 0x88,
-    0x88, 0x80, 0xc5, 0x80, 0x97, 0x08, 0x11, 0x81,
-    0xaa, 0x1c, 0x8b, 0x92, 0x00, 0x00, 0x80, 0xc6,
-    0x00, 0x80, 0x40, 0xba, 0x80, 0xca, 0x81, 0xa3,
-    0x09, 0x86, 0x8c, 0x01, 0x19, 0x80, 0x93, 0x01,
-    0x07, 0x81, 0x88, 0x04, 0x82, 0x8b, 0x17, 0x11,
-    0x00, 0x03, 0x05, 0x02, 0x05, 0x80, 0x40, 0xcf,
-    0x00, 0x82, 0x8f, 0x2a, 0x05, 0x01, 0x80,
-};
-
-static const uint8_t unicode_prop_RGI_Emoji_Modifier_Sequence_table[72] = {
-    0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f,
-    0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
-    0x82, 0xf4, 0x09, 0x8a, 0x94, 0x18, 0x8d, 0x10,
-    0x1a, 0x02, 0x30, 0x00, 0x97, 0x80, 0x40, 0xc8,
-    0x0b, 0x80, 0x94, 0x03, 0x81, 0x40, 0xad, 0x12,
-    0x84, 0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80, 0x8a,
-    0x80, 0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80, 0x88,
-    0x89, 0x0a, 0xb7, 0x80, 0xbc, 0x08, 0x08, 0x80,
-    0x90, 0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9, 0x88,
-};
-
-static const uint8_t unicode_prop_RGI_Emoji_Flag_Sequence_table[128] = {
-    0x0c, 0x00, 0x09, 0x00, 0x04, 0x01, 0x02, 0x06,
-    0x03, 0x03, 0x01, 0x02, 0x01, 0x03, 0x07, 0x0d,
-    0x18, 0x00, 0x09, 0x00, 0x00, 0x89, 0x08, 0x00,
-    0x00, 0x81, 0x88, 0x83, 0x8c, 0x10, 0x00, 0x01,
-    0x07, 0x08, 0x29, 0x10, 0x28, 0x00, 0x80, 0x8a,
-    0x00, 0x0a, 0x00, 0x0e, 0x15, 0x18, 0x83, 0x89,
-    0x06, 0x00, 0x81, 0x8d, 0x00, 0x12, 0x08, 0x00,
-    0x03, 0x00, 0x24, 0x00, 0x05, 0x21, 0x00, 0x00,
-    0x29, 0x90, 0x00, 0x02, 0x00, 0x08, 0x09, 0x00,
-    0x08, 0x18, 0x8b, 0x80, 0x8c, 0x02, 0x19, 0x1a,
-    0x11, 0x00, 0x00, 0x80, 0x9c, 0x80, 0x88, 0x02,
-    0x00, 0x00, 0x02, 0x20, 0x88, 0x0a, 0x00, 0x03,
-    0x01, 0x02, 0x05, 0x08, 0x00, 0x01, 0x09, 0x20,
-    0x21, 0x18, 0x22, 0x00, 0x00, 0x00, 0x00, 0x18,
-    0x28, 0x89, 0x80, 0x8b, 0x80, 0x90, 0x80, 0x92,
-    0x80, 0x8d, 0x05, 0x80, 0x8a, 0x80, 0x88, 0x80,
-};
-
-static const uint8_t unicode_prop_Emoji_Keycap_Sequence_table[4] = {
-    0xa2, 0x05, 0x04, 0x89,
-};
-
 static const uint8_t * const unicode_prop_table[] = {
     unicode_prop_Hyphen_table,
     unicode_prop_Other_Math_table,
@@ -4842,7 +4829,6 @@ static const uint16_t unicode_prop_len_table[] = {
     countof(unicode_prop_Case_Ignorable_table),
 };
 
-/* RGI emoji sequence-property tables */
 typedef enum {
     UNICODE_SEQUENCE_PROP_Basic_Emoji,
     UNICODE_SEQUENCE_PROP_Emoji_Keycap_Sequence,
@@ -5171,3 +5157,4 @@ static const uint8_t unicode_rgi_emoji_zwj_sequence[2392] = {
     0x86, 0x02, 0x4b, 0x16, 0x40, 0x86, 0x02, 0x26,
     0x19, 0x42, 0x86, 0x02, 0xd7, 0x19, 0x40, 0x86,
 };
+

package/deps/quickjs/quickjs-libc.c

@@ -1920,7 +1920,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
     JS_CFUNC_DEF("evalScript", 1, js_evalScript ),
     JS_CFUNC_DEF("loadScript", 1, js_loadScript ),
     JS_CFUNC_DEF("getenv", 1, js_std_getenv ),
-    JS_CFUNC_DEF("setenv", 1, js_std_setenv ),
+    JS_CFUNC_DEF("setenv", 2, js_std_setenv ),
     JS_CFUNC_DEF("unsetenv", 1, js_std_unsetenv ),
     JS_CFUNC_DEF("getenviron", 1, js_std_getenviron ),
 #if !defined(__wasi__)
@@ -4449,7 +4449,7 @@ static const JSCFunctionListEntry js_os_funcs[] = {
     JS_CFUNC_DEF("sleepAsync", 1, js_os_sleepAsync ),
     JS_PROP_STRING_DEF("platform", OS_PLATFORM, 0 ),
     JS_CFUNC_DEF("getcwd", 0, js_os_getcwd ),
-    JS_CFUNC_DEF("chdir", 0, js_os_chdir ),
+    JS_CFUNC_DEF("chdir", 1, js_os_chdir ),
     JS_CFUNC_DEF("mkdir", 1, js_os_mkdir ),
     JS_CFUNC_DEF("readdir", 1, js_os_readdir ),
 #if !defined(_WIN32) && !defined(__wasi__)