@zappdev/cli 0.1.0

package/native/vendor/quickjs-ng/dtoa.h

@@ -0,0 +1,87 @@
+/*
+ * Tiny float64 printing and parsing library
+ *
+ * Copyright (c) 2024 Fabrice Bellard
+ *
+ * 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.
+ */
+#ifndef DTOA_H
+#define DTOA_H
+
+//#define JS_DTOA_DUMP_STATS
+
+/* maximum number of digits for fixed and frac formats */
+#define JS_DTOA_MAX_DIGITS 101
+
+/* radix != 10 is only supported with flags = JS_DTOA_FORMAT_FREE */
+/* use as many digits as necessary */
+#define JS_DTOA_FORMAT_FREE  (0 << 0)
+/* use n_digits significant digits (1 <= n_digits <= JS_DTOA_MAX_DIGITS) */
+#define JS_DTOA_FORMAT_FIXED (1 << 0)
+/* force fractional format: [-]dd.dd with n_digits fractional digits.
+   0 <= n_digits <= JS_DTOA_MAX_DIGITS */
+#define JS_DTOA_FORMAT_FRAC  (2 << 0)
+#define JS_DTOA_FORMAT_MASK  (3 << 0)
+
+/* select exponential notation either in fixed or free format */
+#define JS_DTOA_EXP_AUTO     (0 << 2)
+#define JS_DTOA_EXP_ENABLED  (1 << 2)
+#define JS_DTOA_EXP_DISABLED (2 << 2)
+#define JS_DTOA_EXP_MASK     (3 << 2)
+
+#define JS_DTOA_MINUS_ZERO   (1 << 4) /* show the minus sign for -0 */
+
+/* only accepts integers (no dot, no exponent) */
+#define JS_ATOD_INT_ONLY       (1 << 0)
+/* accept Oo and Ob prefixes in addition to 0x prefix if radix = 0 */
+#define JS_ATOD_ACCEPT_BIN_OCT (1 << 1)
+/* accept O prefix as octal if radix == 0 and properly formed (Annex B) */
+#define JS_ATOD_ACCEPT_LEGACY_OCTAL  (1 << 2)
+/* accept _ between digits as a digit separator */
+#define JS_ATOD_ACCEPT_UNDERSCORES  (1 << 3)
+
+typedef struct {
+    uint64_t mem[37];
+} JSDTOATempMem;
+
+typedef struct {
+    uint64_t mem[27];
+} JSATODTempMem;
+
+/* return a maximum bound of the string length */
+int js_dtoa_max_len(double d, int radix, int n_digits, int flags);
+/* return the string length */
+int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
+            JSDTOATempMem *tmp_mem);
+double js_atod(const char *str, const char **pnext, int radix, int flags,
+               JSATODTempMem *tmp_mem);
+
+#ifdef JS_DTOA_DUMP_STATS
+void js_dtoa_dump_stats(void);
+#endif
+
+/* additional exported functions */
+size_t u32toa(char *buf, uint32_t n);
+size_t i32toa(char *buf, int32_t n);
+size_t u64toa(char *buf, uint64_t n);
+size_t i64toa(char *buf, int64_t n);
+size_t u64toa_radix(char *buf, uint64_t n, unsigned int radix);
+size_t i64toa_radix(char *buf, int64_t n, unsigned int radix);
+
+#endif /* DTOA_H */

package/native/vendor/quickjs-ng/examples/fib.c

