visaljs 0.0.0-stage → 0.0.2

package/runtime/src/math.c

@@ -0,0 +1,243 @@
+/* Math (§21.3), an optional component (ADR 0014). The transcendental functions are V8's
+ * fdlibm port, so results match Node's to the last bit; the rest are exact. */
+#include "js_builtins.h"
+
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "ieee754.h"
+#include "internal.h"
+#include "js_convert.h"
+#include "js_exception.h"
+#include "js_ops.h"
+
+#define NATIVE(name) static JSValue name(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, \
+                                         const JSValue *argv, JSValue new_target)
+#define UNUSED_ARGS (void)callee, (void)this_val, (void)new_target
+#define ARG(i) ((i) < argc ? argv[i] : JS_UNDEFINED)
+
+/* A function of one number: ToNumber(x), then f. */
+#define MATH1(name, f)                                       \
+    NATIVE(name) {                                           \
+        UNUSED_ARGS;                                         \
+        double x;                                            \
+        if (js_to_number(ctx, &x, ARG(0))) return JS_EXCEPTION; \
+        return js_number(f(x));                              \
+    }
+
+static double js_round(double x) {
+    if (!isfinite(x) || x == 0) return x;
+    if (x > 0 && x < 0.5) return 0.0;
+    if (x < 0 && x >= -0.5) return -0.0;
+    double r = floor(x);
+    return x - r >= 0.5 ? r + 1 : r;  /* halves round up, toward +Infinity */
+}
+
+static double js_sign(double x) {
+    return x > 0 ? 1 : x < 0 ? -1 : x;  /* ±0 and NaN as they are */
+}
+
+static double js_fround(double x) {
+    return (double)(float)x;
+}
+
+MATH1(math_abs, fabs)
+MATH1(math_acos, js_ieee754_acos)
+MATH1(math_acosh, js_ieee754_acosh)
+MATH1(math_asin, js_ieee754_asin)
+MATH1(math_asinh, js_ieee754_asinh)
+MATH1(math_atan, js_ieee754_atan)
+MATH1(math_atanh, js_ieee754_atanh)
+MATH1(math_cbrt, js_ieee754_cbrt)
+MATH1(math_ceil, ceil)
+MATH1(math_cos, js_ieee754_cos)
+MATH1(math_cosh, js_ieee754_cosh)
+MATH1(math_exp, js_ieee754_exp)
+MATH1(math_expm1, js_ieee754_expm1)
+MATH1(math_floor, floor)
+MATH1(math_fround, js_fround)
+MATH1(math_log, js_ieee754_log)
+MATH1(math_log1p, js_ieee754_log1p)
+MATH1(math_log10, js_ieee754_log10)
+MATH1(math_log2, js_ieee754_log2)
+MATH1(math_round, js_round)
+MATH1(math_sign, js_sign)
+MATH1(math_sin, js_ieee754_sin)
+MATH1(math_sinh, js_ieee754_sinh)
+MATH1(math_sqrt, sqrt)
+MATH1(math_tan, js_ieee754_tan)
+MATH1(math_tanh, js_ieee754_tanh)
+MATH1(math_trunc, trunc)
+
+NATIVE(math_atan2) {
+    UNUSED_ARGS;
+    double y, x;
+    if (js_to_number(ctx, &y, ARG(0)) || js_to_number(ctx, &x, ARG(1))) return JS_EXCEPTION;
+    return js_number(js_ieee754_atan2(y, x));
+}
+
+NATIVE(math_pow) {
+    UNUSED_ARGS;
+    double x, y;
+    if (js_to_number(ctx, &x, ARG(0)) || js_to_number(ctx, &y, ARG(1))) return JS_EXCEPTION;
+    return js_number(js_ieee754_pow(x, y));
+}
+
+NATIVE(math_clz32) {
+    UNUSED_ARGS;
+    double x;
+    if (js_to_number(ctx, &x, ARG(0))) return JS_EXCEPTION;
+    uint32_t n = (uint32_t)js_double_to_int32(x);
+    int count = 0;
+    for (uint32_t bit = 0x80000000u; bit && !(n & bit); bit >>= 1) count++;
+    return js_int32(count);
+}
+
+NATIVE(math_imul) {
+    UNUSED_ARGS;
+    double a, b;
+    if (js_to_number(ctx, &a, ARG(0)) || js_to_number(ctx, &b, ARG(1))) return JS_EXCEPTION;
+    return js_int32((int32_t)((uint32_t)js_double_to_int32(a) * (uint32_t)js_double_to_int32(b)));
+}
+
+/* max and min convert every argument first (§21.3.2.24), then compare; -0 < +0, NaN wins. */
+static JSValue min_max(JSContext *ctx, uint32_t argc, const JSValue *argv, bool max) {
+    double r = max ? -INFINITY : INFINITY;
+    bool nan = false;
+    for (uint32_t i = 0; i < argc; i++) {
+        double x;
+        if (js_to_number(ctx, &x, argv[i])) return JS_EXCEPTION;
+        if (x != x) nan = true;
+        else if (max ? (x > r || (x == 0 && r == 0 && !signbit(x))) : (x < r || (x == 0 && r == 0 && signbit(x)))) r = x;
+    }
+    return js_number(nan ? NAN : r);
+}
+
+NATIVE(math_max) {
+    UNUSED_ARGS;
+    return min_max(ctx, argc, argv, true);
+}
+
+NATIVE(math_min) {
+    UNUSED_ARGS;
+    return min_max(ctx, argc, argv, false);
+}
+
+/* hypot as V8 computes it: scaled by the largest, with Kahan summation. */
+NATIVE(math_hypot) {
+    UNUSED_ARGS;
+    double small[8], *abs_values = argc <= 8 ? small : malloc(argc * sizeof *abs_values);
+    if (!abs_values) js_fatal("out of memory");
+    double max = 0;
+    bool nan = false;
+    for (uint32_t i = 0; i < argc; i++) {
+        double x;
+        if (js_to_number(ctx, &x, argv[i])) {
+            if (abs_values != small) free(abs_values);
+            return JS_EXCEPTION;
+        }
+        abs_values[i] = fabs(x);
+        if (x != x) nan = true;
+        else if (abs_values[i] > max) max = abs_values[i];
+    }
+    double r;
+    if (max == INFINITY) r = INFINITY;
+    else if (nan) r = NAN;
+    else if (max == 0) r = 0;
+    else {
+        double sum = 0, compensation = 0;
+        for (uint32_t i = 0; i < argc; i++) {
+            double n = abs_values[i] / max;
+            double summand = n * n - compensation;
+            double preliminary = sum + summand;
+            compensation = (preliminary - sum) - summand;
+            sum = preliminary;
+        }
+        r = sqrt(sum) * max;
+    }
+    if (abs_values != small) free(abs_values);
+    return js_number(r);
+}
+
+/* random: xorshift128+, as V8 uses, seeded once per program. */
+static uint64_t random_state[2];
+
+static uint64_t splitmix(uint64_t *x) {
+    uint64_t z = (*x += 0x9E3779B97F4A7C15u);
+    z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9u;
+    z = (z ^ (z >> 27)) * 0x94D049BB133111EBu;
+    return z ^ (z >> 31);
+}
+
+NATIVE(math_random) {
+    UNUSED_ARGS;
+    (void)ctx, (void)argc, (void)argv;
+    if (!random_state[0] && !random_state[1]) {
+        uint64_t seed = (uint64_t)time(NULL) ^ ((uint64_t)(uintptr_t)&seed << 16) ^ (uint64_t)clock();
+        random_state[0] = splitmix(&seed);
+        random_state[1] = splitmix(&seed);
+    }
+    uint64_t s1 = random_state[0];
+    const uint64_t s0 = random_state[1];
+    random_state[0] = s0;
+    s1 ^= s1 << 23;
+    random_state[1] = s1 ^ s0 ^ (s1 >> 17) ^ (s0 >> 26);
+    return js_double((double)(random_state[1] >> 11) * 0x1.0p-53);  /* [0, 1) */
+}
+
+/* in V8's order (Object.getOwnPropertyNames(Math) is the same as Node's) */
+static const JSBuiltin math_entries[] = {
+    JS_BUILTIN_FN("abs", math_abs, 1),
+    JS_BUILTIN_FN("acos", math_acos, 1),
+    JS_BUILTIN_FN("acosh", math_acosh, 1),
+    JS_BUILTIN_FN("asin", math_asin, 1),
+    JS_BUILTIN_FN("asinh", math_asinh, 1),
+    JS_BUILTIN_FN("atan", math_atan, 1),
+    JS_BUILTIN_FN("atanh", math_atanh, 1),
+    JS_BUILTIN_FN("atan2", math_atan2, 2),
+    JS_BUILTIN_FN("ceil", math_ceil, 1),
+    JS_BUILTIN_FN("cbrt", math_cbrt, 1),
+    JS_BUILTIN_FN("expm1", math_expm1, 1),
+    JS_BUILTIN_FN("clz32", math_clz32, 1),
+    JS_BUILTIN_FN("cos", math_cos, 1),
+    JS_BUILTIN_FN("cosh", math_cosh, 1),
+    JS_BUILTIN_FN("exp", math_exp, 1),
+    JS_BUILTIN_FN("floor", math_floor, 1),
+    JS_BUILTIN_FN("fround", math_fround, 1),
+    JS_BUILTIN_FN("hypot", math_hypot, 2),
+    JS_BUILTIN_FN("imul", math_imul, 2),
+    JS_BUILTIN_FN("log", math_log, 1),
+    JS_BUILTIN_FN("log1p", math_log1p, 1),
+    JS_BUILTIN_FN("log2", math_log2, 1),
+    JS_BUILTIN_FN("log10", math_log10, 1),
+    JS_BUILTIN_FN("max", math_max, 2),
+    JS_BUILTIN_FN("min", math_min, 2),
+    JS_BUILTIN_FN("pow", math_pow, 2),
+    JS_BUILTIN_FN("random", math_random, 0),
+    JS_BUILTIN_FN("round", math_round, 1),
+    JS_BUILTIN_FN("sign", math_sign, 1),
+    JS_BUILTIN_FN("sin", math_sin, 1),
+    JS_BUILTIN_FN("sinh", math_sinh, 1),
+    JS_BUILTIN_FN("sqrt", math_sqrt, 1),
+    JS_BUILTIN_FN("tan", math_tan, 1),
+    JS_BUILTIN_FN("tanh", math_tanh, 1),
+    JS_BUILTIN_FN("trunc", math_trunc, 1),
+    JS_BUILTIN_NUMBER("E", 2.718281828459045, 0),
+    JS_BUILTIN_NUMBER("LN10", 2.302585092994046, 0),
+    JS_BUILTIN_NUMBER("LN2", 0.6931471805599453, 0),
+    JS_BUILTIN_NUMBER("LOG10E", 0.4342944819032518, 0),
+    JS_BUILTIN_NUMBER("LOG2E", 1.4426950408889634, 0),
+    JS_BUILTIN_NUMBER("PI", 3.141592653589793, 0),
+    JS_BUILTIN_NUMBER("SQRT1_2", 0.7071067811865476, 0),
+    JS_BUILTIN_NUMBER("SQRT2", 1.4142135623730951, 0),
+    JS_BUILTIN_SYMBOL_STRING(toStringTag, "Math", JS_PROP_CONFIGURABLE),
+};
+
+static void install_math(JSContext *ctx, JSObject *global) {
+    JSValue math = js_new_builtin_object(ctx, math_entries, JS_COUNTOF(math_entries));
+    js_define_data(ctx, global, js_atom_from_cstr(ctx, "Math"), math, JS_BUILTIN_METHOD_ATTRS);
+}
+
+const JSComponent js_component_math = { "math", install_math };

