visaljs 0.0.0-stage → 0.0.2

package/runtime/src/jobs.c

@@ -0,0 +1,337 @@
+/* The job queue (ADR 0008, layer 1: microtasks, unhandled rejections) and the event
+ * loop (layer 2: timers; the v1 backend has no I/O, so waiting is sleeping). */
+#include "js_jobs.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "internal.h"
+#include "js_console.h"
+#include "js_convert.h"
+#include "js_function.h"
+#include "js_promise.h"
+#include "jscontext.h"
+#include "os.h"
+
+/* ---- The queue -------------------------------------------------------------------- */
+
+void js_enqueue_microtask(JSContext *ctx, const JSJob *job) {
+    JSJobQueue *q = &ctx->rt->jobs;
+    if (q->count == q->cap) {  /* grow, unwrapping the ring: no allocation of cells, so no GC */
+        size_t cap = q->cap ? q->cap * 2 : 64;
+        JSJob *items = malloc(cap * sizeof *items);
+        if (!items) js_fatal("out of memory queueing a job");
+        for (size_t i = 0; i < q->count; i++) items[i] = q->items[(q->head + i) % q->cap];
+        free(q->items);
+        q->items = items;
+        q->head = 0;
+        q->cap = cap;
+    }
+    JSJob *slot = &q->items[(q->head + q->count) % q->cap];
+    *slot = *job;
+    slot->realm = ctx;
+    q->count++;
+}
+
+static int run_job(const JSJob *job) {
+    JSContext *ctx = job->realm;
+    switch (job->kind) {
+    case JS_JOB_PROMISE_REACTION: return js_promise_reaction_job(ctx, job->a, job->b, job->c);
+    case JS_JOB_RESOLVE_THENABLE: return js_promise_thenable_job(ctx, job->a, job->b, job->c);
+    default: {
+        uint32_t argc = js_is_array(job->b) ? js_array_length(js_as_object(job->b)) : 0;
+        JSValue small[8], *argv = argc <= 8 ? small : malloc(argc * sizeof *argv);
+        if (!argv) js_fatal("out of memory running a job");
+        for (uint32_t i = 0; i < argc; i++) {
+            argv[i] = js_get_elem(ctx, job->b, js_index_key(i));
+            if (js_is_exception(argv[i])) {
+                if (argv != small) free(argv);
+                return -1;
+            }
+        }
+        JSValue r = js_call(ctx, job->a, JS_UNDEFINED, argc, argv);
+        if (argv != small) free(argv);
+        return js_is_exception(r) ? -1 : 0;
+    }
+    }
+}
+
+/* ---- Unhandled rejections ------------------------------------------------------- */
+
+void js_set_rejection_mode(JSRuntime *rt, JSRejectionMode mode) { rt->rejection_mode = (uint8_t)mode; }
+
+void js_track_rejection(JSContext *ctx, JSValue promise, bool rejected) {
+    JSRuntime *rt = ctx->rt;
+    struct JSRejections *l = &rt->rejections;
+    if (rt->rejection_mode == JS_REJECTIONS_NONE) return;
+    if (rejected) {
+        if (l->count == l->cap) {
+            size_t cap = l->cap ? l->cap * 2 : 16;
+            JSValue *items = realloc(l->items, cap * sizeof *items);
+            if (!items) js_fatal("out of memory tracking a rejection");
+            l->items = items;
+            l->cap = cap;
+        }
+        l->items[l->count++] = promise;
+        return;
+    }
+    for (size_t i = 0; i < l->count; i++) {  /* handled before the checkpoint ended: not reported */
+        if (js_same_bits(l->items[i], promise)) {
+            memmove(&l->items[i], &l->items[i + 1], (l->count - i - 1) * sizeof *l->items);
+            l->count--;
+            return;
+        }
+    }
+}
+
+/* Reports what is still unhandled. Strict: the first one ends the program (like Node). */
+static int process_rejections(JSContext *ctx) {
+    JSRuntime *rt = ctx->rt;
+    struct JSRejections *l = &rt->rejections;
+    while (l->count) {
+        JSValue promise = l->items[0];
+        memmove(&l->items[0], &l->items[1], (l->count - 1) * sizeof *l->items);
+        l->count--;
+        js_report_error(ctx, "Uncaught (in promise) ", js_as_promise(promise)->result);
+        if (rt->rejection_mode == JS_REJECTIONS_STRICT) {
+            l->count = 0;
+            return -1;
+        }
+    }
+    return 0;
+}
+
+/* ---- The checkpoint -------------------------------------------------------------- */
+
+int js_run_microtasks(JSContext *ctx) {
+    JSRuntime *rt = ctx->rt;
+    if (rt->in_checkpoint) return 0;
+    rt->in_checkpoint = 1;
+    JSJobQueue *q = &rt->jobs;
+    int status = 0;
+    while (q->count) {
+        JSJob job = q->items[q->head];  /* on the C stack: the conservative scan keeps it alive */
+        q->head = (q->head + 1) % q->cap;
+        q->count--;
+        if (run_job(&job) < 0) {
+            js_report_uncaught(job.realm);
+            status = -1;
+            break;
+        }
+    }
+    js_clear_kept_objects(rt);  /* the end of the job: WeakRef targets may go now */
+    if (status == 0) status = process_rejections(ctx);
+    rt->in_checkpoint = 0;
+    return status;
+}
+
+/* ---- GC and teardown (gc.c) ----------------------------------------------------- */
+
+void js_jobs_trace(JSRuntime *rt, JSTracer *trc) {
+    JSJobQueue *q = &rt->jobs;
+    for (size_t i = 0; i < q->count; i++) {
+        JSJob *j = &q->items[(q->head + i) % q->cap];
+        js_trace_value(trc, j->a);
+        js_trace_value(trc, j->b);
+        js_trace_value(trc, j->c);
+    }
+    for (size_t i = 0; i < rt->rejections.count; i++) js_trace_value(trc, rt->rejections.items[i]);
+    for (size_t i = 0; i < rt->timers.count; i++) {
+        js_trace_value(trc, rt->timers.heap[i].fn);
+        js_trace_value(trc, rt->timers.heap[i].args);
+    }
+}
+
+void js_jobs_free(JSRuntime *rt) {
+    free(rt->jobs.items);
+    free(rt->rejections.items);
+    free(rt->timers.heap);
+}
+
+/* ---- Timers: a min-heap on (deadline, creation order) ------------------------------ */
+
+static bool before(const JSTimer *a, const JSTimer *b) {
+    return a->deadline < b->deadline || (a->deadline == b->deadline && a->seq < b->seq);
+}
+
+static void swap(JSTimer *a, JSTimer *b) {
+    JSTimer x = *a;
+    *a = *b;
+    *b = x;
+}
+
+static void sift_up(JSTimers *t, size_t i) {
+    for (; i > 0 && before(&t->heap[i], &t->heap[(i - 1) / 2]); i = (i - 1) / 2) swap(&t->heap[i], &t->heap[(i - 1) / 2]);
+}
+
+static void sift_down(JSTimers *t, size_t i) {
+    for (;;) {
+        size_t l = 2 * i + 1, r = l + 1, m = i;
+        if (l < t->count && before(&t->heap[l], &t->heap[m])) m = l;
+        if (r < t->count && before(&t->heap[r], &t->heap[m])) m = r;
+        if (m == i) return;
+        swap(&t->heap[i], &t->heap[m]);
+        i = m;
+    }
+}
+
+static void timer_push(JSTimers *t, const JSTimer *timer) {
+    if (t->count == t->cap) {
+        size_t cap = t->cap ? t->cap * 2 : 16;
+        JSTimer *heap = realloc(t->heap, cap * sizeof *heap);
+        if (!heap) js_fatal("out of memory adding a timer");
+        t->heap = heap;
+        t->cap = cap;
+    }
+    t->heap[t->count++] = *timer;
+    if (!timer->unref) t->refed++;
+    sift_up(t, t->count - 1);
+}
+
+static void timer_remove(JSTimers *t, size_t i) {
+    if (!t->heap[i].unref) t->refed--;
+    t->heap[i] = t->heap[--t->count];
+    if (i < t->count) {
+        sift_down(t, i);
+        sift_up(t, i);
+    }
+}
+
+#define TIMEOUT_MAX 2147483647.0  /* Node's: longer delays, like shorter than 1 ms, become 1 */
+
+/* setTimeout(fn, delay, ...args) / setInterval: the delay as Node takes it. */
+static JSValue add_timer(JSContext *ctx, uint32_t argc, const JSValue *argv, bool repeat) {
+    JSValue fn = argc ? argv[0] : JS_UNDEFINED;
+    if (!js_is_callable(fn)) return js_throw_type_error(ctx, "The \"callback\" argument must be of type function");
+    double delay = 1;
+    if (argc > 1 && js_to_number(ctx, &delay, argv[1]) < 0) return JS_EXCEPTION;
+    if (!(delay >= 1 && delay <= TIMEOUT_MAX)) delay = 1;
+    JSValue args = argc > 2 ? js_new_array_from(ctx, argv + 2, argc - 2) : JS_UNDEFINED;
+    JSTimers *t = &ctx->rt->timers;
+    if (++t->next_id > 2147483647u) t->next_id = 1;
+    JSTimer timer = { t->now + (uint64_t)delay, t->seq++, t->next_id, repeat ? (uint32_t)delay : 0, 0, ctx, fn, args };
+    timer_push(t, &timer);
+    return js_int32((int32_t)timer.id);
+}
+
+uint32_t js_add_timer(JSContext *ctx, JSValue fn, double delay, bool unref) {
+    if (!(delay >= 1 && delay <= TIMEOUT_MAX)) delay = 1;
+    JSTimers *t = &ctx->rt->timers;
+    if (!t->now) t->now = js_os_now_ms();
+    if (++t->next_id > 2147483647u) t->next_id = 1;
+    JSTimer timer = { t->now + (uint64_t)delay, t->seq++, t->next_id, 0, unref, ctx, fn, JS_UNDEFINED };
+    timer_push(t, &timer);
+    return timer.id;
+}
+
+/* clearTimeout / clearInterval (either clears both kinds, as in Node). */
+static void clear_timer(JSContext *ctx, uint32_t argc, const JSValue *argv) {
+    if (!argc || !js_is_number(argv[0])) return;
+    double d = js_as_number(argv[0]);
+    JSTimers *t = &ctx->rt->timers;
+    if (t->running && d == (double)t->running) t->running_cleared = 1;
+    for (size_t i = 0; i < t->count; i++) {
+        if ((double)t->heap[i].id == d) {
+            timer_remove(t, i);
+            return;
+        }
+    }
+}
+
+#define HOST_FN(fn) static JSValue fn(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target)
+
+HOST_FN(set_timeout) {
+    (void)callee, (void)this_val, (void)new_target;
+    return add_timer(ctx, argc, argv, false);
+}
+HOST_FN(set_interval) {
+    (void)callee, (void)this_val, (void)new_target;
+    return add_timer(ctx, argc, argv, true);
+}
+/* setImmediate(fn, ...args): a timer due at the loop's time, so it runs before any later deadline */
+HOST_FN(set_immediate) {
+    (void)callee, (void)this_val, (void)new_target;
+    JSValue fn = argc ? argv[0] : JS_UNDEFINED;
+    if (!js_is_callable(fn)) return js_throw_type_error(ctx, "The \"callback\" argument must be of type function");
+    JSValue args = argc > 1 ? js_new_array_from(ctx, argv + 1, argc - 1) : JS_UNDEFINED;
+    JSTimers *t = &ctx->rt->timers;
+    if (++t->next_id > 2147483647u) t->next_id = 1;
+    JSTimer timer = { t->now, t->seq++, t->next_id, 0, 0, ctx, fn, args };
+    timer_push(t, &timer);
+    return js_int32((int32_t)timer.id);
+}
+HOST_FN(clear_timeout) {
+    (void)callee, (void)this_val, (void)new_target;
+    clear_timer(ctx, argc, argv);
+    return JS_UNDEFINED;
+}
+
+/* ---- The event loop (layer 2) ------------------------------------------------------ */
+
+static JSValue queue_microtask(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
+                               const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    JSValue fn = argc ? argv[0] : JS_UNDEFINED;
+    if (!js_is_callable(fn)) return js_throw_type_error(ctx, "The \"callback\" argument must be of type function");
+    JSJob job = { JS_JOB_CALLBACK, NULL, fn, JS_UNDEFINED, JS_UNDEFINED };
+    js_enqueue_microtask(ctx, &job);
+    return JS_UNDEFINED;
+}
+
+void js_jobs_realm_init(JSContext *ctx, JSObject *global) {
+    (void)js_define_method(ctx, global, "queueMicrotask", queue_microtask, 1);
+    (void)js_define_method(ctx, global, "setTimeout", set_timeout, 2);
+    (void)js_define_method(ctx, global, "setInterval", set_interval, 2);
+    (void)js_define_method(ctx, global, "clearTimeout", clear_timeout, 1);
+    (void)js_define_method(ctx, global, "clearInterval", clear_timeout, 1);
+    (void)js_define_method(ctx, global, "setImmediate", set_immediate, 1);
+    (void)js_define_method(ctx, global, "clearImmediate", clear_timeout, 1);
+    JSTimers *t = &ctx->rt->timers;
+    if (!t->now) t->now = js_os_now_ms();  /* the base of every timer the main script sets */
+}
+
+/* One task per iteration, then a full checkpoint: promise callbacks always run before the
+ * next timer. The program ends when no timer is pending (unref'd ones don't count) and no I/O is. */
+int js_run_event_loop(JSContext *ctx, JSValue main_result) {
+    if (js_is_exception(main_result)) return js_report_uncaught(ctx);
+    if (js_run_microtasks(ctx) < 0) return 1;
+    JSRuntime *rt = ctx->rt;
+    JSTimers *t = &rt->timers;
+    while (t->refed || (rt->io && rt->io->alive(rt))) {
+        /* FinalizationRegistry cleanups run between tasks; on their own they don't keep the program alive */
+        if (js_run_finalization_cleanups(ctx) < 0) return 1;
+        if (!t->count || t->heap[0].deadline > t->now) {  /* nothing due at the cached time: refresh it, or wait */
+            t->now = js_os_now_ms();
+            if (!t->count || t->heap[0].deadline > t->now) {
+                int64_t timeout = t->count ? (int64_t)(t->heap[0].deadline - t->now) : -1;
+                /* the output so far appears before the wait, as Node's does (a server's log, say) */
+                fflush(stdout);
+                fflush(stderr);
+                if (rt->io && rt->io->alive(rt)) {  /* I/O callbacks run while waiting */
+                    int status = rt->io->run(ctx, timeout);
+                    if (status) return status;
+                } else {
+                    js_os_sleep_ms(t->heap[0].deadline - t->now);  /* t->refed: a timer is pending */
+                }
+                t->now = js_os_now_ms();
+            }
+            continue;
+        }
+        JSTimer timer = t->heap[0];  /* on the C stack: the conservative scan keeps it alive */
+        timer_remove(t, 0);
+        t->running = timer.repeat ? timer.id : 0;
+        t->running_cleared = 0;
+        JSValue r = js_is_undefined(timer.args) ? js_call(timer.realm, timer.fn, JS_UNDEFINED, 0, NULL)
+                                                : js_call_spread(timer.realm, timer.fn, JS_UNDEFINED, timer.args, NULL);
+        t->running = 0;
+        if (js_is_exception(r)) return js_report_uncaught(timer.realm);
+        if (timer.repeat && !t->running_cleared) {  /* re-armed after its callback, from the loop's time */
+            timer.deadline = t->now + timer.repeat;
+            timer.seq = t->seq++;
+            timer_push(t, &timer);
+        }
+        if (js_run_microtasks(ctx) < 0) return 1;
+    }
+    return 0;
+}