@@ -0,0 +1,67 @@
+/*
+ * QuickJS: Example of C module
+ *
+ * Copyright (c) 2017-2018 Fabrice Bellard
+ *
+ * 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.
+ */
+
+#include <quickjs.h>
+
+#define countof(x) (sizeof(x) / sizeof((x)[0]))
+
+static int fib(int n)
+{
+    if (n <= 0)
+        return 0;
+    else if (n == 1)
+        return 1;
+    else
+        return fib(n - 1) + fib(n - 2);
+}
+
+static JSValue js_fib(JSContext *ctx, JSValue this_val,
+                      int argc, JSValue *argv)
+{
+    int n, res;
+    if (JS_ToInt32(ctx, &n, argv[0]))
+        return JS_EXCEPTION;
+    res = fib(n);
+    return JS_NewInt32(ctx, res);
+}
+
+static const JSCFunctionListEntry js_fib_funcs[] = {
+    JS_CFUNC_DEF("fib", 1, js_fib ),
+};
+
+static int js_fib_init(JSContext *ctx, JSModuleDef *m)
+{
+    return JS_SetModuleExportList(ctx, m, js_fib_funcs,
+                                  countof(js_fib_funcs));
+}
+
+JS_MODULE_EXTERN JSModuleDef *js_init_module(JSContext *ctx, const char *module_name)
+{
+    JSModuleDef *m;
+    m = JS_NewCModule(ctx, module_name, js_fib_init);
+    if (!m)
+        return NULL;
+    JS_AddModuleExportList(ctx, m, js_fib_funcs, countof(js_fib_funcs));
+    return m;
+}

package/native/vendor/quickjs-ng/examples/fib_module.js

@@ -0,0 +1,10 @@
+/* fib module */
+export function fib(n)
+{
+    if (n <= 0)
+        return 0;
+    else if (n == 1)
+        return 1;
+    else
+        return fib(n - 1) + fib(n - 2);
+}

package/native/vendor/quickjs-ng/examples/hello.js

@@ -0,0 +1 @@
+console.log("Hello World");

package/native/vendor/quickjs-ng/examples/hello_module.js

@@ -0,0 +1,6 @@
+/* example of JS module */
+
+import { fib } from "./fib_module.js";
+
+console.log("Hello World");
+console.log("fib(10)=", fib(10));

package/native/vendor/quickjs-ng/examples/meson.build

@@ -0,0 +1,17 @@
+shared_module(
+  'fib',
+  'fib.c',
+
+  name_prefix: '',
+  gnu_symbol_visibility: 'hidden',
+  dependencies: qjs_module_dep,
+)
+
+shared_module(
+  'point',
+  'point.c',
+
+  name_prefix: '',
+  gnu_symbol_visibility: 'hidden',
+  dependencies: qjs_module_dep,
+)

package/native/vendor/quickjs-ng/examples/pi_bigint.js