package/runtime/src/module.c

@@ -0,0 +1,336 @@
+/* Module-level host behavior (ADR 0009): import.meta, one object per original file, and
+ * import() of a specifier the bundler couldn't resolve at build time. Errors and URLs
+ * follow Node: ERR_MODULE_NOT_FOUND, file: URLs percent-encoded like the WHATWG URL parser. */
+#include "js_module.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "internal.h"
+#include "js_atoms.h"
+#include "js_convert.h"
+#include "js_error.h"
+#include "js_exception.h"
+#include "js_promise.h"
+#include "js_symbol.h"
+#include "jsstring.h"
+
+/* ---- A growable UTF-8 buffer ------------------------------------------- */
+
+typedef struct {
+    char *s;
+    size_t len, cap;
+} Buf;
+
+static void put(Buf *b, const char *s, size_t n) {
+    if (b->len + n + 1 > b->cap) {
+        size_t cap = b->cap ? b->cap * 2 : 128;
+        while (cap < b->len + n + 1) cap *= 2;
+        char *grown = realloc(b->s, cap);
+        if (!grown) js_fatal("out of memory");
+        b->s = grown;
+        b->cap = cap;
+    }
+    memcpy(b->s + b->len, s, n);
+    b->len += n;
+    b->s[b->len] = '\0';
+}
+
+static void puts_(Buf *b, const char *s) { put(b, s, strlen(s)); }
+
+/* Characters of a URL path the WHATWG parser percent-encodes (the path percent-encode set),
+ * and in the query and fragment (`in_path` false: the fragment set, which the query's covers). */
+static bool needs_encoding(unsigned char c, bool in_path) {
+    if (c <= 0x20 || c >= 0x7F) return true;
+    switch (c) {
+    case '"': case '<': case '>': case '`': return true;
+    case '#': case '?': case '{': case '}': return in_path;
+    default: return false;
+    }
+}
+
+static void put_encoded(Buf *b, const char *s, size_t n, bool in_path) {
+    static const char HEX[] = "0123456789ABCDEF";
+    for (size_t i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)s[i];
+        if (needs_encoding(c, in_path)) {
+            char esc[3] = { '%', HEX[c >> 4], HEX[c & 15] };
+            put(b, esc, 3);
+        } else {
+            put(b, (const char *)&c, 1);
+        }
+    }
+}
+
+/* Appends `path` (absolute, '/'-separated) with its dot segments removed, as the WHATWG URL
+ * parser does: `.` is dropped, `..` drops the segment before it, and either one at the end
+ * leaves a trailing slash. Empty segments (`a//b`) stay. */
+static void put_normalized_path(Buf *b, const char *path, size_t n) {
+    size_t base = b->len;
+    size_t i = path[0] == '/' ? 1 : 0;
+    for (;;) {
+        size_t start = i;
+        while (i < n && path[i] != '/') i++;
+        size_t len = i - start;
+        bool last = i >= n;
+        if (len == 2 && path[start] == '.' && path[start + 1] == '.') {
+            if (b->len > base) {                   /* drop "/segment" */
+                while (b->s[b->len - 1] != '/') b->len--;
+                b->len--;
+            }
+            if (last) put(b, "/", 1);
+        } else if (len == 1 && path[start] == '.') {
+            if (last) put(b, "/", 1);
+        } else {
+            put(b, "/", 1);
+            put(b, path + start, len);
+        }
+        if (last) break;
+        i++;  /* past the '/' */
+    }
+    if (b->len == base) put(b, "/", 1);
+    b->s[b->len] = '\0';
+}
+
+/* The file: URL of an absolute path. */
+static void put_file_url(Buf *b, const char *path) {
+    puts_(b, "file://");
+    put_encoded(b, path, strlen(path), true);
+}
+
+static char *utf8_of(JSContext *ctx, JSValue s) {
+    JSStrView v = js_string_view(ctx, s);
+    size_t n = js_view_to_utf8(v, NULL, 0);
+    char *out = malloc(n + 1);
+    if (!out) js_fatal("out of memory");
+    js_view_to_utf8(v, out, n);
+    out[n] = '\0';
+    return out;
+}
+
+static bool starts_with(const char *s, const char *prefix) {
+    return strncmp(s, prefix, strlen(prefix)) == 0;
+}
+
+/* A URL scheme followed by ':' (`file:`, `https:`; not a Windows drive letter's one character). */
+static size_t scheme_length(const char *s) {
+    if (!((s[0] >= 'a' && s[0] <= 'z') || (s[0] >= 'A' && s[0] <= 'Z'))) return 0;
+    size_t i = 1;
+    while ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= '0' && s[i] <= '9') ||
+           s[i] == '+' || s[i] == '-' || s[i] == '.')
+        i++;
+    return s[i] == ':' && i > 1 ? i : 0;
+}
+
+/* Node built-in modules visaljs provides as bare names (node/prelude). */
+static const char *const HOST_MODULES[] = { "fs", "path", "util" };
+
+/* ERR_MODULE_NOT_FOUND, as Node words it. */
+static JSValue not_found(JSContext *ctx, const char *what, const char *name, const char *importer) {
+    Buf b = { 0 };
+    puts_(&b, "Cannot find ");
+    puts_(&b, what);
+    puts_(&b, " '");
+    puts_(&b, name);
+    puts_(&b, "' imported from ");
+    puts_(&b, importer);
+    JSValue msg = js_new_string_utf8(ctx, b.s, b.len);
+    free(b.s);
+    if (js_is_exception(msg)) return msg;
+    JSValue err = js_new_error(ctx, JS_ERROR, msg);
+    if (js_is_exception(err)) return err;
+    JSValue code = js_new_string_cstr(ctx, "ERR_MODULE_NOT_FOUND");
+    if (js_is_exception(code)) return code;
+    js_define_data(ctx, js_as_object(err), js_atom_from_cstr(ctx, "code"), code, JS_PROP_DEFAULT);
+    return err;
+}
+
+/* Resolves a specifier against the module at `importer` (an absolute path), into `out`.
+ * 0, or -1 with *error set (ERR_MODULE_NOT_FOUND for packages, which only the bundler resolves). */
+static int resolve_specifier(JSContext *ctx, const char *spec, const char *importer, Buf *out, JSValue *error) {
+    if (starts_with(spec, "node:")) {
+        puts_(out, spec);
+        return 0;
+    }
+    for (size_t i = 0; i < sizeof HOST_MODULES / sizeof HOST_MODULES[0]; i++) {
+        if (strcmp(spec, HOST_MODULES[i]) == 0) {
+            puts_(out, "node:");
+            puts_(out, spec);
+            return 0;
+        }
+    }
+    bool relative = strcmp(spec, ".") == 0 || strcmp(spec, "..") == 0 || starts_with(spec, "./") ||
+                    starts_with(spec, "../") || spec[0] == '/';
+    size_t scheme = scheme_length(spec);
+    if (!relative && !scheme) {
+        /* a package: its name is the first segment (two for a scope, @scope/name) */
+        const char *slash = strchr(spec, '/');
+        if (spec[0] == '@' && slash) slash = strchr(slash + 1, '/');
+        size_t n = slash ? (size_t)(slash - spec) : strlen(spec);
+        char *name = malloc(n + 1);
+        if (!name) js_fatal("out of memory");
+        memcpy(name, spec, n);
+        name[n] = '\0';
+        *error = not_found(ctx, "package", name, importer);
+        free(name);
+        return -1;
+    }
+    const char *rest;
+    Buf path = { 0 };
+    if (scheme) {
+        /* an absolute URL: scheme://authority kept, its path normalized */
+        const char *p = spec + scheme + 1;
+        size_t prefix = scheme + 1;
+        if (p[0] == '/' && p[1] == '/') {
+            const char *end = p + 2;
+            while (*end && *end != '/' && *end != '?' && *end != '#') end++;
+            prefix = (size_t)(end - spec);
+        }
+        put(out, spec, prefix);
+        const char *path_start = spec + prefix;
+        rest = path_start + strcspn(path_start, "?#");
+        put(&path, path_start, (size_t)(rest - path_start));
+        if (path.len == 0) put(&path, "/", 1);
+    } else {
+        puts_(out, "file://");
+        rest = spec + strcspn(spec, "?#");
+        if (spec[0] != '/') {
+            /* the importer's directory, then the specifier */
+            const char *dir_end = strrchr(importer, '/');
+            put(&path, importer, dir_end ? (size_t)(dir_end - importer) + 1 : 0);
+        }
+        put(&path, spec, (size_t)(rest - spec));
+    }
+    for (size_t i = 0; i < path.len; i++)
+        if (path.s[i] == '\\') path.s[i] = '/';  /* special schemes treat backslashes as slashes */
+    Buf normalized = { 0 };
+    put_normalized_path(&normalized, path.s, path.len);
+    put_encoded(out, normalized.s, normalized.len, !scheme || starts_with(spec, "file:"));
+    put_encoded(out, rest, strlen(rest), false);
+    free(path.s);
+    free(normalized.s);
+    return 0;
+}
+
+/* import.meta.resolve(specifier): the module's path is the function's home_object. */
+static JSValue meta_resolve(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
+                            const JSValue *argv, JSValue new_target) {
+    (void)this_val, (void)new_target;
+    JSValue s = js_to_string(ctx, argc ? argv[0] : JS_UNDEFINED);
+    if (js_is_exception(s)) return s;
+    char *spec = utf8_of(ctx, s);
+    char *importer = utf8_of(ctx, js_as_function(callee)->home_object);
+    Buf out = { 0 };
+    JSValue error = JS_UNDEFINED;
+    int r = resolve_specifier(ctx, spec, importer, &out, &error);
+    free(spec);
+    free(importer);
+    if (r < 0) {
+        free(out.s);
+        return js_is_exception(error) ? error : js_throw(ctx, error);
+    }
+    JSValue result = js_new_string_utf8(ctx, out.s, out.len);
+    free(out.s);
+    return result;
+}
+
+JSValue js_import_meta(JSContext *ctx, JSValue *cache, const char *file, bool main) {
+    if (js_is_object(*cache)) return *cache;
+    JSValue meta = js_new_object_proto(ctx, JS_NULL, 5);
+    if (js_is_exception(meta)) return meta;
+    JSObject *o = js_as_object(meta);
+    const char *slash = strrchr(file, '/');
+    size_t dir_len = slash == file ? 1 : slash ? (size_t)(slash - file) : 0;
+    JSValue path = js_new_string_cstr(ctx, file);
+    if (js_is_exception(path)) return path;
+    JSValue dirname = js_new_string_utf8(ctx, file, dir_len);
+    if (js_is_exception(dirname)) return dirname;
+    Buf url = { 0 };
+    put_file_url(&url, file);
+    JSValue href = js_new_string_utf8(ctx, url.s, url.len);
+    free(url.s);
+    if (js_is_exception(href)) return href;
+    js_define_data(ctx, o, js_atom_from_cstr(ctx, "dirname"), dirname, JS_PROP_DEFAULT);
+    js_define_data(ctx, o, js_atom_from_cstr(ctx, "filename"), path, JS_PROP_DEFAULT);
+    js_define_data(ctx, o, js_atom_from_cstr(ctx, "main"), js_bool(main), JS_PROP_DEFAULT);
+    JSValue resolve = js_new_native(ctx, meta_resolve, js_atom_from_cstr(ctx, "resolve"), 1, JS_FN_STRICT);
+    if (js_is_exception(resolve)) return resolve;
+    js_set_home_object(ctx, resolve, path);
+    js_define_data(ctx, o, js_atom_from_cstr(ctx, "resolve"), resolve, JS_PROP_DEFAULT);
+    js_define_data(ctx, o, js_atom_from_cstr(ctx, "url"), href, JS_PROP_DEFAULT);
+    *cache = meta;
+    return meta;
+}
+
+/* Rejects `promise` with the pending exception; returns it. */
+static JSValue reject_pending(JSContext *ctx, JSValue promise) {
+    js_promise_reject_internal(ctx, promise, js_take_exception(ctx));
+    return promise;
+}
+
+static JSValue reject_type_error(JSContext *ctx, JSValue promise, const char *message) {
+    JSValue e = js_throw_type_error(ctx, "%s", message);
+    (void)e;
+    return reject_pending(ctx, promise);
+}
+
+/* §13.3.10.1 EvaluateImportCall, after the arguments are evaluated: the specifier and the
+ * options are checked as the spec says (each failure rejects, with V8's messages), then the
+ * module, which can't be in the program (the bundler inlines every import() it can resolve),
+ * isn't found. */
+JSValue js_dynamic_import(JSContext *ctx, JSValue specifier, JSValue options, const char *importer) {
+    JSValue promise = js_new_promise(ctx);
+    if (js_is_exception(promise)) return promise;
+    JSValue s = js_to_string(ctx, specifier);
+    if (js_is_exception(s)) return reject_pending(ctx, promise);
+    if (!js_is_undefined(options)) {
+        if (!js_is_object(options)) return reject_type_error(ctx, promise, "The second argument to import() must be an object");
+        JSValue with = js_get(ctx, js_as_object(options), js_atom_from_cstr(ctx, "with"), options);
+        if (js_is_exception(with)) return reject_pending(ctx, promise);
+        if (!js_is_undefined(with)) {
+            if (!js_is_object(with)) return reject_type_error(ctx, promise, "The 'assert' option must be an object");
+            JSValue keys = js_own_keys(ctx, js_as_object(with));
+            if (js_is_exception(keys)) return reject_pending(ctx, promise);
+            JSValueArray *list = (JSValueArray *)js_as_cell(keys);
+            for (uint32_t i = 0; i < list->cell.aux; i++) {
+                JSValue key = list->values[i];
+                if (js_is_symbol(key)) continue;
+                JSPropertyDescriptor desc;
+                int has = js_get_own_property(ctx, js_as_object(with), key, &desc);
+                if (has < 0) return reject_pending(ctx, promise);
+                if (!has || !(desc.attrs & JS_PROP_ENUMERABLE)) continue;
+                JSValue v = js_get(ctx, js_as_object(with), key, with);
+                if (js_is_exception(v)) return reject_pending(ctx, promise);
+                if (!js_is_string(v)) return reject_type_error(ctx, promise, "Import assertion value must be a string");
+            }
+        }
+    }
+    char *spec = utf8_of(ctx, s);
+    Buf out = { 0 };
+    JSValue error = JS_UNDEFINED;
+    if (resolve_specifier(ctx, spec, importer, &out, &error) == 0) {
+        /* a file: Node names its path; anything else (node:os, https:) its URL */
+        const char *name = out.s;
+        Buf decoded = { 0 };
+        if (starts_with(out.s, "file://")) {
+            for (const char *p = out.s + 7; *p; p++) {
+                if (p[0] == '%' && p[1] && p[2]) {
+                    char hex[3] = { p[1], p[2], 0 };
+                    char c = (char)strtol(hex, NULL, 16);
+                    put(&decoded, &c, 1);
+                    p += 2;
+                } else {
+                    put(&decoded, p, 1);
+                }
+            }
+            name = decoded.s ? decoded.s : "";
+        }
+        error = not_found(ctx, "module", name, importer);
+        free(decoded.s);
+    }
+    free(spec);
+    free(out.s);
+    if (js_is_exception(error)) return reject_pending(ctx, promise);
+    js_promise_reject_internal(ctx, promise, error);
+    return promise;
+}