@zappdev/cli 0.1.0

package/native/vendor/quickjs-ng/standalone.js

@@ -0,0 +1,129 @@
+import * as std from "qjs:std";
+import * as os from "qjs:os";
+import * as bjson from "qjs:bjson";
+
+// See quickjs.h
+const JS_READ_OBJ_BYTECODE = 1 << 0;
+const JS_READ_OBJ_REFERENCE = 1 << 3;
+const JS_WRITE_OBJ_BYTECODE = 1 << 0;
+const JS_WRITE_OBJ_REFERENCE = 1 << 3;
+const JS_WRITE_OBJ_STRIP_SOURCE = 1 << 4;
+
+/**
+ * Trailer for standalone binaries. When some code gets bundled with the qjs
+ * executable we add a 12 byte trailer. The first 8 bytes are the magic
+ * string that helps us understand this is a standalone binary, and the
+ * remaining 4 are the offset (before the trailer) where the bundled data
+ * is located.
+ *
+ * The offset is stored as a 32bit little-endian number.
+ */
+const Trailer = {
+    Magic: 'quickjs2',
+    MagicSize: 8,
+    DataSize: 4,
+    Size: 12
+};
+
+function encodeAscii(txt) {
+  return new Uint8Array(txt.split('').map(c => c.charCodeAt(0)));
+}
+
+function decodeAscii(buf) {
+  return Array.from(buf).map(c => String.fromCharCode(c)).join('')
+}
+
+export function compileStandalone(inFile, outFile, targetExe) {
+  // Step 1: compile the source file to bytecode
+  const js = std.loadFile(inFile);
+
+  if (!js) {
+    throw new Error(`failed to open ${inFile}`);
+  }
+
+  const code = std.evalScript(js, {
+    compile_only: true,
+    compile_module: true
+  });
+  const bytecode = new Uint8Array(bjson.write(code, JS_WRITE_OBJ_BYTECODE | JS_WRITE_OBJ_REFERENCE | JS_WRITE_OBJ_STRIP_SOURCE));
+
+  // Step 2: copy the bytecode to the end of the executable and add a marker.
+  const exeFileName = targetExe ?? os.exePath() ?? globalThis.argv0;
+  const exe = std.loadFile(exeFileName, { binary: true });
+
+  if (!exe) {
+    throw new Error(`failed to open executable: ${exeFileName}`);
+  }
+
+  const exeSize = exe.length;
+  const newBuffer = exe.buffer.transfer(exeSize + bytecode.length + Trailer.Size);
+  const newExe = new Uint8Array(newBuffer);
+
+  newExe.set(bytecode, exeSize);
+  newExe.set(encodeAscii(Trailer.Magic), exeSize + bytecode.length);
+
+  const dw = new DataView(newBuffer, exeSize + bytecode.length + Trailer.MagicSize, Trailer.DataSize);
+
+  dw.setUint32(0, bytecode.length, true /* little-endian */);
+
+  // We use os.open() so we can set the permissions mask.
+  const newFd = os.open(outFile, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o755);
+
+  if (newFd < 0) {
+    throw new Error(`failed to create ${outFile}`);
+  }
+  if (os.write(newFd, newBuffer, 0, newBuffer.byteLength) < 0) {
+    os.close(newFd);
+    throw new Error(`failed to write to output file`);
+  }
+  os.close(newFd);
+}
+
+export function runStandalone() {
+  const file = os.exePath() ?? globalThis.argv0;
+  const exe = std.open(file, 'rb');
+
+  if (!exe) {
+    throw new Error(`failed to open executable: ${file}`);
+  }
+
+  let r = exe.seek(-Trailer.Size, std.SEEK_END);
+  if (r < 0) {
+    throw new Error(`seek error: ${-r}`);
+  }
+
+  const trailer = new Uint8Array(Trailer.Size);
+
+  exe.read(trailer.buffer, 0, Trailer.Size);
+
+  const magic = new Uint8Array(trailer.buffer, 0, Trailer.MagicSize);
+
+  // Shouldn't happen since qjs.c checks for it.
+  if (decodeAscii(magic) !== Trailer.Magic) {
+    exe.close();
+    throw new Error('corrupted binary, magic mismatch');
+  }
+
+  const dw = new DataView(trailer.buffer, Trailer.MagicSize, Trailer.DataSize);
+  const bytecodelen = dw.getUint32(0, true /* little-endian */);
+  const bytecode = new Uint8Array(bytecodelen);
+
+  r = exe.seek(-(bytecodelen + Trailer.Size), std.SEEK_END);
+  if (r < 0) {
+    exe.close();
+    throw new Error(`seek error: ${-r}`);
+  }
+
+  exe.read(bytecode.buffer, 0, bytecode.length);
+  if (exe.error()) {
+    exe.close();
+    throw new Error('read error');
+  }
+  exe.close();
+
+  const code = bjson.read(bytecode.buffer, 0, bytecode.length, JS_READ_OBJ_BYTECODE | JS_READ_OBJ_REFERENCE);
+
+  return std.evalScript(code, {
+    eval_module: true
+  });
+}