@@ -0,0 +1,118 @@
+/*
+ * PI computation in Javascript using the BigInt type
+ */
+"use strict";
+
+/* return floor(log2(a)) for a > 0 and 0 for a = 0 */
+function floor_log2(a)
+{
+    var k_max, a1, k, i;
+    k_max = 0n;
+    while ((a >> (2n ** k_max)) != 0n) {
+        k_max++;
+    }
+    k = 0n;
+    a1 = a;
+    for(i = k_max - 1n; i >= 0n; i--) {
+        a1 = a >> (2n ** i);
+        if (a1 != 0n) {
+            a = a1;
+            k |= (1n << i);
+        }
+    }
+    return k;
+}
+
+/* return ceil(log2(a)) for a > 0 */
+function ceil_log2(a)
+{
+    return floor_log2(a - 1n) + 1n;
+}
+
+/* return floor(sqrt(a)) (not efficient but simple) */
+function int_sqrt(a)
+{
+    var l, u, s;
+    if (a == 0n)
+        return a;
+    l = ceil_log2(a);
+    u = 1n << ((l + 1n) / 2n);
+    /* u >= floor(sqrt(a)) */
+    for(;;) {
+        s = u;
+        u = ((a / s) + s) / 2n;
+        if (u >= s)
+            break;
+    }
+    return s;
+}
+
+/* return pi * 2**prec */
+function calc_pi(prec) {
+    const CHUD_A = 13591409n;
+    const CHUD_B = 545140134n;
+    const CHUD_C = 640320n;
+    const CHUD_C3 = 10939058860032000n; /* C^3/24 */
+    const CHUD_BITS_PER_TERM = 47.11041313821584202247; /* log2(C/12)*3 */
+
+    /* return [P, Q, G] */
+    function chud_bs(a, b, need_G) {
+        var c, P, Q, G, P1, Q1, G1, P2, Q2, G2;
+        if (a == (b - 1n)) {
+            G = (2n * b - 1n) * (6n * b - 1n) * (6n * b - 5n);
+            P = G * (CHUD_B * b + CHUD_A);
+            if (b & 1n)
+                P = -P;
+            Q = b * b * b * CHUD_C3;
+        } else {
+            c = (a + b) >> 1n;
+            [P1, Q1, G1] = chud_bs(a, c, true);
+            [P2, Q2, G2] = chud_bs(c, b, need_G);
+            P = P1 * Q2 + P2 * G1;
+            Q = Q1 * Q2;
+            if (need_G)
+                G = G1 * G2;
+            else
+                G = 0n;
+        }
+        return [P, Q, G];
+    }
+
+    var n, P, Q, G;
+    /* number of serie terms */
+    n = BigInt(Math.ceil(Number(prec) / CHUD_BITS_PER_TERM)) + 10n;
+    [P, Q, G] = chud_bs(0n, n, false);
+    Q = (CHUD_C / 12n) * (Q << prec) / (P + Q * CHUD_A);
+    G = int_sqrt(CHUD_C << (2n * prec));
+    return (Q * G) >> prec;
+}
+
+function main(args) {
+    var r, n_digits, n_bits, out;
+    if (args.length < 1) {
+        print("usage: pi n_digits");
+        return;
+    }
+    n_digits = args[0] | 0;
+
+    /* we add more bits to reduce the probability of bad rounding for
+      the last digits */
+    n_bits = BigInt(Math.ceil(n_digits * Math.log2(10))) + 32n;
+    r = calc_pi(n_bits);
+    r = ((10n ** BigInt(n_digits)) * r) >> n_bits;
+    out = r.toString();
+    print(out[0] + "." + out.slice(1));
+}
+
+var args;
+if (typeof scriptArgs != "undefined") {
+    args = scriptArgs;
+    args.shift();
+} else if (typeof arguments != "undefined") {
+    args = arguments;
+} else {
+    /* default: 1000 digits */
+    args=[1000];
+}
+
+main(args);

package/native/vendor/quickjs-ng/examples/point.c