package/runtime/src/jsnum.c

@@ -0,0 +1,353 @@
+/* Number <-> string conversion (ADR 0013). */
+#include "jsnum.h"
+
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "dtoa.h"
+
+/* QuickJS's integer formatters return the length without NUL-terminating. */
+size_t js_i32_to_cstr(char *buf, int32_t i) {
+    size_t n = i32toa(buf, i);
+    buf[n] = '\0';
+    return n;
+}
+
+static bool fits_int32(double d) {
+    return d >= -2147483648.0 && d <= 2147483647.0 && (double)(int32_t)d == d;
+}
+
+static size_t dtoa(char *buf, double d, int radix, int n_digits, int flags) {
+    JSDTOATempMem tmp;  /* 296 bytes, no malloc */
+    return (size_t)js_dtoa(buf, d, radix, n_digits, flags, &tmp);
+}
+
+size_t js_num_to_cstr(char *buf, double d) {
+    if (fits_int32(d)) return js_i32_to_cstr(buf, (int32_t)d);  /* also -0 → "0" */
+    return dtoa(buf, d, 10, 0, JS_DTOA_FORMAT_FREE);
+}
+
+/* Binary exponent of d as significand * 2^e with a 53-bit significand
+ * (V8's Double::Exponent). Positive means d >= 2^53. */
+static int binary_exponent(double d) {
+    uint64_t b;
+    memcpy(&b, &d, 8);
+    int biased = (int)((b >> 52) & 0x7FF);
+    return biased == 0 ? -1074 : biased - 1075;
+}
+
+static double next_double_up(double d) {
+    return nextafter(d, INFINITY);
+}
+
+/* Radix other than 10, with V8's algorithm so the output matches Node
+ * byte for byte (ADR 0013): fraction digits until they are within half an
+ * ulp, and integer digits beyond 2^53 filled with zeros. */
+static size_t radix_to_cstr(char *out, double value, int radix) {
+    static const char chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+    char buffer[2200];
+    const int mid = (int)sizeof buffer / 2;
+    int integer_cursor = mid, fraction_cursor = mid;
+
+    bool negative = value < 0;
+    if (negative) value = -value;
+
+    double integer = floor(value);
+    double fraction = value - integer;
+    double delta = 0.5 * (next_double_up(value) - value);
+    if (delta < next_double_up(0.0)) delta = next_double_up(0.0);
+
+    if (fraction >= delta) {
+        buffer[fraction_cursor++] = '.';
+        do {
+            fraction *= radix;
+            delta *= radix;
+            int digit = (int)fraction;
+            buffer[fraction_cursor++] = chars[digit];
+            fraction -= digit;
+            /* Round half to even; carry back through written digits. */
+            if (fraction > 0.5 || (fraction == 0.5 && (digit & 1))) {
+                if (fraction + delta > 1) {
+                    for (;;) {
+                        fraction_cursor--;
+                        if (fraction_cursor == mid) {  /* reached the '.' */
+                            integer += 1;
+                            break;
+                        }
+                        char c = buffer[fraction_cursor];
+                        int prev = c > '9' ? c - 'a' + 10 : c - '0';
+                        if (prev + 1 < radix) {
+                            buffer[fraction_cursor++] = chars[prev + 1];
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+        } while (fraction >= delta);
+    }
+
+    /* Digits below the double's precision are zeros. */
+    while (binary_exponent(integer / radix) > 0) {
+        integer /= radix;
+        buffer[--integer_cursor] = '0';
+    }
+    do {
+        double remainder = fmod(integer, radix);
+        buffer[--integer_cursor] = chars[(int)remainder];
+        integer = (integer - remainder) / radix;
+    } while (integer > 0);
+
+    if (negative) buffer[--integer_cursor] = '-';
+    size_t n = (size_t)(fraction_cursor - integer_cursor);
+    memcpy(out, buffer + integer_cursor, n);
+    out[n] = '\0';
+    return n;
+}
+
+size_t js_num_to_cstr_radix(char *buf, double d, int radix) {
+    if (radix == 10 || !isfinite(d)) return js_num_to_cstr(buf, d);
+    if (fits_int32(d)) {
+        size_t n = i64toa_radix(buf, (int32_t)d, (unsigned)radix);
+        buf[n] = '\0';
+        return n;
+    }
+    return radix_to_cstr(buf, d, radix);
+}
+
+size_t js_num_to_fixed(char *buf, double d, int digits) {
+    if (!(fabs(d) < 1e21)) return js_num_to_cstr(buf, d);  /* also NaN */
+    return dtoa(buf, d, 10, digits, JS_DTOA_FORMAT_FRAC);
+}
+
+size_t js_num_to_precision(char *buf, double d, int digits) {
+    if (!isfinite(d)) return js_num_to_cstr(buf, d);
+    return dtoa(buf, d, 10, digits, JS_DTOA_FORMAT_FIXED);
+}
+
+size_t js_num_to_exponential(char *buf, double d, int digits) {
+    if (!isfinite(d)) return js_num_to_cstr(buf, d);
+    if (digits < 0) return dtoa(buf, d, 10, 0, JS_DTOA_FORMAT_FREE | JS_DTOA_EXP_ENABLED);
+    return dtoa(buf, d, 10, digits + 1, JS_DTOA_FORMAT_FIXED | JS_DTOA_EXP_ENABLED);
+}
+
+/* ---- StringToNumber ---- */
+
+/* StrWhiteSpaceChar: WhiteSpace and LineTerminator. */
+static bool is_str_whitespace(uint32_t c) {
+    switch (c) {
+    case 0x09: case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x20:
+    case 0xA0: case 0x1680: case 0x2028: case 0x2029: case 0x202F:
+    case 0x205F: case 0x3000: case 0xFEFF:
+        return true;
+    default:
+        return c >= 0x2000 && c <= 0x200A;
+    }
+}
+
+static int digit_value(char c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'z') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
+    return 99;
+}
+
+static bool is_decimal(char c) { return c >= '0' && c <= '9'; }
+
+/* `p` is ASCII, NUL-terminated, non-empty and has no surrounding whitespace. */
+static double ascii_to_num(const char *p, size_t n) {
+    JSATODTempMem tmp;
+
+    /* NonDecimalIntegerLiteral: unsigned only. */
+    if (n > 2 && p[0] == '0') {
+        int radix = 0;
+        switch (p[1]) {
+        case 'x': case 'X': radix = 16; break;
+        case 'o': case 'O': radix = 8; break;
+        case 'b': case 'B': radix = 2; break;
+        }
+        if (radix) {
+            for (size_t i = 2; i < n; i++)
+                if (digit_value(p[i]) >= radix) return NAN;
+            return js_atod(p + 2, NULL, radix, JS_ATOD_INT_ONLY, &tmp);
+        }
+    }
+
+    /* StrDecimalLiteral: [+-] (Infinity | digits [. digits] [e [+-] digits] | . digits [e ...]) */
+    size_t i = 0;
+    bool neg = false;
+    if (p[0] == '+' || p[0] == '-') {
+        neg = p[0] == '-';
+        i = 1;
+    }
+    if (n - i == 8 && memcmp(p + i, "Infinity", 8) == 0) return neg ? -INFINITY : INFINITY;
+
+    size_t mantissa_digits = 0;
+    while (i < n && is_decimal(p[i])) i++, mantissa_digits++;
+    if (i < n && p[i] == '.') {
+        i++;
+        while (i < n && is_decimal(p[i])) i++, mantissa_digits++;
+    }
+    if (mantissa_digits == 0) return NAN;
+    if (i < n && (p[i] == 'e' || p[i] == 'E')) {
+        i++;
+        if (i < n && (p[i] == '+' || p[i] == '-')) i++;
+        if (i == n || !is_decimal(p[i])) return NAN;
+        while (i < n && is_decimal(p[i])) i++;
+    }
+    if (i != n) return NAN;
+    return js_atod(p, NULL, 10, 0, &tmp);
+}
+
+double js_str_to_num(JSStrView s) {
+    uint32_t start = 0, end = s.length;
+    while (start < end && is_str_whitespace(js_view_at(s, start))) start++;
+    while (end > start && is_str_whitespace(js_view_at(s, end - 1))) end--;
+    if (start == end) return 0.0;
+
+    size_t n = end - start;
+    char small[64];
+    char *buf = n < sizeof small ? small : malloc(n + 1);
+    if (!buf) abort();  /* out of memory; the heap's OOM policy isn't defined yet */
+
+    double result = NAN;
+    for (size_t i = 0; i < n; i++) {
+        uint32_t c = js_view_at(s, start + (uint32_t)i);
+        if (c > 0x7F) goto done;  /* non-ASCII inside the literal */
+        buf[i] = (char)c;
+    }
+    buf[n] = '\0';
+    result = ascii_to_num(buf, n);
+done:
+    if (buf != small) free(buf);
+    return result;
+}
+
+size_t js_num_to_locale(char *buf, double d) {
+    if (isnan(d)) return (size_t)sprintf(buf, "NaN");
+    size_t n = 0;
+    if (signbit(d)) buf[n++] = '-';  /* also -0, as ICU */
+    if (isinf(d)) return n + (size_t)sprintf(buf + n, "\xe2\x88\x9e");
+    /* the shortest decimal, positional, rounded half-up to three fraction digits (ICU rounds
+     * the shortest decimal, not the binary value: 1.0005 is "1.001") */
+    char digits[400];
+    size_t len = dtoa(digits, fabs(d), 10, 0, JS_DTOA_FORMAT_FREE | JS_DTOA_EXP_DISABLED);
+    digits[len] = '\0';
+    char *dot = strchr(digits, '.');
+    size_t int_len = dot ? (size_t)(dot - digits) : len;
+    char frac[4] = { 0 };
+    size_t frac_len = 0;
+    if (dot) {
+        const char *f = dot + 1;
+        for (; frac_len < 3 && f[frac_len]; frac_len++) frac[frac_len] = f[frac_len];
+        if (f[frac_len] >= '5' && f[frac_len] <= '9') {  /* round up, carrying into the integer part */
+            size_t i = frac_len;
+            while (i > 0 && frac[i - 1] == '9') frac[--i] = '0';
+            if (i > 0) frac[i - 1]++;
+            else {
+                size_t j = int_len;
+                while (j > 0 && digits[j - 1] == '9') digits[--j] = '0';
+                if (j > 0) digits[j - 1]++;
+                else {
+                    memmove(digits + 1, digits, int_len);
+                    digits[0] = '1';
+                    int_len++;
+                }
+            }
+        }
+        while (frac_len > 0 && frac[frac_len - 1] == '0') frac_len--;
+    }
+    for (size_t i = 0; i < int_len; i++) {
+        if (i > 0 && (int_len - i) % 3 == 0) buf[n++] = ',';
+        buf[n++] = digits[i];
+    }
+    if (frac_len) {
+        buf[n++] = '.';
+        memcpy(buf + n, frac, frac_len);
+        n += frac_len;
+    }
+    buf[n] = '\0';
+    return n;
+}
+
+/* ---- parseFloat / parseInt: the scanner in prefix mode ----------------- */
+
+static uint32_t skip_whitespace(JSStrView s) {
+    uint32_t i = 0;
+    while (i < s.length && is_str_whitespace(js_view_at(s, i))) i++;
+    return i;
+}
+
+static int unit_digit(JSStrView s, uint32_t i) {
+    uint32_t c = js_view_at(s, i);
+    return c < 0x80 ? digit_value((char)c) : 99;
+}
+
+/* Correctly rounded value of the ASCII units [start, end) of s in `radix`. */
+static double atod_range(JSStrView s, uint32_t start, uint32_t end, int radix, int flags) {
+    size_t n = end - start;
+    char small[64];
+    char *buf = n < sizeof small ? small : malloc(n + 1);
+    if (!buf) abort();
+    for (size_t i = 0; i < n; i++) buf[i] = (char)js_view_at(s, start + (uint32_t)i);
+    buf[n] = '\0';
+    JSATODTempMem tmp;
+    double d = js_atod(buf, NULL, radix, flags, &tmp);
+    if (buf != small) free(buf);
+    return d;
+}
+
+static bool unit_is(JSStrView s, uint32_t i, char c) { return i < s.length && js_view_at(s, i) == (uint32_t)c; }
+
+double js_parse_float(JSStrView s) {
+    uint32_t i = skip_whitespace(s), start = i;
+    bool neg = false;
+    if (unit_is(s, i, '+') || unit_is(s, i, '-')) neg = js_view_at(s, i++) == '-';
+    static const char inf[] = "Infinity";
+    uint32_t k = 0;
+    while (k < 8 && unit_is(s, i + k, inf[k])) k++;
+    if (k == 8) return neg ? -INFINITY : INFINITY;
+
+    uint32_t digits = 0;
+    while (i < s.length && unit_digit(s, i) < 10) i++, digits++;
+    if (unit_is(s, i, '.')) {
+        uint32_t dot = i++;
+        while (i < s.length && unit_digit(s, i) < 10) i++, digits++;
+        if (!digits) i = dot;
+    }
+    if (!digits) return NAN;
+    if (unit_is(s, i, 'e') || unit_is(s, i, 'E')) {  /* only if a digit follows */
+        uint32_t j = i + 1;
+        if (unit_is(s, j, '+') || unit_is(s, j, '-')) j++;
+        if (j < s.length && unit_digit(s, j) < 10) {
+            while (j < s.length && unit_digit(s, j) < 10) j++;
+            i = j;
+        }
+    }
+    return atod_range(s, start, i, 10, 0);
+}
+
+double js_parse_int(JSStrView s, int32_t radix) {
+    uint32_t i = skip_whitespace(s);
+    bool neg = false;
+    if (unit_is(s, i, '+') || unit_is(s, i, '-')) neg = js_view_at(s, i++) == '-';
+    bool strip_prefix = true;
+    if (radix != 0) {
+        if (radix < 2 || radix > 36) return NAN;
+        if (radix != 16) strip_prefix = false;
+    } else {
+        radix = 10;
+    }
+    if (strip_prefix && unit_is(s, i, '0') && (unit_is(s, i + 1, 'x') || unit_is(s, i + 1, 'X'))) {
+        i += 2;
+        radix = 16;
+    }
+    uint32_t start = i;
+    while (i < s.length && unit_digit(s, i) < radix) i++;
+    if (i == start) return NAN;
+    double d = atod_range(s, start, i, radix, JS_ATOD_INT_ONLY);
+    return neg ? -d : d;  /* "-0" is -0 */
+}