package/native/vendor/quickjs-ng/tests/assert.js

@@ -0,0 +1,49 @@
+export function assert(actual, expected, message) {
+    if (arguments.length === 1)
+        expected = true;
+
+    if (typeof actual === typeof expected) {
+        if (actual === expected) {
+            if (actual !== 0 || (1 / actual) === (1 / expected))
+                return;
+        }
+        if (typeof actual === 'number') {
+            if (isNaN(actual) && isNaN(expected))
+                return;
+        }
+        if (typeof actual === 'object') {
+            if (actual !== null && expected !== null
+            &&  actual.constructor === expected.constructor
+            &&  actual.toString() === expected.toString())
+                return;
+        }
+    }
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+export function assertThrows(err, func)
+{
+    var ex;
+    ex = false;
+    try {
+        func();
+    } catch(e) {
+        ex = true;
+        assert(e instanceof err);
+    }
+    assert(ex, true, "exception expected");
+}
+
+export function assertArrayEquals(a, b)
+{
+    if (!Array.isArray(a) || !Array.isArray(b))
+        return assert(false);
+
+    assert(a.length, b.length);
+
+    a.forEach((value, idx) => {
+        assert(b[idx], value);
+    });
+}

package/native/vendor/quickjs-ng/tests/bug1221.js

@@ -0,0 +1,16 @@
+import {assert} from "./assert.js"
+
+let caught = 0
+for (let i = 1; i <= 32; i++) {
+    const prefix = "(:?".repeat(i)
+    const suffix = "|)+".repeat(i)
+    const between = "(?:a|)+"
+    try {
+        new RegExp(prefix + between + suffix)
+    } catch (e) {
+        assert(e instanceof SyntaxError)
+        assert(e.message, "out of memory")
+        caught++
+    }
+}
+assert(caught, 12) // subject to change

package/native/vendor/quickjs-ng/tests/bug1296.js

@@ -0,0 +1,12 @@
+const ab = new ArrayBuffer(10, { maxByteLength: 10 });
+function f() {
+    return 1337;
+}
+const evil = f.bind();
+
+Object.defineProperty(evil, "prototype", { get: () => {
+    print("resizing");
+    return ab.resize();
+} });
+let u8 = Reflect.construct(Uint8Array, [ab], evil);
+print(u8);

package/native/vendor/quickjs-ng/tests/bug1297.js

@@ -0,0 +1,22 @@
+// Test for issue #1297: Heap buffer overflow in js_typed_array_sort
+// The bug occurs when a comparator function resizes the ArrayBuffer during sort
+
+const sz = 256;
+const newSz = 10;
+const ab = new ArrayBuffer(sz, { maxByteLength: sz * 10 });
+const u8 = new Uint8Array(ab);
+
+for (let i = 0; i < sz; i++) u8[i] = i;
+u8[sz - 1] = 0;
+
+let cnt = 0;
+u8.sort((a, b) => {
+    for (let i = 0; i < 3000; i++) {
+      try { ab.resize(newSz); } catch(e){}
+    }
+
+    return a - b;
+});
+
+// If we get here without crashing, the fix works
+print("PASS: bug1297 - typed array sort with resize did not crash");

package/native/vendor/quickjs-ng/tests/bug1301.js

@@ -0,0 +1,21 @@
+/*---
+features: [skip-if-tcc]
+---*/
+
+import {assert} from "./assert.js"
+
+const rab = new ArrayBuffer(1024, { maxByteLength: 1024 * 1024 });
+const i32 = new Int32Array(rab);
+const evil = {
+    valueOf: () => {
+        print("resize buffer");
+        rab.resize(0);
+        return 123;
+    }
+};
+
+try {
+  Atomics.store(i32, 0, evil);
+} catch (e) {
+  assert(e instanceof RangeError);
+}

package/native/vendor/quickjs-ng/tests/bug1302.js

@@ -0,0 +1,24 @@
+/*---
+features: [skip-if-tcc]
+---*/
+
+import {assert} from "./assert.js"
+
+const rab = new ArrayBuffer(1024, { maxByteLength: 1024 * 1024 });
+const i32 = new Int32Array(rab);
+const evil = {
+    valueOf: () => {
+        print("resize buffer");
+        rab.resize(0);
+        return 123;
+    }
+};
+try {
+  Atomics.add(i32, 0, evil);
+  // Atomics.sub(i32, 0, evil);
+  // Atomics.and(i32, 0, evil);
+  // Atomics.or(i32, 0, evil);
+  // Atomics.xor(i32, 0, evil);
+} catch (e) {
+  assert(e instanceof RangeError);
+}

package/native/vendor/quickjs-ng/tests/bug1305.js

@@ -0,0 +1,26 @@
+import {assert} from "./assert.js"
+
+const rab = new ArrayBuffer(10, { maxByteLength: 10 });
+const src = new Uint8Array(rab, 0);
+
+function f() {
+    return 1337;
+}
+
+const EvilConstructor = new Proxy(function(){}, {
+    get: function(target, prop, receiver) {
+        if (prop === 'prototype') {
+            print("resizing");
+            rab.resize(0);
+            return Uint8Array.prototype;
+        }
+        return Reflect.get(target, prop, receiver);
+    }
+});
+
+try {
+  let u8 = Reflect.construct(Uint8Array, [src], EvilConstructor);
+  print(u8);
+} catch (e) {
+  assert(e instanceof RangeError);
+}

package/native/vendor/quickjs-ng/tests/bug1318.js

@@ -0,0 +1,54 @@
+import * as std from "qjs:std";
+// https://github.com/quickjs-ng/quickjs/issues/1318
+// Heap use-after-free when FinalizationRegistry is part of a reference cycle.
+// Run under ASAN.
+
+// Test 1: held value is the FR itself (original PoC pattern)
+{
+    let target = {};
+    let fr = new FinalizationRegistry(function() {});
+    fr.register(target, fr);
+    fr.ref = target;
+    target.ref = fr;
+    target = null;
+    fr = null;
+    std.gc();
+}
+
+// Test 2: callback is part of the cycle
+{
+    let target = {};
+    let cb = function() {};
+    let fr = new FinalizationRegistry(cb);
+    fr.register(target, 42);
+    fr.ref = target;
+    target.ref = fr;
+    target.cb = cb;
+    target = null;
+    fr = null;
+    cb = null;
+    std.gc();
+}
+
+// Test 3: simplified real-world pattern (from issue comment)
+{
+    class Registry {
+        #fr = new FinalizationRegistry(v => {});
+        set(key) {
+            const ref = new WeakRef(key);
+            this.#fr.register(key, {}, ref);
+        }
+    }
+    function Observer() {
+        this.targets = new Registry;
+    }
+    Observer.prototype.observe = function(target) {
+        this.targets.set(target);
+        target.subset = new Set;
+        target.subset.add(this);
+    }
+    let sample = {};
+    new Observer().observe(sample);
+    sample = null;
+    std.gc();
+}

package/native/vendor/quickjs-ng/tests/bug1352.js

@@ -0,0 +1,8 @@
+// run under ASAN
+let key = Symbol("fortytwo")
+let wm = new WeakMap()
+let fr = new FinalizationRegistry(() => {})
+fr.register(key, 42)
+wm.set(key, fr)
+fr = null
+key = null

package/native/vendor/quickjs-ng/tests/bug1354.js

@@ -0,0 +1,6 @@
+/*---
+negative:
+  phase: runtime
+  type: SyntaxError
+---*/
+new RegExp("[", "v") // run under ASAN

package/native/vendor/quickjs-ng/tests/bug1355.js

@@ -0,0 +1,58 @@
+function deferred() {
+    let resolve
+    const promise = new Promise(f => {
+        resolve = f
+    })
+    return { promise, resolve }
+}
+
+let it, a, b, c
+let getterHit = 0
+let inGetter = false
+
+Object.defineProperty(Object.prototype, "then", {
+    configurable: true,
+    get() {
+        if (inGetter || !it) return undefined
+        inGetter = true
+        try {
+            if (getterHit === 0) {
+                it.return(0)
+            } else if (getterHit === 1) {
+                it.next(1)
+                it.return(1)
+            }
+            getterHit++
+        } catch (_) {
+        }
+        inGetter = false
+        return undefined
+    },
+})
+
+async function* g() {
+    try {
+        await a.promise
+        yield 1
+        await b.promise
+        yield 2
+        await c.promise
+    } finally {
+        await c.promise
+    }
+}
+
+(async () => {
+    a = deferred()
+    b = deferred()
+    c = deferred()
+    it = g()
+
+    it.next()
+    a.resolve({})
+    await Promise.resolve()
+    await Promise.resolve()
+    b.resolve({})
+    c.resolve({})
+    await Promise.resolve()
+})()

package/native/vendor/quickjs-ng/tests/bug1368.js

@@ -0,0 +1,9 @@
+let it;
+const evil = {
+  [Symbol.iterator]() {
+    it.return();
+    return [][Symbol.iterator]();
+  }
+};
+it = Iterator.concat(evil);
+it.next();

package/native/vendor/quickjs-ng/tests/bug39/1.js

@@ -0,0 +1,6 @@
+/*---
+flags: [qjs:track-promise-rejections]
+---*/
+
+Promise.reject().catch(() => print('oops'))
+Promise.resolve().then(() => print('ok'))

package/native/vendor/quickjs-ng/tests/bug39/2.js

@@ -0,0 +1,6 @@
+/*---
+flags: [qjs:track-promise-rejections]
+---*/
+
+const error = await Promise.resolve().then(() => Promise.reject('reject')).catch(e => e)
+print('Got this error:', error)

package/native/vendor/quickjs-ng/tests/bug39/3.js

@@ -0,0 +1,7 @@
+/*---
+flags: [qjs:track-promise-rejections]
+---*/
+
+const promise = Promise.reject('reject')
+const error = await Promise.resolve().then(() => promise).catch(e => e)
+print('Got this error:', error)

package/native/vendor/quickjs-ng/tests/bug488-upstream.js

@@ -0,0 +1,7 @@
+// for-of with yield in iterable expression should not cause stack underflow
+function* x() {
+    for (var e of yield []);
+}
+var g = x();
+g.next();
+g.return("test");

package/native/vendor/quickjs-ng/tests/bug633/0.js

@@ -0,0 +1,7 @@
+/*---
+flags: [qjs:no-detect-module]
+negative:
+  phase: parse
+  type: SyntaxError
+---*/
+const undefined = 42 // SyntaxError at global scope

package/native/vendor/quickjs-ng/tests/bug633/1.js

@@ -0,0 +1,4 @@
+/*---
+flags: [qjs:no-detect-module, module]
+---*/
+const undefined = 42 // not a SyntaxError at toplevel module scope

package/native/vendor/quickjs-ng/tests/bug633/2.js

@@ -0,0 +1,4 @@
+/*---
+flags: [qjs:no-detect-module]
+---*/
+{ const undefined = 42 } // not a SyntaxError, not at global scope

package/native/vendor/quickjs-ng/tests/bug633/3.js

@@ -0,0 +1,4 @@
+/*---
+flags: [qjs:no-detect-module]
+---*/
+;(function() { const undefined = 42 })() // not a SyntaxError, not at global scope

package/native/vendor/quickjs-ng/tests/bug645/0.js

@@ -0,0 +1,4 @@
+"use strict";
+
+const u8 = new Uint8Array(1);
+u8[100] = 123; // Should not throw.

package/native/vendor/quickjs-ng/tests/bug645/1.js

@@ -0,0 +1,9 @@
+import { assert, assertThrows } from "../assert.js";
+const ab = new ArrayBuffer(1);
+const u8 = new Uint8Array(ab);
+assert(!ab.detached);
+// Detach the ArrayBuffer.
+ab.transfer();
+assert(ab.detached);
+u8[100] = 123; // Doesn't throw.
+assertThrows(TypeError, () => Object.defineProperty(u8, "100", { value: 123 }));

package/native/vendor/quickjs-ng/tests/bug645/2.js

@@ -0,0 +1,7 @@
+import { assert, assertThrows } from "../assert.js";
+const ab = new ArrayBuffer(16, { maxByteLength: 32 });
+const u8 = new Uint8Array(ab, 16);
+ab.resize(8);
+assert(ab.byteLength, 8);
+u8[1] = 123; // Doesn't throw.
+assertThrows(TypeError, () => Object.defineProperty(u8, "1", { value: 123 }));

package/native/vendor/quickjs-ng/tests/bug648.js

@@ -0,0 +1,13 @@
+/*---
+negative:
+  phase: runtime
+  type: Error
+---*/
+let finrec = new FinalizationRegistry(v => {})
+let object = {object:"object"}
+finrec.register(object, {held:"held"}, {token:"token"})
+object = undefined
+// abrupt termination should not leak |held|
+// unfortunately only shows up in qjs, not run-test262,
+// but still good to have a regression test
+throw Error("ok")

package/native/vendor/quickjs-ng/tests/bug652.js

@@ -0,0 +1,4 @@
+import { assert } from "./assert.js"
+const ref = new WeakRef({})
+const val = ref.deref() // should not throw
+assert(val, undefined)

package/native/vendor/quickjs-ng/tests/bug741.js

@@ -0,0 +1,19 @@
+import {assert} from "./assert.js"
+
+while (1) label: break
+
+var i = 0
+while (i < 3) label: {
+    if (i > 0)
+        break
+    i++
+}
+assert(i, 1)
+
+for (;;) label: break
+
+for (i = 0; i < 3; i++) label: {
+    if (i > 0)
+        break
+}
+assert(i, 1)

package/native/vendor/quickjs-ng/tests/bug775.js

@@ -0,0 +1,7 @@
+/*---
+negative:
+  phase: runtime
+  type: RangeError
+---*/
+function f() { f() } // was problematic under ASan
+f()

package/native/vendor/quickjs-ng/tests/bug776.js

@@ -0,0 +1,7 @@
+/*---
+negative:
+  phase: runtime
+  type: RangeError
+---*/
+function f() { f.apply(null) } // was problematic under ASan
+f()

package/native/vendor/quickjs-ng/tests/bug832.js

@@ -0,0 +1,2 @@
+const m = await import("./empty.js")
+print(m) // should not throw

package/native/vendor/quickjs-ng/tests/bug858.js

@@ -0,0 +1,26 @@
+import {assert} from "./assert.js";
+
+Error.stackTraceLimit = Infinity;
+assert(Error.stackTraceLimit === Infinity);
+assert(new Error("error").stack.includes("bug858.js")); // stack should not be empty
+
+Error.stackTraceLimit = -Infinity;
+assert(Error.stackTraceLimit === -Infinity);
+assert(!new Error("error").stack.includes("bug858.js")); // stack should be empty
+
+Error.stackTraceLimit = NaN;
+assert(Number.isNaN(Error.stackTraceLimit));
+assert(!new Error("error").stack.includes("bug858.js")); // stack should be empty
+
+Error.stackTraceLimit = -0;
+assert(Object.is(Error.stackTraceLimit, -0));
+assert(!new Error("error").stack.includes("bug858.js")); // stack should be empty
+
+const obj = { valueOf() { throw "evil" } };
+Error.stackTraceLimit = obj;
+assert(Error.stackTraceLimit === obj);
+try {
+  throw new Error("fail")
+} catch (e) {
+  assert(e.message.includes("fail"));
+}

package/native/vendor/quickjs-ng/tests/bug904.js

@@ -0,0 +1,6 @@
+import {assert, assertThrows} from "./assert.js"
+let calls = 0
+Error.prepareStackTrace = function() { calls++ }
+function f() { f() }
+assertThrows(RangeError, f)
+assert(calls, 0)

package/native/vendor/quickjs-ng/tests/bug988.js

@@ -0,0 +1,7 @@
+import {assert} from  "./assert.js"
+const expected = [97,98,99]
+const ab = new ArrayBuffer(0, {maxByteLength:3})
+const dv = new DataView(ab)
+ab.resize(3)
+for (const [i,v] of Object.entries(expected)) dv.setUint8(i, v)
+for (const [i,v] of Object.entries(expected)) assert(v, dv.getUint8(i))

package/native/vendor/quickjs-ng/tests/bug999.js

@@ -0,0 +1,3 @@
+function* f(r){ return r } // must return r
+[...f({})]
+

package/native/vendor/quickjs-ng/tests/destructured-export.js

@@ -0,0 +1,8 @@
+import { assert, assertArrayEquals } from "./assert.js";
+import * as mod from "./destructured-export.js";
+
+export const { a, b, c } = { a: 1, b: 2, c: 3 };
+export const d = 4;
+
+assert(typeof mod === 'object');
+assertArrayEquals(Object.keys(mod), ["a", "b", "c", "d"]);

package/native/vendor/quickjs-ng/tests/detect_module/0.js

@@ -0,0 +1 @@
+await undefined

package/native/vendor/quickjs-ng/tests/detect_module/1.js

@@ -0,0 +1,2 @@
+const p = Promise.resolve(42)
+await p

package/native/vendor/quickjs-ng/tests/detect_module/2.js

@@ -0,0 +1 @@
+await = 42 // parsed as classic script