@@ -0,0 +1,154 @@
+/*
+ * QuickJS: Example of C module with a class
+ *
+ * Copyright (c) 2019 Fabrice Bellard
+ *
+ * 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.
+ */
+
+#include <math.h>
+
+#include <quickjs.h>
+
+#define countof(x) (sizeof(x) / sizeof((x)[0]))
+
+/* Point Class */
+
+typedef struct {
+    int x;
+    int y;
+} JSPointData;
+
+static JSClassID js_point_class_id;
+
+static void js_point_finalizer(JSRuntime *rt, JSValue val)
+{
+    JSPointData *s = JS_GetOpaque(val, js_point_class_id);
+    /* Note: 's' can be NULL in case JS_SetOpaque() was not called */
+    js_free_rt(rt, s);
+}
+
+static JSValue js_point_ctor(JSContext *ctx,
+                             JSValue new_target,
+                             int argc, JSValue *argv)
+{
+    JSPointData *s;
+    JSValue obj = JS_UNDEFINED;
+    JSValue proto;
+
+    s = js_mallocz(ctx, sizeof(*s));
+    if (!s)
+        return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &s->x, argv[0]))
+        goto fail;
+    if (JS_ToInt32(ctx, &s->y, argv[1]))
+        goto fail;
+    /* using new_target to get the prototype is necessary when the
+       class is extended. */
+    proto = JS_GetPropertyStr(ctx, new_target, "prototype");
+    if (JS_IsException(proto))
+        goto fail;
+    obj = JS_NewObjectProtoClass(ctx, proto, js_point_class_id);
+    JS_FreeValue(ctx, proto);
+    if (JS_IsException(obj))
+        goto fail;
+    JS_SetOpaque(obj, s);
+    return obj;
+ fail:
+    js_free(ctx, s);
+    JS_FreeValue(ctx, obj);
+    return JS_EXCEPTION;
+}
+
+static JSValue js_point_get_xy(JSContext *ctx, JSValue this_val, int magic)
+{
+    JSPointData *s = JS_GetOpaque2(ctx, this_val, js_point_class_id);
+    if (!s)
+        return JS_EXCEPTION;
+    if (magic == 0)
+        return JS_NewInt32(ctx, s->x);
+    else
+        return JS_NewInt32(ctx, s->y);
+}
+
+static JSValue js_point_set_xy(JSContext *ctx, JSValue this_val, JSValue val, int magic)
+{
+    JSPointData *s = JS_GetOpaque2(ctx, this_val, js_point_class_id);
+    int v;
+    if (!s)
+        return JS_EXCEPTION;
+    if (JS_ToInt32(ctx, &v, val))
+        return JS_EXCEPTION;
+    if (magic == 0)
+        s->x = v;
+    else
+        s->y = v;
+    return JS_UNDEFINED;
+}
+
+static JSValue js_point_norm(JSContext *ctx, JSValue this_val,
+                             int argc, JSValue *argv)
+{
+    JSPointData *s = JS_GetOpaque2(ctx, this_val, js_point_class_id);
+    if (!s)
+        return JS_EXCEPTION;
+    return JS_NewFloat64(ctx, sqrt((double)s->x * s->x + (double)s->y * s->y));
+}
+
+static JSClassDef js_point_class = {
+    "Point",
+    .finalizer = js_point_finalizer,
+};
+
+static const JSCFunctionListEntry js_point_proto_funcs[] = {
+    JS_CGETSET_MAGIC_DEF("x", js_point_get_xy, js_point_set_xy, 0),
+    JS_CGETSET_MAGIC_DEF("y", js_point_get_xy, js_point_set_xy, 1),
+    JS_CFUNC_DEF("norm", 0, js_point_norm),
+};
+
+static int js_point_init(JSContext *ctx, JSModuleDef *m)
+{
+    JSValue point_proto, point_class;
+    JSRuntime *rt = JS_GetRuntime(ctx);
+
+    /* create the Point class */
+    JS_NewClassID(rt, &js_point_class_id);
+    JS_NewClass(rt, js_point_class_id, &js_point_class);
+
+    point_proto = JS_NewObject(ctx);
+    JS_SetPropertyFunctionList(ctx, point_proto, js_point_proto_funcs, countof(js_point_proto_funcs));
+
+    point_class = JS_NewCFunction2(ctx, js_point_ctor, "Point", 2, JS_CFUNC_constructor, 0);
+    /* set proto.constructor and ctor.prototype */
+    JS_SetConstructor(ctx, point_class, point_proto);
+    JS_SetClassProto(ctx, js_point_class_id, point_proto);
+
+    JS_SetModuleExport(ctx, m, "Point", point_class);
+    return 0;
+}
+
+JS_MODULE_EXTERN JSModuleDef *js_init_module(JSContext *ctx, const char *module_name)
+{
+    JSModuleDef *m;
+    m = JS_NewCModule(ctx, module_name, js_point_init);
+    if (!m)
+        return NULL;
+    JS_AddModuleExport(ctx, m, "Point");
+    return m;
+}

package/native/vendor/quickjs-ng/examples/test_fib.js

@@ -0,0 +1,8 @@
+/* example of JS module importing a C module */
+import * as os from "qjs:os";
+
+const isWin = os.platform === 'win32';
+const { fib } = await import(`./fib.${isWin ? 'dll' : 'so'}`);
+
+console.log("Hello World");
+console.log("fib(10)=", fib(10));

package/native/vendor/quickjs-ng/examples/test_point.js

