jseption 0.0.3 → 0.0.5

package/dist/module.js

@@ -0,0 +1,1166 @@
+/*
+ * ES modules: loading, linking, evaluation (with top-level await), module
+ * namespace objects, dynamic import() and import.meta.
+ *
+ * Ported from quickjs.c (js_create_module_function, js_inner_module_linking,
+ * js_resolve_export, js_build_module_ns, js_inner_module_evaluation,
+ * js_async_module_execution_fulfilled/rejected, js_dynamic_import), with one
+ * change of shape: QuickJS asks a synchronous loader for each module while it
+ * resolves the graph, but a browser fetches asynchronously, so here the whole
+ * graph is fetched first (in parallel where the loader allows), and linking and
+ * evaluation run once every module is there. A loader that answers
+ * synchronously makes the whole sequence synchronous.
+ *
+ * The sandbox stays closed by default: with no loader set, nothing can be
+ * imported. The embedder's loader decides what a specifier means.
+ */
+import { JS_EXCEPTION, JS_UNINITIALIZED, JS_IsException, JS_IsObject, JS_NewAtom, JS_AtomGetStr, JS_Call, JS_NewCFunction, JS_EnqueueJob, JS_ToString, JS_Throw, JS_ThrowTypeError, JS_ThrowSyntaxError, JS_ThrowReferenceError, JS_NewObjectProto, JS_DefinePropertyValueStr, JS_GetPropertyStr, JS_GetFunctionData, js_take_exception, js_ensure_meta, js_host_exception_to_guest, hooks, JS_PROP_C_W_E, JS_ATOM_default, JS_ATOM__star_, JS_EVAL_TYPE_MODULE, JS_EVAL_FLAG_COMPILE_ONLY, JS_EVAL_FLAG_STRIP_TYPES, JS_EVAL_FLAG_JSX, } from "./quickjs.js";
+import { JSModuleDef, JSExportEntry, JSFunctionBytecode, new_var_ref_cell, } from "./values.js";
+import { js_closure_from_refs } from "./interpreter.js";
+import { JS_NewPromiseCapability, JS_PromiseState, JS_PromiseResult, perform_promise_then } from "./builtins/promise.js";
+import { JS_ParseJSON } from "./builtins/json.js";
+import { toGuest, drainJobs } from "./embed.js";
+/* the source type an id implies: .ts, .mts and .cts are TypeScript, .tsx TSX, .jsx JSX. When the
+   id is a URL (it has a scheme), its query and fragment are not part of the path, so
+   `https://app/App.tsx?v=3` and `file:///a.ts#x` are TSX and TypeScript; other ids (file paths)
+   are matched as they are, since `?` and `#` are ordinary characters there */
+export function js_module_type_of(id) {
+    const path = /^[a-z][a-z0-9+.-]*:/i.test(id) ? id.replace(/[?#].*$/s, '') : id;
+    return /\.[mc]?ts$/.test(path) ? 'ts' : /\.tsx$/.test(path) ? 'tsx' : /\.jsx$/.test(path) ? 'jsx' : 'js';
+}
+/* the JS_Eval flags that compile a source type */
+export function js_module_type_flags(type) {
+    return (type === 'ts' || type === 'tsx' ? JS_EVAL_FLAG_STRIP_TYPES : 0) | (type === 'jsx' || type === 'tsx' ? JS_EVAL_FLAG_JSX : 0);
+}
+/* Set (or clear, with null) the module loader of a runtime */
+export function JS_SetModuleLoader(rt, loader) {
+    rt.module_loader = loader;
+}
+/* the default resolution: relative specifiers against the referrer, URL style */
+export function js_default_module_resolve(specifier, referrer) {
+    if (!(specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/')))
+        return specifier;
+    if (referrer === null)
+        return normalize_path(specifier);
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(referrer)) {
+        try {
+            return new URL(specifier, referrer).href;
+        }
+        catch { /* not a URL: fall through */ }
+    }
+    if (specifier.startsWith('/'))
+        return normalize_path(specifier);
+    const slash = referrer.lastIndexOf('/');
+    const dir = slash >= 0 ? referrer.slice(0, slash + 1) : '';
+    return normalize_path(dir + specifier);
+}
+/* collapse `.` and `..` segments of a path */
+function normalize_path(path) {
+    const abs = path.startsWith('/');
+    const out = [];
+    for (const seg of path.split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..') {
+            if (out.length > 0 && out[out.length - 1] !== '..')
+                out.pop();
+            else if (!abs)
+                out.push('..');
+            continue;
+        }
+        out.push(seg);
+    }
+    const r = out.join('/');
+    return abs ? '/' + r : r;
+}
+/* QuickJS's JS_DetectModule heuristic: after comments, the source starts with `export`, or
+   with `import` not followed by `(` or `.` */
+export function JS_DetectModule(input) {
+    let p = 0;
+    const n = input.length;
+    if (input.startsWith('#!')) {
+        while (p < n && input[p] !== '\n')
+            p++;
+    }
+    const skip = () => {
+        for (;;) {
+            while (p < n && /\s/.test(input[p]))
+                p++;
+            if (input.startsWith('//', p)) {
+                while (p < n && input[p] !== '\n')
+                    p++;
+                continue;
+            }
+            if (input.startsWith('/*', p)) {
+                const e = input.indexOf('*/', p + 2);
+                p = e < 0 ? n : e + 2;
+                continue;
+            }
+            break;
+        }
+    };
+    const word = () => { const m = /^[A-Za-z_$][\w$]*/.exec(input.slice(p, p + 32)); return m ? m[0] : ''; };
+    skip();
+    const w = word();
+    if (w === 'export')
+        return true;
+    if (w !== 'import')
+        return false;
+    p += 6;
+    skip();
+    return !(input[p] === '(' || input[p] === '.');
+}
+/* ---------------------------------------------------------------------
+   Errors
+   --------------------------------------------------------------------- */
+function throw_type_error(ctx, msg) {
+    JS_ThrowTypeError(ctx, msg);
+    return js_take_exception(ctx);
+}
+function throw_syntax_error(ctx, msg) {
+    JS_ThrowSyntaxError(ctx, msg);
+    return js_take_exception(ctx);
+}
+/* a value thrown by the embedder's loader, as a guest value */
+function host_error_to_guest(ctx, e) {
+    try {
+        return toGuest(ctx, e);
+    }
+    catch {
+        return throw_type_error(ctx, String(e));
+    }
+}
+/* a value caught in this file, in the engine's convention: guest values pass through, host
+   errors become guest errors */
+function caught(ctx, e) {
+    js_host_exception_to_guest(ctx, e);
+    return js_take_exception(ctx);
+}
+function mname(ctx, m) { return JS_AtomGetStr(ctx, m.module_name); }
+/* ---------------------------------------------------------------------
+   Compiled modules
+   --------------------------------------------------------------------- */
+/* every function of a module knows its module (import.meta, the referrer of import()) */
+function js_mark_module_functions(b, m) {
+    b.module = m;
+    for (const c of b.cpool)
+        if (c instanceof JSFunctionBytecode)
+            js_mark_module_functions(c, m);
+}
+/* the module record of a compiled module body */
+export function js_module_set_function(m, b) {
+    m.func_bytecode = b;
+    js_mark_module_functions(b, m);
+}
+/* called by the parser for JS_EVAL_TYPE_MODULE */
+function js_module_compiled(ctx, m, b, flags) {
+    js_module_set_function(m, b);
+    if (flags & JS_EVAL_FLAG_COMPILE_ONLY)
+        return m;
+    return js_module_eval_function(ctx, m);
+}
+function module_key(id, kind) {
+    return kind === 'json' ? id + '\u0000json' : id;
+}
+/* register a root module (JS_Eval, JS_EvalFunction) under its name, if the name is free */
+function js_register_module(ctx, m) {
+    const key = module_key(mname(ctx, m), m.kind === 1 /* JSModuleKind.JSON */ ? 'json' : 'js');
+    if (!ctx.module_map.has(key))
+        ctx.module_map.set(key, m);
+}
+/* a synthetic module (JSON or host values) with the given named exports */
+function js_new_synthetic_module(ctx, id, kind, exports) {
+    const m = new JSModuleDef(JS_NewAtom(ctx, id));
+    m.kind = kind;
+    m.realm = ctx;
+    m.synthetic_exports = new Map();
+    for (const [name, v] of exports) {
+        const atom = JS_NewAtom(ctx, name);
+        m.export_entries.push(new JSExportEntry(atom, atom, 0 /* JSExportType.LOCAL */));
+        m.synthetic_exports.set(atom, v);
+    }
+    return m;
+}
+/* the module for what the loader returned; throws a guest value on failure */
+function js_module_from_load_result(ctx, id, kind, r) {
+    let src;
+    if (typeof r === 'string')
+        src = { source: r };
+    else if (r instanceof Uint8Array)
+        src = { bytecode: r };
+    else if (r !== null && typeof r === 'object')
+        src = r;
+    else
+        throw throw_type_error(ctx, `the module loader returned no module for '${id}'`);
+    if (src.exports !== undefined) {
+        if (kind === 'json')
+            throw throw_type_error(ctx, `'${id}' is a host module, not a JSON module`);
+        const exports = new Map();
+        for (const k of Object.keys(src.exports)) {
+            try {
+                exports.set(k, toGuest(ctx, src.exports[k]));
+            }
+            catch (e) {
+                throw host_error_to_guest(ctx, e);
+            }
+        }
+        const m = js_new_synthetic_module(ctx, id, 2 /* JSModuleKind.HOST */, exports);
+        m.url = src.url ?? null;
+        return m;
+    }
+    const type = src.type ?? (src.bytecode ? 'js' : js_module_type_of(id));
+    if (kind === 'json' || type === 'json') {
+        if (kind !== 'json')
+            throw throw_type_error(ctx, `'${id}' is a JSON module: import it with { type: "json" }`);
+        if (type !== 'json' && src.type !== undefined)
+            throw throw_type_error(ctx, `'${id}' is not a JSON module`);
+        if (typeof src.source !== 'string')
+            throw throw_type_error(ctx, `the module loader returned no JSON source for '${id}'`);
+        const v = JS_ParseJSON(ctx, src.source, id);
+        if (JS_IsException(v))
+            throw js_take_exception(ctx);
+        const m = js_new_synthetic_module(ctx, id, 1 /* JSModuleKind.JSON */, new Map([['default', v]]));
+        m.url = src.url ?? null;
+        return m;
+    }
+    let m;
+    if (src.bytecode !== undefined) {
+        const read = hooks_bytecode.read;
+        if (read === null)
+            throw throw_type_error(ctx, 'bytecode modules are not supported in this build');
+        const v = read(ctx, src.bytecode);
+        if (JS_IsException(v))
+            throw js_take_exception(ctx);
+        if (!(v instanceof JSModuleDef))
+            throw throw_type_error(ctx, `the bytecode for '${id}' is not a module`);
+        m = v;
+        /* the module takes the id it was loaded under */
+        m.module_name = JS_NewAtom(ctx, id);
+    }
+    else {
+        if (typeof src.source !== 'string')
+            throw throw_type_error(ctx, `the module loader returned no source for '${id}'`);
+        const flags = JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY | js_module_type_flags(type);
+        const v = hooks.JS_EvalInternal(ctx, undefined, src.source, id, flags, -1);
+        if (JS_IsException(v))
+            throw js_take_exception(ctx);
+        m = v;
+    }
+    m.url = src.url ?? null;
+    return m;
+}
+/* set by src/bytecode.ts: read a compiled module from bytes */
+export const hooks_bytecode = { read: null };
+/* the module type a request asks for, or a guest error */
+function js_request_kind(ctx, attrs) {
+    if (attrs === null)
+        return 'js';
+    for (const k of Object.keys(attrs)) {
+        if (k !== 'type')
+            return throw_syntax_error(ctx, `unsupported import attribute '${k}'`);
+    }
+    const t = attrs.type;
+    if (t === undefined)
+        return 'js';
+    if (t === 'json')
+        return 'json';
+    return throw_type_error(ctx, `unsupported module type '${t}'`);
+}
+function js_resolve_specifier(ctx, specifier, referrer, attrs) {
+    const loader = ctx.rt.module_loader;
+    if (loader === null)
+        throw throw_type_error(ctx, `cannot import '${specifier}': no module loader is set`);
+    let id;
+    try {
+        id = loader.resolve ? loader.resolve(specifier, referrer, attrs) : js_default_module_resolve(specifier, referrer);
+    }
+    catch (e) {
+        throw host_error_to_guest(ctx, e);
+    }
+    if (typeof id !== 'string')
+        throw throw_type_error(ctx, `the module loader could not resolve '${specifier}'`);
+    return id;
+}
+/* the module for `id`: from the context's map, or fetched with the loader. `cb` runs once,
+   synchronously if the module is there or the loader answers synchronously */
+function js_fetch_module(ctx, specifier, id, kind, attrs, cb) {
+    const key = module_key(id, kind);
+    const existing = ctx.module_map.get(key);
+    if (existing !== undefined) {
+        cb(undefined, existing);
+        return;
+    }
+    const inflight = ctx.module_inflight.get(key);
+    if (inflight !== undefined) {
+        inflight.waiters.push(cb);
+        return;
+    }
+    const loader = ctx.rt.module_loader;
+    if (loader === null) {
+        cb(throw_type_error(ctx, `cannot import '${specifier}': no module loader is set`), null);
+        return;
+    }
+    const entry = { waiters: [cb] };
+    ctx.module_inflight.set(key, entry);
+    let is_async = false;
+    const settle = (err, m) => {
+        ctx.module_inflight.delete(key);
+        if (m !== null)
+            ctx.module_map.set(key, m);
+        for (const w of entry.waiters)
+            w(err, m);
+        /* a load that finished in a host callback: run the guest jobs it started */
+        if (is_async)
+            drainJobs(ctx);
+    };
+    const done = (r) => {
+        let m;
+        try {
+            m = js_module_from_load_result(ctx, id, kind, r);
+        }
+        catch (e) {
+            settle(caught(ctx, e), null);
+            return;
+        }
+        settle(undefined, m);
+    };
+    let r;
+    try {
+        r = loader.load(id, attrs);
+    }
+    catch (e) {
+        settle(host_error_to_guest(ctx, e), null);
+        return;
+    }
+    if (r !== null && typeof r === 'object' && typeof r.then === 'function') {
+        is_async = true;
+        r.then(done, e => settle(host_error_to_guest(ctx, e), null));
+    }
+    else {
+        done(r);
+    }
+}
+/* Make sure every request of `root`, transitively, has its module. `cb(err)` runs once; it
+   runs synchronously when every module was already loaded or loaded synchronously */
+function js_load_graph(ctx, root, cb) {
+    let pending = 0;
+    let finished = false;
+    const visited = new Set();
+    const fail = (err) => { if (!finished) {
+        finished = true;
+        cb(err);
+    } };
+    const one_done = () => { if (--pending === 0 && !finished) {
+        finished = true;
+        cb(undefined);
+    } };
+    const visit = (m) => {
+        if (visited.has(m) || finished)
+            return;
+        visited.add(m);
+        const referrer = mname(ctx, m);
+        for (const rme of m.req_module_entries) {
+            if (finished)
+                return;
+            if (rme.module !== null) {
+                visit(rme.module);
+                continue;
+            }
+            const specifier = JS_AtomGetStr(ctx, rme.module_name);
+            const attrs = rme.attributes ?? {};
+            const kind = js_request_kind(ctx, rme.attributes);
+            if (kind !== 'js' && kind !== 'json') {
+                fail(kind);
+                return;
+            }
+            let id;
+            try {
+                id = js_resolve_specifier(ctx, specifier, referrer, attrs);
+            }
+            catch (e) {
+                fail(caught(ctx, e));
+                return;
+            }
+            pending++;
+            js_fetch_module(ctx, specifier, id, kind, attrs, (err, m1) => {
+                if (finished)
+                    return;
+                if (err !== undefined) {
+                    fail(err);
+                    return;
+                }
+                rme.module = m1;
+                visit(m1);
+                one_done();
+            });
+        }
+    };
+    pending++;
+    visit(root);
+    one_done();
+}
+/* ---------------------------------------------------------------------
+   Module functions and linking (js_create_module_function, js_link_module)
+   --------------------------------------------------------------------- */
+function js_create_module_function(ctx, m) {
+    if (m.func_created)
+        return 0;
+    if (m.kind !== 0 /* JSModuleKind.JS */) {
+        /* initialize the exported variables */
+        for (const me of m.export_entries)
+            me.var_ref = new_var_ref_cell(undefined);
+    }
+    else {
+        const b = m.func_bytecode;
+        /* create the module variables; the other variables are imported from other modules */
+        const var_refs = b.closure_var.map(cv => cv.is_local ? new_var_ref_cell(cv.is_lexical ? JS_UNINITIALIZED : undefined) : null);
+        const proto = ctx.class_proto[48 /* JSClassID.ASYNC_FUNCTION */] ?? ctx.function_proto;
+        const f = js_closure_from_refs(ctx, b, var_refs, proto, false);
+        if (JS_IsException(f))
+            return -1;
+        m.func_obj = f;
+    }
+    m.func_created = true;
+    /* do it on the dependencies */
+    for (const rme of m.req_module_entries) {
+        if (js_create_module_function(ctx, rme.module) < 0)
+            return -1;
+    }
+    return 0;
+}
+function module_var_refs(m) {
+    return JS_GetFunctionData(m.func_obj).var_refs;
+}
+/* the variable of a local export */
+function export_var_ref(m, me) {
+    if (me.var_ref === null)
+        me.var_ref = module_var_refs(m)[me.var_idx];
+    return me.var_ref;
+}
+function same_binding(a, b) {
+    if (a.ns !== null || b.ns !== null)
+        return a.ns === b.ns;
+    return a.module === b.module && a.me.var_idx === b.me.var_idx && a.me.local_name === b.me.local_name;
+}
+/* ResolveExport (js_resolve_export1) */
+function js_resolve_export1(m, export_name, set, out) {
+    out.b = null;
+    let names = set.get(m);
+    if (names === undefined) {
+        names = new Set();
+        set.set(m, names);
+    }
+    if (names.has(export_name))
+        return 2 /* ResolveResult.CIRCULAR */;
+    names.add(export_name);
+    const me = m.export_entries.find(e => e.export_name === export_name) ?? null;
+    if (me !== null) {
+        if (me.export_type === 0 /* JSExportType.LOCAL */) {
+            out.b = { module: m, me, ns: null };
+            return 0 /* ResolveResult.FOUND */;
+        }
+        const m1 = m.req_module_entries[me.req_module_idx].module;
+        if (me.local_name === JS_ATOM__star_) {
+            /* export * as ns from */
+            out.b = { module: m, me, ns: m1 };
+            return 0 /* ResolveResult.FOUND */;
+        }
+        return js_resolve_export1(m1, me.local_name, set, out);
+    }
+    if (export_name === JS_ATOM_default)
+        return 1 /* ResolveResult.NOT_FOUND */;
+    /* not found in the direct or indirect exports: try the star exports */
+    let star = null;
+    for (const se of m.star_export_entries) {
+        const m1 = m.req_module_entries[se.req_module_idx].module;
+        const r = { b: null };
+        const ret = js_resolve_export1(m1, export_name, set, r);
+        if (ret === 3 /* ResolveResult.AMBIGUOUS */)
+            return ret;
+        if (ret === 0 /* ResolveResult.FOUND */) {
+            if (star !== null) {
+                if (!same_binding(star, r.b))
+                    return 3 /* ResolveResult.AMBIGUOUS */;
+            }
+            else {
+                star = r.b;
+            }
+        }
+    }
+    if (star !== null) {
+        out.b = star;
+        return 0 /* ResolveResult.FOUND */;
+    }
+    return 1 /* ResolveResult.NOT_FOUND */;
+}
+function js_resolve_export(m, export_name, out) {
+    return js_resolve_export1(m, export_name, new Map(), out);
+}
+function js_resolve_export_throw_error(ctx, res, m, export_name) {
+    const n = JS_AtomGetStr(ctx, export_name), mn = mname(ctx, m);
+    switch (res) {
+        case 2 /* ResolveResult.CIRCULAR */:
+            JS_ThrowSyntaxError(ctx, `circular reference when looking for export '${n}' in module '${mn}'`);
+            break;
+        case 3 /* ResolveResult.AMBIGUOUS */:
+            JS_ThrowSyntaxError(ctx, `export '${n}' in module '${mn}' is ambiguous`);
+            break;
+        default:
+            JS_ThrowSyntaxError(ctx, `Could not find export '${n}' in module '${mn}'`);
+            break;
+    }
+}
+/* the variable a resolved binding reads */
+function binding_var_ref(ctx, b) {
+    if (b.ns !== null) {
+        const ns = js_get_module_ns(ctx, b.ns);
+        if (JS_IsException(ns))
+            return null;
+        return new_var_ref_cell(ns);
+    }
+    return export_var_ref(b.module, b.me);
+}
+/* Prepare a module to be executed by resolving all the imported variables */
+function js_inner_module_linking(ctx, m, stack, index) {
+    if (m.status === 1 /* JSModuleStatus.LINKING */ || m.status === 2 /* JSModuleStatus.LINKED */ ||
+        m.status === 4 /* JSModuleStatus.EVALUATING_ASYNC */ || m.status === 5 /* JSModuleStatus.EVALUATED */)
+        return index;
+    m.status = 1 /* JSModuleStatus.LINKING */;
+    m.dfs_index = index;
+    m.dfs_ancestor_index = index;
+    index++;
+    /* push 'm' on stack */
+    m.stack_prev = stack.top;
+    stack.top = m;
+    for (const rme of m.req_module_entries) {
+        const m1 = rme.module;
+        index = js_inner_module_linking(ctx, m1, stack, index);
+        if (index < 0)
+            return -1;
+        if (m1.status === 1 /* JSModuleStatus.LINKING */)
+            m.dfs_ancestor_index = Math.min(m.dfs_ancestor_index, m1.dfs_ancestor_index);
+    }
+    /* check the indirect exports */
+    for (const me of m.export_entries) {
+        if (me.export_type === 1 /* JSExportType.INDIRECT */ && me.local_name !== JS_ATOM__star_) {
+            const m1 = m.req_module_entries[me.req_module_idx].module;
+            const r = { b: null };
+            const ret = js_resolve_export(m1, me.local_name, r);
+            if (ret !== 0 /* ResolveResult.FOUND */) {
+                js_resolve_export_throw_error(ctx, ret, m1, me.local_name);
+                return -1;
+            }
+        }
+    }
+    if (m.kind === 0 /* JSModuleKind.JS */) {
+        const var_refs = module_var_refs(m);
+        for (const mi of m.import_entries) {
+            const m1 = m.req_module_entries[mi.req_module_idx].module;
+            if (mi.is_star) {
+                /* namespace import */
+                const ns = js_get_module_ns(ctx, m1);
+                if (JS_IsException(ns))
+                    return -1;
+                var_refs[mi.var_idx].set(ns);
+            }
+            else {
+                const r = { b: null };
+                const ret = js_resolve_export(m1, mi.import_name, r);
+                if (ret !== 0 /* ResolveResult.FOUND */) {
+                    js_resolve_export_throw_error(ctx, ret, m1, mi.import_name);
+                    return -1;
+                }
+                const vr = binding_var_ref(ctx, r.b);
+                if (vr === null)
+                    return -1;
+                var_refs[mi.var_idx] = vr;
+            }
+        }
+        /* keep the exported variables in the module export entries */
+        for (const me of m.export_entries) {
+            if (me.export_type === 0 /* JSExportType.LOCAL */)
+                export_var_ref(m, me);
+        }
+        /* initialize the global variables: with `this` true, the module function only runs its
+           hoisted definitions */
+        const ret = JS_Call(ctx, m.func_obj, true, []);
+        if (JS_IsException(ret))
+            return -1;
+    }
+    if (m.dfs_index === m.dfs_ancestor_index) {
+        for (;;) {
+            /* pop m1 from stack */
+            const m1 = stack.top;
+            stack.top = m1.stack_prev;
+            m1.status = 2 /* JSModuleStatus.LINKED */;
+            if (m1 === m)
+                break;
+        }
+    }
+    return index;
+}
+function js_link_module(ctx, m) {
+    const stack = { top: null };
+    if (js_inner_module_linking(ctx, m, stack, 0) < 0) {
+        while (stack.top !== null) {
+            const m1 = stack.top;
+            m1.status = 0 /* JSModuleStatus.UNLINKED */;
+            stack.top = m1.stack_prev;
+        }
+        return -1;
+    }
+    return 0;
+}
+/* ---------------------------------------------------------------------
+   Module namespace objects
+   --------------------------------------------------------------------- */
+/* GetExportedNames */
+function get_exported_names(m, from_star, visited, out) {
+    if (visited.has(m))
+        return;
+    visited.add(m);
+    for (const me of m.export_entries) {
+        if (from_star && me.export_name === JS_ATOM_default)
+            continue;
+        if (!out.includes(me.export_name))
+            out.push(me.export_name);
+    }
+    for (const se of m.star_export_entries) {
+        get_exported_names(m.req_module_entries[se.req_module_idx].module, true, visited, out);
+    }
+}
+function compare_code_units(a, b) { return a < b ? -1 : a > b ? 1 : 0; }
+/* Build the namespace object of a module: a host Proxy over a frozen-shape, null-prototype
+   target, so that native property access sees the live bindings (spec 10.4.6) */
+function js_build_module_ns(ctx, m) {
+    const names = [];
+    get_exported_names(m, false, new Set(), names);
+    const bindings = new Map();
+    for (const name of names) {
+        const r = { b: null };
+        const ret = js_resolve_export(m, name, r);
+        if (ret === 3 /* ResolveResult.AMBIGUOUS */)
+            continue; /* ambiguous exports are left out */
+        if (ret !== 0 /* ResolveResult.FOUND */) {
+            js_resolve_export_throw_error(ctx, ret, m, name);
+            return JS_EXCEPTION;
+        }
+        const b = r.b;
+        const key = JS_AtomGetStr(ctx, name);
+        if (b.ns !== null) {
+            /* the namespace of another module: resolved lazily (cycles) */
+            const target_module = b.ns;
+            bindings.set(key, () => {
+                const v = js_get_module_ns(ctx, target_module);
+                if (JS_IsException(v))
+                    throw js_take_exception(ctx);
+                return v;
+            });
+        }
+        else {
+            const vr = export_var_ref(b.module, b.me);
+            bindings.set(key, () => {
+                const v = vr.get();
+                if (v === JS_UNINITIALIZED) {
+                    JS_ThrowReferenceError(ctx, `'${key}' is not initialized`);
+                    throw js_take_exception(ctx);
+                }
+                return v;
+            });
+        }
+    }
+    const keys = [...bindings.keys()].sort(compare_code_units);
+    const target = Object.create(null);
+    for (const k of keys)
+        Reflect.defineProperty(target, k, { value: undefined, writable: true, enumerable: true, configurable: false });
+    Reflect.defineProperty(target, Symbol.toStringTag, { value: 'Module', writable: false, enumerable: false, configurable: false });
+    Object.preventExtensions(target);
+    const value_of = (k) => bindings.get(k)();
+    const handler = Object.assign(Object.create(null), {
+        get(t, key, receiver) {
+            if (typeof key === 'symbol')
+                return Reflect.get(t, key, receiver);
+            return bindings.has(key) ? value_of(key) : undefined;
+        },
+        set() { return false; },
+        has(t, key) {
+            if (typeof key === 'symbol')
+                return Reflect.has(t, key);
+            return bindings.has(key);
+        },
+        deleteProperty(t, key) {
+            if (typeof key === 'symbol')
+                return Reflect.deleteProperty(t, key);
+            return !bindings.has(key);
+        },
+        getOwnPropertyDescriptor(t, key) {
+            if (typeof key === 'symbol')
+                return Reflect.getOwnPropertyDescriptor(t, key);
+            if (!bindings.has(key))
+                return undefined;
+            return { value: value_of(key), writable: true, enumerable: true, configurable: false };
+        },
+        defineProperty(t, key, desc) {
+            if (typeof key === 'symbol')
+                return Reflect.defineProperty(t, key, desc);
+            if (!bindings.has(key))
+                return false;
+            const value = value_of(key); /* TDZ */
+            if (desc.configurable === true || desc.enumerable === false || desc.get !== undefined || desc.set !== undefined ||
+                desc.writable === false)
+                return false;
+            if ('value' in desc)
+                return Object.is(desc.value, value);
+            return true;
+        },
+        ownKeys() { return [...keys, Symbol.toStringTag]; },
+    });
+    const ns = new Proxy(target, handler);
+    js_ensure_meta(ns, 11 /* JSClassID.MODULE_NS */).realm = ctx;
+    return ns;
+}
+export function js_get_module_ns(ctx, m) {
+    if (m.module_ns === undefined) {
+        const ns = js_build_module_ns(ctx, m);
+        if (JS_IsException(ns))
+            return ns;
+        m.module_ns = ns;
+    }
+    return m.module_ns;
+}
+/* the namespace object of a module that has been linked */
+export function JS_GetModuleNamespace(ctx, m) {
+    return js_get_module_ns(ctx, m);
+}
+/* ---------------------------------------------------------------------
+   Evaluation (js_inner_module_evaluation and the asynchronous completion)
+   --------------------------------------------------------------------- */
+/* run a module without top-level await: 0, or -1 with the error in out.error */
+function js_execute_sync_module(ctx, m, out) {
+    if (m.kind !== 0 /* JSModuleKind.JS */) {
+        for (const me of m.export_entries)
+            me.var_ref.set(m.synthetic_exports.get(me.export_name));
+        return 0;
+    }
+    const promise = JS_Call(ctx, m.func_obj, undefined, []);
+    if (JS_IsException(promise)) {
+        out.error = js_take_exception(ctx);
+        return -1;
+    }
+    const state = JS_PromiseState(ctx, promise);
+    if (state === 1 /* JSPromiseState.FULFILLED */)
+        return 0;
+    if (state === 2 /* JSPromiseState.REJECTED */) {
+        out.error = JS_PromiseResult(ctx, promise);
+        /* the rejection is reported through the module's own promise */
+        perform_promise_then(ctx, promise, [undefined, undefined], [undefined, undefined]);
+        return -1;
+    }
+    out.error = throw_type_error(ctx, 'promise is pending');
+    return -1;
+}
+function js_execute_async_module(ctx, m) {
+    const promise = JS_Call(ctx, m.func_obj, undefined, []);
+    if (JS_IsException(promise)) {
+        js_async_module_execution_rejected(ctx, m, js_take_exception(ctx));
+        return;
+    }
+    const on_fulfilled = JS_NewCFunction(ctx, () => { js_async_module_execution_fulfilled(ctx, m); return undefined; }, '', 0);
+    const on_rejected = JS_NewCFunction(ctx, (_c, _t, argv) => { js_async_module_execution_rejected(ctx, m, argv[0]); return undefined; }, '', 1);
+    perform_promise_then(ctx, promise, [on_fulfilled, on_rejected], [undefined, undefined]);
+}
+function js_inner_module_evaluation(ctx, m, index, stack, out) {
+    if (m.status === 4 /* JSModuleStatus.EVALUATING_ASYNC */ || m.status === 5 /* JSModuleStatus.EVALUATED */) {
+        if (m.eval_has_exception) {
+            out.error = m.eval_exception;
+            return -1;
+        }
+        return index;
+    }
+    if (m.status === 3 /* JSModuleStatus.EVALUATING */)
+        return index;
+    m.status = 3 /* JSModuleStatus.EVALUATING */;
+    m.dfs_index = index;
+    m.dfs_ancestor_index = index;
+    m.pending_async_dependencies = 0;
+    index++;
+    /* push 'm' on stack */
+    m.stack_prev = stack.top;
+    stack.top = m;
+    for (const rme of m.req_module_entries) {
+        let m1 = rme.module;
+        index = js_inner_module_evaluation(ctx, m1, index, stack, out);
+        if (index < 0)
+            return -1;
+        if (m1.status === 3 /* JSModuleStatus.EVALUATING */) {
+            m.dfs_ancestor_index = Math.min(m.dfs_ancestor_index, m1.dfs_ancestor_index);
+        }
+        else {
+            m1 = m1.cycle_root;
+            if (m1.eval_has_exception) {
+                out.error = m1.eval_exception;
+                return -1;
+            }
+        }
+        if (m1.async_evaluation) {
+            m.pending_async_dependencies++;
+            m1.async_parent_modules.push(m);
+        }
+    }
+    if (m.pending_async_dependencies > 0) {
+        m.async_evaluation = true;
+        m.async_evaluation_timestamp = ctx.rt.module_async_evaluation_next_timestamp++;
+    }
+    else if (m.has_tla) {
+        m.async_evaluation = true;
+        m.async_evaluation_timestamp = ctx.rt.module_async_evaluation_next_timestamp++;
+        js_execute_async_module(ctx, m);
+    }
+    else {
+        if (js_execute_sync_module(ctx, m, out) < 0)
+            return -1;
+    }
+    if (m.dfs_index === m.dfs_ancestor_index) {
+        for (;;) {
+            /* pop m1 from stack */
+            const m1 = stack.top;
+            stack.top = m1.stack_prev;
+            m1.status = m1.async_evaluation ? 4 /* JSModuleStatus.EVALUATING_ASYNC */ : 5 /* JSModuleStatus.EVALUATED */;
+            m1.cycle_root = m;
+            if (m1 === m)
+                break;
+        }
+    }
+    return index;
+}
+/* Run the module function of the module and of all its requested modules. Returns a
+   promise (or an exception) */
+function js_evaluate_module(ctx, m) {
+    if (m.status === 4 /* JSModuleStatus.EVALUATING_ASYNC */ || m.status === 5 /* JSModuleStatus.EVALUATED */)
+        m = m.cycle_root;
+    /* a promise may be created only on the cycle_root of a cycle */
+    if (m.promise !== undefined)
+        return m.promise;
+    const funcs = [undefined, undefined];
+    const promise = JS_NewPromiseCapability(ctx, funcs);
+    if (JS_IsException(promise))
+        return promise;
+    m.promise = promise;
+    m.resolving_funcs = funcs;
+    const stack = { top: null };
+    const out = { error: undefined };
+    if (js_inner_module_evaluation(ctx, m, 0, stack, out) < 0) {
+        while (stack.top !== null) {
+            const m1 = stack.top;
+            m1.status = 5 /* JSModuleStatus.EVALUATED */;
+            m1.eval_has_exception = true;
+            m1.eval_exception = out.error;
+            m1.cycle_root = m;
+            stack.top = m1.stack_prev;
+        }
+        JS_Call(ctx, m.resolving_funcs[1], undefined, [m.eval_exception]);
+    }
+    else if (!m.async_evaluation) {
+        JS_Call(ctx, m.resolving_funcs[0], undefined, [undefined]);
+    }
+    return m.promise;
+}
+function js_set_module_evaluated(ctx, m) {
+    m.status = 5 /* JSModuleStatus.EVALUATED */;
+    if (m.promise !== undefined)
+        JS_Call(ctx, m.resolving_funcs[0], undefined, [undefined]);
+}
+/* the async parents of a module whose evaluation finished, ready to run */
+function gather_available_ancestors(module, exec_list) {
+    for (const m of module.async_parent_modules) {
+        if (!exec_list.includes(m) && !m.cycle_root.eval_has_exception) {
+            m.pending_async_dependencies--;
+            if (m.pending_async_dependencies === 0) {
+                exec_list.push(m);
+                if (!m.has_tla)
+                    gather_available_ancestors(m, exec_list);
+            }
+        }
+    }
+}
+function js_async_module_execution_rejected(ctx, module, error) {
+    if (module.status === 5 /* JSModuleStatus.EVALUATED */)
+        return;
+    module.eval_has_exception = true;
+    module.eval_exception = error;
+    module.status = 5 /* JSModuleStatus.EVALUATED */;
+    module.async_evaluation = false;
+    for (const m of module.async_parent_modules)
+        js_async_module_execution_rejected(ctx, m, error);
+    if (module.promise !== undefined)
+        JS_Call(ctx, module.resolving_funcs[1], undefined, [error]);
+}
+function js_async_module_execution_fulfilled(ctx, module) {
+    if (module.status === 5 /* JSModuleStatus.EVALUATED */)
+        return;
+    module.async_evaluation = false;
+    js_set_module_evaluated(ctx, module);
+    const exec_list = [];
+    gather_available_ancestors(module, exec_list);
+    /* sort by increasing async_evaluation timestamp */
+    exec_list.sort((a, b) => a.async_evaluation_timestamp - b.async_evaluation_timestamp);
+    for (const m of exec_list) {
+        if (m.status === 5 /* JSModuleStatus.EVALUATED */)
+            continue; /* rejected meanwhile */
+        if (m.has_tla) {
+            js_execute_async_module(ctx, m);
+        }
+        else {
+            const out = { error: undefined };
+            if (js_execute_sync_module(ctx, m, out) < 0) {
+                js_async_module_execution_rejected(ctx, m, out.error);
+            }
+            else {
+                m.async_evaluation = false;
+                js_set_module_evaluated(ctx, m);
+            }
+        }
+    }
+}
+/* ---------------------------------------------------------------------
+   Running modules
+   --------------------------------------------------------------------- */
+/* link and evaluate a module whose graph is loaded: the evaluation promise, or an exception */
+function js_link_and_evaluate(ctx, m) {
+    if (js_create_module_function(ctx, m) < 0)
+        return JS_EXCEPTION;
+    if (js_link_module(ctx, m) < 0)
+        return JS_EXCEPTION;
+    return js_evaluate_module(ctx, m);
+}
+/* Load the graph of `m`, link and evaluate it, then call `ok(ns)` or `fail(error)` */
+function js_run_module(ctx, m, ok, fail) {
+    js_load_graph(ctx, m, err => {
+        if (err !== undefined) {
+            fail(err);
+            return;
+        }
+        const p = js_link_and_evaluate(ctx, m);
+        if (JS_IsException(p)) {
+            fail(js_take_exception(ctx));
+            return;
+        }
+        const on_ful = JS_NewCFunction(ctx, () => {
+            const ns = js_get_module_ns(ctx, m);
+            if (JS_IsException(ns))
+                fail(js_take_exception(ctx));
+            else
+                ok(ns);
+            return undefined;
+        }, '', 0);
+        const on_rej = JS_NewCFunction(ctx, (_c, _t, argv) => { fail(argv[0]); return undefined; }, '', 1);
+        perform_promise_then(ctx, p, [on_ful, on_rej], [undefined, undefined]);
+    });
+}
+/* JS_EvalFunction of a compiled module (and JS_Eval of a module): with a loader that
+   answers synchronously, this is QuickJS's behaviour (load or link errors are thrown, the
+   result is the evaluation promise); otherwise a promise that settles with the evaluation */
+function js_module_eval_function(ctx, m) {
+    js_register_module(ctx, m);
+    let sync = true;
+    let result = undefined;
+    let error = undefined;
+    let has_error = false;
+    let funcs = null;
+    let promise = undefined;
+    js_load_graph(ctx, m, err => {
+        if (sync) {
+            if (err !== undefined) {
+                has_error = true;
+                error = err;
+                return;
+            }
+            result = js_link_and_evaluate(ctx, m);
+            return;
+        }
+        if (err !== undefined) {
+            JS_Call(ctx, funcs[1], undefined, [err]);
+            return;
+        }
+        const p = js_link_and_evaluate(ctx, m);
+        if (JS_IsException(p)) {
+            JS_Call(ctx, funcs[1], undefined, [js_take_exception(ctx)]);
+            return;
+        }
+        JS_Call(ctx, funcs[0], undefined, [p]);
+    });
+    if (has_error)
+        return JS_Throw(ctx, error);
+    if (result !== undefined)
+        return result;
+    /* still loading */
+    sync = false;
+    funcs = [undefined, undefined];
+    promise = JS_NewPromiseCapability(ctx, funcs);
+    return promise;
+}
+function js_new_promise(ctx) {
+    const funcs = [undefined, undefined];
+    const promise = JS_NewPromiseCapability(ctx, funcs);
+    return {
+        promise,
+        resolve: v => { JS_Call(ctx, funcs[0], undefined, [v]); },
+        reject: e => { JS_Call(ctx, funcs[1], undefined, [e]); },
+    };
+}
+/* Evaluate `source` as a module named `url`: a promise for its namespace object. `flags` may hold
+   JS_EVAL_FLAG_STRIP_TYPES and JS_EVAL_FLAG_JSX */
+export function JS_EvalModule(ctx, source, url, flags = 0) {
+    const p = js_new_promise(ctx);
+    const v = hooks.JS_EvalInternal(ctx, undefined, source, url, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY |
+        (flags & (JS_EVAL_FLAG_STRIP_TYPES | JS_EVAL_FLAG_JSX)), -1);
+    if (JS_IsException(v)) {
+        p.reject(js_take_exception(ctx));
+        return p.promise;
+    }
+    const m = v;
+    js_register_module(ctx, m);
+    js_run_module(ctx, m, p.resolve, p.reject);
+    return p.promise;
+}
+/* import(specifier) from the host: a promise for the namespace object */
+export function JS_ImportModule(ctx, specifier, referrer = null, attributes = null) {
+    const p = js_new_promise(ctx);
+    js_import(ctx, specifier, referrer, attributes, p.resolve, p.reject);
+    return p.promise;
+}
+function js_import(ctx, specifier, referrer, attributes, ok, fail) {
+    const kind = js_request_kind(ctx, attributes);
+    if (kind !== 'js' && kind !== 'json') {
+        fail(kind);
+        return;
+    }
+    const attrs = attributes ?? {};
+    let id;
+    try {
+        id = js_resolve_specifier(ctx, specifier, referrer, attrs);
+    }
+    catch (e) {
+        fail(caught(ctx, e));
+        return;
+    }
+    js_fetch_module(ctx, specifier, id, kind, attrs, (err, m) => {
+        if (err !== undefined) {
+            fail(err);
+            return;
+        }
+        js_run_module(ctx, m, ok, fail);
+    });
+}
+/* the name a function's code is known by: its module's id, or its script's file name */
+function js_referrer_of(ctx, b) {
+    if (b === null)
+        return null;
+    if (b.module !== null)
+        return mname(ctx, b.module);
+    if (b.has_debug && b.debug.filename)
+        return JS_AtomGetStr(ctx, b.debug.filename);
+    return null;
+}
+/* import(specifier, options) */
+function js_dynamic_import(ctx, b, specifier, options) {
+    const p = js_new_promise(ctx);
+    if (JS_IsException(p.promise))
+        return p.promise;
+    const reject_now = () => { p.reject(js_take_exception(ctx)); return p.promise; };
+    /* the string conversion must occur here */
+    const spec = JS_ToString(ctx, specifier);
+    if (JS_IsException(spec))
+        return reject_now();
+    let attributes = null;
+    if (options !== undefined) {
+        if (!JS_IsObject(options)) {
+            JS_ThrowTypeError(ctx, 'options must be an object');
+            return reject_now();
+        }
+        const with_obj = JS_GetPropertyStr(ctx, options, 'with');
+        if (JS_IsException(with_obj))
+            return reject_now();
+        if (with_obj !== undefined) {
+            if (!JS_IsObject(with_obj)) {
+                JS_ThrowTypeError(ctx, 'options.with must be an object');
+                return reject_now();
+            }
+            attributes = Object.create(null);
+            let keys;
+            try {
+                keys = Reflect.ownKeys(with_obj);
+            }
+            catch (e) {
+                p.reject(host_error_to_guest(ctx, e));
+                return p.promise;
+            }
+            for (const k of keys) {
+                if (typeof k !== 'string')
+                    continue;
+                let d;
+                try {
+                    d = Reflect.getOwnPropertyDescriptor(with_obj, k);
+                }
+                catch (e) {
+                    p.reject(host_error_to_guest(ctx, e));
+                    return p.promise;
+                }
+                if (!d || !d.enumerable)
+                    continue;
+                const v = JS_GetPropertyStr(ctx, with_obj, k);
+                if (JS_IsException(v))
+                    return reject_now();
+                if (typeof v !== 'string') {
+                    JS_ThrowTypeError(ctx, 'module attribute values must be strings');
+                    return reject_now();
+                }
+                attributes[k] = v;
+            }
+        }
+    }
+    const kind = js_request_kind(ctx, attributes);
+    if (kind !== 'js' && kind !== 'json') {
+        p.reject(kind);
+        return p.promise;
+    }
+    const referrer = js_referrer_of(ctx, b);
+    /* not run synchronously: it could recurse into js_evaluate_module() */
+    JS_EnqueueJob(ctx, () => {
+        js_import(ctx, spec, referrer, attributes, p.resolve, p.reject);
+        return undefined;
+    }, []);
+    return p.promise;
+}
+/* import.meta: a null-prototype object with `url` and `resolve` */
+function js_import_meta(ctx, b) {
+    const m = b?.module ?? null;
+    if (m === null)
+        return JS_ThrowTypeError(ctx, 'import.meta not supported in this context');
+    if (m.meta_obj === undefined) {
+        const meta = JS_NewObjectProto(ctx, null);
+        if (JS_IsException(meta))
+            return meta;
+        const id = mname(ctx, m);
+        JS_DefinePropertyValueStr(ctx, meta, 'url', m.url ?? id, JS_PROP_C_W_E);
+        const resolve = JS_NewCFunction(ctx, (c, _t, argv) => {
+            const spec = JS_ToString(c, argv[0]);
+            if (JS_IsException(spec))
+                return spec;
+            try {
+                return js_resolve_specifier(c, spec, id, {});
+            }
+            catch (e) {
+                return JS_Throw(c, caught(c, e));
+            }
+        }, 'resolve', 1);
+        JS_DefinePropertyValueStr(ctx, meta, 'resolve', resolve, JS_PROP_C_W_E);
+        m.meta_obj = meta;
+    }
+    return m.meta_obj;
+}
+hooks.js_module_compiled = js_module_compiled;
+hooks.js_dynamic_import = js_dynamic_import;
+hooks.js_import_meta = js_import_meta;
+hooks.js_module_eval_function = js_module_eval_function;
+//# sourceMappingURL=module.js.map