@@ -0,0 +1,43 @@
+/* example of JS module importing a C module */
+import * as os from "qjs:os";
+
+const isWin = os.platform === 'win32';
+const { Point } = await import(`./point.${isWin ? 'dll' : 'so'}`);
+
+function assert(b, str)
+{
+    if (b) {
+        return;
+    } else {
+        throw Error("assertion failed: " + str);
+    }
+}
+
+class ColorPoint extends Point {
+    constructor(x, y, color) {
+        super(x, y);
+        this.color = color;
+    }
+    get_color() {
+        return this.color;
+    }
+};
+
+function main()
+{
+    var pt, pt2;
+
+    pt = new Point(2, 3);
+    assert(pt.x === 2);
+    assert(pt.y === 3);
+    pt.x = 4;
+    assert(pt.x === 4);
+    assert(pt.norm() == 5);
+
+    pt2 = new ColorPoint(2, 3, 0xffffff);
+    assert(pt2.x === 2);
+    assert(pt2.color === 0xffffff);
+    assert(pt2.get_color() === 0xffffff);
+}
+
+main();

package/native/vendor/quickjs-ng/fuzz.c

@@ -0,0 +1,51 @@
+// clang -g -O1 -fsanitize=fuzzer -o fuzz fuzz.c
+#include "quickjs.h"
+#include "quickjs.c"
+#include "cutils.h"
+#include "libregexp.c"
+#include "libunicode.c"
+#include "dtoa.c"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+// note: LLVM output does not contain checksum, needs to be added
+// manually (4 byte field at position 1) when adding to the corpus
+//
+// fill in UINT32_MAX to disable checksumming
+int LLVMFuzzerTestOneInput(const uint8_t *buf, size_t len)
+{
+    if (!len)
+        return 0;
+    JSRuntime *rt = JS_NewRuntime();
+    if (!rt)
+        exit(1);
+    JSContext *ctx = JS_NewContext(rt);
+    if (!ctx)
+        exit(1);
+    size_t newlen = len + 4;
+    uint8_t *newbuf = malloc(newlen);
+    if (!newbuf)
+        exit(1);
+    uint32_t csum = bc_csum(&buf[1], len-1);    // skip version field
+    newbuf[0] = buf[0];                         // copy version field
+    put_u32_le(&newbuf[1], csum);               // insert checksum
+    memcpy(&newbuf[5], &buf[1], len-1);         // copy rest of payload
+    JSValue val = JS_ReadObject(ctx, newbuf, newlen, /*flags*/0);
+    free(newbuf);
+    if (JS_IsException(val)) {
+        JSValue exc = JS_GetException(ctx);
+        const char *str = JS_ToCString(ctx, exc);
+        JS_FreeValue(ctx, exc);
+        if (!str)
+            exit(1);
+        if (strstr(str, "checksum error"))
+            exit(1);
+        JS_FreeCString(ctx, str);
+    }
+    JS_FreeValue(ctx, val);
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+    return 0;
+}

package/native/vendor/quickjs-ng/gen/function_source.c

@@ -0,0 +1,81 @@
+/* File generated automatically by the QuickJS-ng compiler. */
+
+#include "quickjs-libc.h"
+
+const uint32_t qjsc_function_source_size = 332;
+
+const uint8_t qjsc_function_source[332] = {
+ 0x18, 0x08, 0x1e, 0x5a, 0xf2, 0x05, 0x01, 0x30,
+ 0x74, 0x65, 0x73, 0x74, 0x73, 0x2f, 0x66, 0x75,
+ 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73,
+ 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x6a, 0x73,
+ 0x01, 0x0c, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c,
+ 0x01, 0x02, 0x66, 0x01, 0x0c, 0x65, 0x78, 0x70,
+ 0x65, 0x63, 0x74, 0x01, 0x34, 0x66, 0x75, 0x6e,
+ 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x28,
+ 0x29, 0x20, 0x7b, 0x20, 0x72, 0x65, 0x74, 0x75,
+ 0x72, 0x6e, 0x20, 0x34, 0x32, 0x20, 0x7d, 0x0d,
+ 0xca, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+ 0x20, 0x0a, 0x01, 0xa2, 0x01, 0x00, 0x05, 0x00,
+ 0x03, 0x02, 0x02, 0x01, 0x74, 0x05, 0xcc, 0x03,
+ 0x02, 0x00, 0x30, 0xce, 0x03, 0x04, 0x00, 0x70,
+ 0x01, 0xcc, 0x03, 0x04, 0x02, 0x70, 0x00, 0x10,
+ 0x00, 0x01, 0x00, 0xe4, 0x01, 0x00, 0x01, 0x00,
+ 0xd0, 0x03, 0x00, 0x1e, 0xce, 0x03, 0x01, 0x06,
+ 0x0c, 0x43, 0x0a, 0x01, 0xce, 0x03, 0x00, 0x00,
+ 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0xbc,
+ 0x2a, 0x28, 0xca, 0x03, 0x03, 0x01, 0x00, 0x1a,
+ 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+ 0x20, 0x66, 0x28, 0x29, 0x20, 0x7b, 0x20, 0x72,
+ 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x34, 0x32,
+ 0x20, 0x7d, 0x0c, 0x03, 0xc2, 0x04, 0x08, 0xcc,
+ 0x08, 0xea, 0x05, 0xbf, 0x00, 0xe2, 0x29, 0x04,
+ 0xe9, 0x00, 0x00, 0x00, 0xe1, 0x60, 0x00, 0x00,
+ 0xde, 0x41, 0x38, 0x00, 0x00, 0x00, 0x24, 0x00,
+ 0x00, 0xc9, 0x61, 0x00, 0x00, 0x64, 0x00, 0x00,
+ 0xae, 0xea, 0x0b, 0x38, 0x98, 0x00, 0x00, 0x00,
+ 0x61, 0x00, 0x00, 0xef, 0x30, 0x60, 0x02, 0x00,
+ 0x60, 0x01, 0x00, 0x38, 0x3b, 0x00, 0x00, 0x00,
+ 0x64, 0x00, 0x00, 0x04, 0xe7, 0x00, 0x00, 0x00,
+ 0x9c, 0x32, 0x01, 0x00, 0x03, 0x00, 0xca, 0x61,
+ 0x01, 0x00, 0x41, 0x38, 0x00, 0x00, 0x00, 0x24,
+ 0x00, 0x00, 0xcb, 0x61, 0x02, 0x00, 0x64, 0x00,
+ 0x00, 0xae, 0xea, 0x0b, 0x38, 0x98, 0x00, 0x00,
+ 0x00, 0x61, 0x02, 0x00, 0xef, 0x30, 0x67, 0x02,
+ 0x00, 0x67, 0x01, 0x00, 0x06, 0x2f, 0xca, 0x03,
+ 0x01, 0x01, 0x18, 0x00, 0x1c, 0x0a, 0x2a, 0x26,
+ 0x03, 0x20, 0x1c, 0x1b, 0x0c, 0x00, 0x10, 0x08,
+ 0x27, 0x11, 0x12, 0x67, 0x0d, 0x26, 0x03, 0x20,
+ 0x1c, 0x1b, 0x0c, 0x00,
+};
+
+static JSContext *JS_NewCustomContext(JSRuntime *rt)
+{
+  JSContext *ctx = JS_NewContext(rt);
+  if (!ctx)
+    return NULL;
+  return ctx;
+}
+
+int main(int argc, char **argv)
+{
+  int r;
+  JSRuntime *rt;
+  JSContext *ctx;
+  r = 0;
+  rt = JS_NewRuntime();
+  js_std_set_worker_new_context_func(JS_NewCustomContext);
+  js_std_init_handlers(rt);
+  JS_SetModuleLoaderFunc2(rt, NULL, js_module_loader, js_module_check_attributes, NULL);
+  ctx = JS_NewCustomContext(rt);
+  js_std_add_helpers(ctx, argc, argv);
+  js_std_eval_binary(ctx, qjsc_function_source, qjsc_function_source_size, 0);
+  r = js_std_loop(ctx);
+  if (r) {
+    js_std_dump_error(ctx);
+  }
+  js_std_free_handlers(rt);
+  JS_FreeContext(ctx);
+  JS_FreeRuntime(rt);
+  return r;
+}