jseption 0.0.0-stage → 0.0.2

package/dist/builtins/json.js

@@ -0,0 +1,984 @@
+/*
+ * JSON object (port of the JSON part of quickjs.c: json_next_token,
+ * json_parse_value, JS_ParseJSON, internalize_json_property,
+ * js_json_check, js_json_to_str, JS_JSONStringify)
+ */
+import * as Q from "../quickjs.js";
+import { JS_EXCEPTION, JS_IsException, JS_IsUndefined, JS_IsObject, JS_IsFunction, JS_IsArray, JS_NewObject, JS_NewArray, JS_NewErrorNative, JS_Throw, JS_ThrowTypeError, JS_ThrowStackOverflow, JS_DefinePropertyValue, JS_DefinePropertyValueUint32, JS_GetProperty, JS_GetPropertyInt64, JS_GetPropertyValue, JS_DeleteProperty, JS_GetOwnPropertyNamesInternal, JS_PROP_C_W_E, JS_PROP_WRITABLE, JS_PROP_CONFIGURABLE, JS_GPN_STRING_MASK, JS_GPN_ENUM_ONLY, JS_ATOM_NULL, JS_ATOM_empty_string, JS_ATOM_toJSON, JS_ATOM_fileName, JS_ATOM_lineNumber, JS_ATOM_columnNumber, JS_ATOM_Symbol_toStringTag, JS_ATOM_true, JS_ATOM_false, JS_ATOM_null, JS_ValueToAtom, JS_NewAtomUInt32, JS_AtomToValue, JS_Call, JS_ToString, JS_ToNumber, JS_ToInt32Clamp, JS_ToQuotedString, js_get_length64, build_backtrace, JS_SetPropertyFunctionList, JS_CFUNC_DEF, JS_PROP_STRING_DEF, JS_OBJECT_DEF, JS_NewAtom, } from "../quickjs.js";
+import { fix_deep_json } from "./native.js";
+/* ---------------------------------------------------------------------
+   JSON parser (port of json_next_token / json_parse_value)
+   --------------------------------------------------------------------- */
+export const JS_PARSE_JSON_EXT = 1 << 0; /* allow extended JSON (comments, trailing commas, ...) */
+class JSONParseState {
+    ctx;
+    buf;
+    buf_end;
+    buf_ptr = 0;
+    last_ptr = 0;
+    filename;
+    ext_json = false;
+    /* current token */
+    tok = -1 /* JSONTok.EOF */;
+    tok_ptr = 0; /* start position of the token */
+    tok_str = ''; /* TOK_STRING value */
+    tok_num = 0; /* TOK_NUMBER value */
+    tok_atom = JS_ATOM_NULL; /* TOK_IDENT atom */
+    constructor(ctx, buf, filename) {
+        this.ctx = ctx;
+        this.buf = buf;
+        this.buf_end = buf.length;
+        this.filename = filename;
+    }
+    /* character code at position p, 0 past the end (like the NUL terminated C buffer) */
+    at(p) {
+        return p < this.buf_end ? this.buf.charCodeAt(p) : 0;
+    }
+}
+const CP_LS = 0x2028;
+const CP_PS = 0x2029;
+function get_line_col(buf, pos) {
+    let line = 1, col = 1;
+    const n = Math.min(pos, buf.length);
+    for (let i = 0; i < n; i++) {
+        const c = buf.charCodeAt(i);
+        if (c === 10) {
+            line++;
+            col = 1;
+        }
+        else if (c === 13) {
+            if (buf.charCodeAt(i + 1) !== 10) {
+                line++;
+                col = 1;
+            }
+        }
+        else if (c === CP_LS || c === CP_PS) {
+            line++;
+            col = 1;
+        }
+        else
+            col++;
+    }
+    return [line, col];
+}
+/* port of js_parse_error_pos / js_parse_error_v: throw a SyntaxError
+   with the position of 'pos' in the input */
+function json_parse_error_pos(s, pos, msg) {
+    const ctx = s.ctx;
+    const [line, col] = get_line_col(s.buf, pos);
+    const obj = JS_NewErrorNative(ctx, 3 /* JSErrorEnum.SYNTAX_ERROR */, msg);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_fileName, s.filename, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_lineNumber, line, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_columnNumber, col, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    build_backtrace(ctx, obj, s.filename, line, col, 0);
+    JS_Throw(ctx, obj);
+    return -1;
+}
+function json_parse_error(s, msg) {
+    return json_parse_error_pos(s, s.tok_ptr, msg);
+}
+function is_digit(c) { return c >= 48 && c <= 57; }
+function from_hex(c) {
+    if (c >= 48 && c <= 57)
+        return c - 48;
+    if (c >= 65 && c <= 70)
+        return c - 55;
+    if (c >= 97 && c <= 102)
+        return c - 87;
+    return -1;
+}
+/* ASCII identifier start / continue (lre_is_id_start / lre_is_id_continue restricted to ASCII) */
+function is_ident_start_ascii(c) {
+    return (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c === 95 /* _ */ || c === 36 /* $ */;
+}
+function is_ident_continue_ascii(c) {
+    return is_ident_start_ascii(c) || is_digit(c);
+}
+/* port of lre_parse_escape(&p, TRUE): returns the code point, -1 if
+   malformed, -2 if unknown escape; pp.p is updated */
+function lre_parse_escape(s, pp) {
+    let p = pp.p;
+    let c = s.at(p++);
+    switch (c) {
+        case 98:
+            c = 8;
+            break; /* \b */
+        case 102:
+            c = 12;
+            break; /* \f */
+        case 110:
+            c = 10;
+            break; /* \n */
+        case 114:
+            c = 13;
+            break; /* \r */
+        case 116:
+            c = 9;
+            break; /* \t */
+        case 118:
+            c = 11;
+            break; /* \v */
+        case 120: /* x */
+        case 117: /* u */
+            {
+                if (s.at(p) === 123 /* { */) {
+                    p++;
+                    c = 0;
+                    for (;;) {
+                        const h = from_hex(s.at(p++));
+                        if (h < 0)
+                            return -1;
+                        c = (c << 4) | h;
+                        if (c > 0x10ffff)
+                            return -1;
+                        if (s.at(p) === 125 /* } */)
+                            break;
+                    }
+                    p++;
+                }
+                else {
+                    const n = (c === 120) ? 2 : 4;
+                    c = 0;
+                    for (let i = 0; i < n; i++) {
+                        const h = from_hex(s.at(p++));
+                        if (h < 0)
+                            return -1;
+                        c = (c << 4) | h;
+                    }
+                }
+            }
+            break;
+        default:
+            return -2;
+    }
+    pp.p = p;
+    return c;
+}
+/* port of js_parse_string() in JSON mode (s->cur_func == NULL) */
+function json_parse_string(s, sep, p) {
+    let out = '';
+    for (;;) {
+        if (p >= s.buf_end)
+            return json_parse_error(s, 'unexpected end of string');
+        let c = s.at(p);
+        if (c < 0x20) {
+            return json_parse_error_pos(s, p, 'invalid character in a JSON string');
+        }
+        p++;
+        if (c === sep)
+            break;
+        if (c === 92 /* \ */) {
+            const p_escape = p - 1;
+            c = s.at(p);
+            switch (c) {
+                case 0:
+                    if (p >= s.buf_end)
+                        return json_parse_error(s, 'unexpected end of string');
+                    p++;
+                    break;
+                case 39: /* ' */
+                case 34: /* " */
+                case 92: /* \ */
+                    p++;
+                    break;
+                case 13: /* \r: accept DOS and MAC newline sequences */
+                    if (s.at(p + 1) === 10)
+                        p++;
+                /* fall through */
+                case 10:
+                    /* ignore escaped newline sequence */
+                    p++;
+                    continue;
+                default:
+                    if (c >= 48 && c <= 57) {
+                        /* JSON case: no octal escapes */
+                        return json_parse_error_pos(s, p_escape, 'malformed escape sequence in string literal');
+                    }
+                    else if (c >= 0x80) {
+                        p++;
+                        /* LS or PS are skipped */
+                        if (c === CP_LS || c === CP_PS)
+                            continue;
+                    }
+                    else {
+                        const pp = { p };
+                        const ret = lre_parse_escape(s, pp);
+                        if (ret === -1) {
+                            return json_parse_error_pos(s, p_escape, 'malformed escape sequence in string literal');
+                        }
+                        else if (ret < 0) {
+                            /* ignore the '\' (could output a warning) */
+                            p++;
+                        }
+                        else {
+                            p = pp.p;
+                            c = ret;
+                        }
+                    }
+                    break;
+            }
+        }
+        out += (c > 0xffff) ? String.fromCodePoint(c) : String.fromCharCode(c);
+    }
+    s.tok = -2 /* JSONTok.STRING */;
+    s.tok_str = out;
+    s.buf_ptr = p;
+    return 0;
+}
+/* port of json_parse_ident: only pure ascii identifiers are accepted */
+function json_parse_ident(s, pp, c) {
+    let p = pp.p;
+    let ident = String.fromCharCode(c);
+    for (;;) {
+        c = s.at(p);
+        if (c >= 128 || !is_ident_continue_ascii(c))
+            break;
+        ident += String.fromCharCode(c);
+        p++;
+    }
+    pp.p = p;
+    return JS_NewAtom(s.ctx, ident);
+}
+/* port of js_atof() with radix 10 and no flags (JSON) or
+   ATOD_ACCEPT_BIN_OCT with radix 0 (extended JSON). Returns -1 on error. */
+function json_parse_number(s, p) {
+    const ext = s.ext_json;
+    let is_neg = false;
+    let radix = 10;
+    let p_start;
+    if (s.at(p) === 43 /* + */) {
+        p++;
+    }
+    else if (s.at(p) === 45 /* - */) {
+        p++;
+        is_neg = true;
+    }
+    if (ext && s.at(p) === 48 /* 0 */) {
+        const c1 = s.at(p + 1);
+        if (c1 === 120 || c1 === 88) {
+            p += 2;
+            radix = 16;
+        }
+        else if (c1 === 111 || c1 === 79) {
+            p += 2;
+            radix = 8;
+        }
+        else if (c1 === 98 || c1 === 66) {
+            p += 2;
+            radix = 2;
+        }
+        if (radix !== 10) {
+            /* there must be a digit after the prefix */
+            if (to_digit(s.at(p)) >= radix)
+                return json_parse_error_pos(s, p, 'invalid number literal');
+        }
+    }
+    let is_float = false;
+    p_start = p;
+    while (to_digit(s.at(p)) < radix)
+        p++;
+    if (s.at(p) === 46 /* . */ && (p > p_start || to_digit(s.at(p + 1)) < radix)) {
+        is_float = true;
+        p++;
+        while (to_digit(s.at(p)) < radix)
+            p++;
+    }
+    if (p > p_start) {
+        const c = s.at(p);
+        if (((c === 101 || c === 69) && radix === 10) ||
+            ((c === 112 || c === 80) && (radix === 2 || radix === 8 || radix === 16))) {
+            let p1 = p + 1;
+            is_float = true;
+            if (s.at(p1) === 43 || s.at(p1) === 45)
+                p1++;
+            if (is_digit(s.at(p1))) {
+                p = p1 + 1;
+                while (is_digit(s.at(p)))
+                    p++;
+            }
+        }
+    }
+    if (p === p_start)
+        return json_parse_error_pos(s, p, 'invalid number literal');
+    const text = s.buf.substring(p_start, p);
+    let d;
+    if (radix === 10) {
+        d = Number(text);
+    }
+    else if (is_float) {
+        return json_parse_error_pos(s, p_start, 'invalid number literal');
+    }
+    else {
+        d = parseInt(text, radix);
+    }
+    if (is_neg)
+        d = -d;
+    s.tok = -3 /* JSONTok.NUMBER */;
+    s.tok_num = d;
+    s.buf_ptr = p;
+    return 0;
+}
+function to_digit(c) {
+    if (c >= 48 && c <= 57)
+        return c - 48;
+    if (c >= 65 && c <= 90)
+        return c - 65 + 10;
+    if (c >= 97 && c <= 122)
+        return c - 97 + 10;
+    return 36;
+}
+function json_next_token(s) {
+    let p = s.last_ptr = s.buf_ptr;
+    for (;;) {
+        s.tok_ptr = p;
+        const c = s.at(p);
+        switch (c) {
+            case 0:
+                if (p >= s.buf_end) {
+                    s.tok = -1 /* JSONTok.EOF */;
+                    s.buf_ptr = p;
+                    return 0;
+                }
+                break; /* def_token */
+            case 39: /* ' */
+                if (!s.ext_json)
+                    break; /* JSON does not accept single quoted strings */
+            /* fall through */
+            case 34: /* " */
+                if (json_parse_string(s, c, p + 1)) {
+                    s.tok = -5 /* JSONTok.ERROR */;
+                    return -1;
+                }
+                return 0;
+            case 13: /* \r: accept DOS and MAC newline sequences */
+                if (s.at(p + 1) === 10)
+                    p++;
+            /* fall through */
+            case 10:
+                p++;
+                continue;
+            case 12: /* \f */
+            case 11: /* \v */
+                if (!s.ext_json)
+                    break; /* JSONWhitespace does not match <VT>, nor <FF> */
+            /* fall through */
+            case 32:
+            case 9:
+                p++;
+                continue;
+            case 47: /* / */
+                if (!s.ext_json)
+                    break; /* JSON does not accept comments */
+                if (s.at(p + 1) === 42 /* * */) {
+                    p += 2;
+                    for (;;) {
+                        if (p >= s.buf_end) {
+                            json_parse_error(s, 'unexpected end of comment');
+                            s.tok = -5 /* JSONTok.ERROR */;
+                            return -1;
+                        }
+                        if (s.at(p) === 42 && s.at(p + 1) === 47) {
+                            p += 2;
+                            break;
+                        }
+                        p++;
+                    }
+                    continue;
+                }
+                else if (s.at(p + 1) === 47) {
+                    p += 2;
+                    for (;;) {
+                        if (p >= s.buf_end)
+                            break;
+                        const c1 = s.at(p);
+                        if (c1 === 13 || c1 === 10 || c1 === CP_LS || c1 === CP_PS)
+                            break;
+                        p++;
+                    }
+                    continue;
+                }
+                break; /* def_token */
+            case 43: /* + */
+                if (!s.ext_json || !is_digit(s.at(p + 1)))
+                    break;
+                return json_parse_number(s, p);
+            case 48: /* 0 */
+                if (is_digit(s.at(p + 1)))
+                    break;
+                return json_parse_number(s, p);
+            case 45: /* - */
+                if (!is_digit(s.at(p + 1)))
+                    break;
+                return json_parse_number(s, p);
+            default:
+                if (is_digit(c))
+                    return json_parse_number(s, p);
+                if (is_ident_start_ascii(c)) {
+                    /* identifier: only pure ascii characters are accepted */
+                    const pp = { p: p + 1 };
+                    const atom = json_parse_ident(s, pp, c);
+                    if (atom === JS_ATOM_NULL) {
+                        s.tok = -5 /* JSONTok.ERROR */;
+                        return -1;
+                    }
+                    s.tok_atom = atom;
+                    s.tok = -4 /* JSONTok.IDENT */;
+                    s.buf_ptr = pp.p;
+                    return 0;
+                }
+                if (c >= 128) {
+                    json_parse_error(s, 'unexpected character');
+                    s.tok = -5 /* JSONTok.ERROR */;
+                    return -1;
+                }
+                break;
+        }
+        /* def_token */
+        s.tok = c;
+        p++;
+        s.buf_ptr = p;
+        return 0;
+    }
+}
+function json_parse_expect(s, tok) {
+    if (s.tok !== tok) {
+        /* XXX: dump token correctly in all cases */
+        return json_parse_error(s, `expecting '${String.fromCharCode(tok)}'`);
+    }
+    return json_next_token(s);
+}
+/* current token (through a function so that TypeScript does not narrow s.tok) */
+function cur_tok(s) { return s.tok; }
+function json_parse_value(s, depth) {
+    const ctx = s.ctx;
+    let val = null;
+    if (depth > ctx.rt.max_stack_depth)
+        return JS_ThrowStackOverflow(ctx);
+    const tok = s.tok;
+    switch (tok) {
+        case 123: /* { */
+            {
+                if (json_next_token(s))
+                    return JS_EXCEPTION;
+                val = JS_NewObject(ctx);
+                if (JS_IsException(val))
+                    return val;
+                if (cur_tok(s) !== 125 /* } */) {
+                    for (;;) {
+                        let prop_name;
+                        if (cur_tok(s) === -2 /* JSONTok.STRING */) {
+                            prop_name = JS_ValueToAtom(ctx, s.tok_str);
+                            if (prop_name === JS_ATOM_NULL)
+                                return JS_EXCEPTION;
+                        }
+                        else if (s.ext_json && cur_tok(s) === -4 /* JSONTok.IDENT */) {
+                            prop_name = s.tok_atom;
+                        }
+                        else {
+                            json_parse_error(s, 'expecting property name');
+                            return JS_EXCEPTION;
+                        }
+                        if (json_next_token(s))
+                            return JS_EXCEPTION;
+                        if (json_parse_expect(s, 58 /* : */))
+                            return JS_EXCEPTION;
+                        const prop_val = json_parse_value(s, depth + 1);
+                        if (JS_IsException(prop_val))
+                            return JS_EXCEPTION;
+                        const ret = JS_DefinePropertyValue(ctx, val, prop_name, prop_val, JS_PROP_C_W_E);
+                        if (ret < 0)
+                            return JS_EXCEPTION;
+                        if (cur_tok(s) !== 44 /* , */)
+                            break;
+                        if (json_next_token(s))
+                            return JS_EXCEPTION;
+                        if (s.ext_json && cur_tok(s) === 125)
+                            break;
+                    }
+                }
+                if (json_parse_expect(s, 125 /* } */))
+                    return JS_EXCEPTION;
+            }
+            break;
+        case 91: /* [ */
+            {
+                if (json_next_token(s))
+                    return JS_EXCEPTION;
+                val = JS_NewArray(ctx);
+                if (JS_IsException(val))
+                    return val;
+                if (cur_tok(s) !== 93 /* ] */) {
+                    let idx = 0;
+                    for (;;) {
+                        const el = json_parse_value(s, depth + 1);
+                        if (JS_IsException(el))
+                            return JS_EXCEPTION;
+                        const ret = JS_DefinePropertyValueUint32(ctx, val, idx, el, JS_PROP_C_W_E);
+                        if (ret < 0)
+                            return JS_EXCEPTION;
+                        if (cur_tok(s) !== 44 /* , */)
+                            break;
+                        if (json_next_token(s))
+                            return JS_EXCEPTION;
+                        idx++;
+                        if (s.ext_json && cur_tok(s) === 93)
+                            break;
+                    }
+                }
+                if (json_parse_expect(s, 93 /* ] */))
+                    return JS_EXCEPTION;
+            }
+            break;
+        case -2 /* JSONTok.STRING */:
+            val = s.tok_str;
+            if (json_next_token(s))
+                return JS_EXCEPTION;
+            break;
+        case -3 /* JSONTok.NUMBER */:
+            val = s.tok_num;
+            if (json_next_token(s))
+                return JS_EXCEPTION;
+            break;
+        case -4 /* JSONTok.IDENT */:
+            if (s.tok_atom === JS_ATOM_false || s.tok_atom === JS_ATOM_true) {
+                val = (s.tok_atom === JS_ATOM_true);
+            }
+            else if (s.tok_atom === JS_ATOM_null) {
+                val = null;
+            }
+            else {
+                return json_unexpected_token(s);
+            }
+            if (json_next_token(s))
+                return JS_EXCEPTION;
+            break;
+        default:
+            return json_unexpected_token(s);
+    }
+    return val;
+}
+function json_unexpected_token(s) {
+    if (s.tok === -1 /* JSONTok.EOF */) {
+        json_parse_error(s, 'Unexpected end of JSON input');
+    }
+    else {
+        json_parse_error(s, `unexpected token: '${s.buf.substring(s.tok_ptr, s.buf_ptr)}'`);
+    }
+    return JS_EXCEPTION;
+}
+export function JS_ParseJSON2(ctx, buf, filename, flags) {
+    const s = new JSONParseState(ctx, buf, filename);
+    s.ext_json = (flags & JS_PARSE_JSON_EXT) !== 0;
+    if (json_next_token(s))
+        return JS_EXCEPTION;
+    const val = json_parse_value(s, 0);
+    if (JS_IsException(val))
+        return val;
+    if (s.tok !== -1 /* JSONTok.EOF */) {
+        json_parse_error(s, 'unexpected data at the end');
+        return JS_EXCEPTION;
+    }
+    return val;
+}
+export function JS_ParseJSON(ctx, buf, filename) {
+    return JS_ParseJSON2(ctx, buf, filename, 0);
+}
+/* ---------------------------------------------------------------------
+   JSON.parse
+   --------------------------------------------------------------------- */
+function internalize_json_property(ctx, holder, name, reviver, depth) {
+    if (depth > ctx.rt.max_stack_depth)
+        return JS_ThrowStackOverflow(ctx);
+    const val = JS_GetProperty(ctx, holder, name);
+    if (JS_IsException(val))
+        return val;
+    if (JS_IsObject(val)) {
+        const is_array = JS_IsArray(ctx, val);
+        if (is_array < 0)
+            return JS_EXCEPTION;
+        let len;
+        let atoms = null;
+        if (is_array) {
+            len = js_get_length64(ctx, val);
+            if (len < 0)
+                return JS_EXCEPTION;
+        }
+        else {
+            atoms = JS_GetOwnPropertyNamesInternal(ctx, val, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK);
+            if (!atoms)
+                return JS_EXCEPTION;
+            len = atoms.length;
+        }
+        for (let i = 0; i < len; i++) {
+            let prop;
+            if (is_array) {
+                prop = JS_NewAtomUInt32(ctx, i);
+            }
+            else {
+                prop = atoms[i].atom;
+            }
+            const new_el = internalize_json_property(ctx, val, prop, reviver, depth + 1);
+            if (JS_IsException(new_el))
+                return JS_EXCEPTION;
+            let ret;
+            if (JS_IsUndefined(new_el)) {
+                ret = JS_DeleteProperty(ctx, val, prop, 0);
+            }
+            else {
+                ret = JS_DefinePropertyValue(ctx, val, prop, new_el, JS_PROP_C_W_E);
+            }
+            if (ret < 0)
+                return JS_EXCEPTION;
+        }
+    }
+    const name_val = JS_AtomToValue(ctx, name);
+    if (JS_IsException(name_val))
+        return JS_EXCEPTION;
+    return JS_Call(ctx, reviver, holder, [name_val, val]);
+}
+function js_json_parse(ctx, this_val, argv) {
+    const str = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(str))
+        return JS_EXCEPTION;
+    /* fast path: the host parser, with the tree re-prototyped to the guest
+       intrinsics. On a syntax error the ported parser runs to produce the
+       QuickJS error (message, line and column). */
+    let obj;
+    try {
+        obj = fix_deep_json(ctx, JSON.parse(str));
+    }
+    catch {
+        obj = JS_ParseJSON(ctx, str, '<input>');
+    }
+    if (JS_IsException(obj))
+        return obj;
+    if (argv.length > 1 && JS_IsFunction(ctx, argv[1])) {
+        const reviver = argv[1];
+        const root = JS_NewObject(ctx);
+        if (JS_IsException(root))
+            return JS_EXCEPTION;
+        if (JS_DefinePropertyValue(ctx, root, JS_ATOM_empty_string, obj, JS_PROP_C_W_E) < 0)
+            return JS_EXCEPTION;
+        obj = internalize_json_property(ctx, root, JS_ATOM_empty_string, reviver, 0);
+    }
+    return obj;
+}
+function js_json_check(ctx, jsc, holder, val, key) {
+    /* check for object.toJSON method */
+    /* ECMA specifies this is done only for Object and BigInt */
+    if (JS_IsObject(val) || typeof val === 'bigint') {
+        const f = JS_GetProperty(ctx, val, JS_ATOM_toJSON);
+        if (JS_IsException(f))
+            return JS_EXCEPTION;
+        if (JS_IsFunction(ctx, f)) {
+            val = JS_Call(ctx, f, val, [key]);
+            if (JS_IsException(val))
+                return JS_EXCEPTION;
+        }
+    }
+    if (!JS_IsUndefined(jsc.replacer_func)) {
+        val = JS_Call(ctx, jsc.replacer_func, holder, [key, val]);
+        if (JS_IsException(val))
+            return JS_EXCEPTION;
+    }
+    switch (typeof val) {
+        case 'object':
+            if (val === null)
+                return val;
+            if (Q.JS_IsObject(val)) {
+                if (JS_IsFunction(ctx, val))
+                    break;
+                return val;
+            }
+            if (JS_IsException(val))
+                return val;
+            break; /* symbol */
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            return val;
+        default:
+            break;
+    }
+    return undefined;
+}
+function js_json_to_str(ctx, jsc, holder, val, indent, depth) {
+    if (depth > ctx.rt.max_stack_depth) {
+        JS_ThrowStackOverflow(ctx);
+        return -1;
+    }
+    if (Q.JS_IsObject(val)) {
+        const p = val;
+        const cl = Q.JS_GetClassID(p);
+        if (cl === 5 /* JSClassID.STRING */) {
+            val = JS_ToString(ctx, val);
+            if (JS_IsException(val))
+                return -1;
+        }
+        else if (cl === 4 /* JSClassID.NUMBER */) {
+            val = JS_ToNumber(ctx, val);
+            if (JS_IsException(val))
+                return -1;
+        }
+        else if (cl === 6 /* JSClassID.BOOLEAN */ || cl === 33 /* JSClassID.BIG_INT */) {
+            /* This will throw the same error as for the primitive object */
+            val = Q.JS_GetAnyOpaque(p);
+        }
+        else {
+            if (jsc.stack.includes(p)) {
+                JS_ThrowTypeError(ctx, 'circular reference');
+                return -1;
+            }
+            const indent1 = indent + jsc.gap;
+            let sep, sep1;
+            if (jsc.gap !== '') {
+                sep = '\n' + indent1;
+                sep1 = ' ';
+            }
+            else {
+                sep = jsc.empty;
+                sep1 = jsc.empty;
+            }
+            jsc.stack.push(p);
+            const ret = JS_IsArray(ctx, val);
+            if (ret < 0)
+                return -1;
+            if (ret) {
+                const len = js_get_length64(ctx, val);
+                if (len < 0)
+                    return -1;
+                jsc.b.push('[');
+                for (let i = 0; i < len; i++) {
+                    if (i > 0)
+                        jsc.b.push(',');
+                    jsc.b.push(sep);
+                    let v = JS_GetPropertyInt64(ctx, val, i);
+                    if (JS_IsException(v))
+                        return -1;
+                    /* XXX: could do this string conversion only when needed */
+                    const prop = String(i);
+                    v = js_json_check(ctx, jsc, val, v, prop);
+                    if (JS_IsException(v))
+                        return -1;
+                    if (JS_IsUndefined(v))
+                        v = null;
+                    if (js_json_to_str(ctx, jsc, val, v, indent1, depth + 1))
+                        return -1;
+                }
+                if (len > 0 && jsc.gap !== '') {
+                    jsc.b.push('\n');
+                    jsc.b.push(indent);
+                }
+                jsc.b.push(']');
+            }
+            else {
+                let tab;
+                if (jsc.property_list !== null) {
+                    tab = jsc.property_list;
+                }
+                else {
+                    const keys = js_object_keys(ctx, val);
+                    if (!keys)
+                        return -1;
+                    tab = keys;
+                }
+                const len = tab.length;
+                jsc.b.push('{');
+                let has_content = false;
+                for (let i = 0; i < len; i++) {
+                    let prop = tab[i];
+                    let v = JS_GetPropertyValue(ctx, val, prop);
+                    if (JS_IsException(v))
+                        return -1;
+                    v = js_json_check(ctx, jsc, val, v, prop);
+                    if (JS_IsException(v))
+                        return -1;
+                    if (!JS_IsUndefined(v)) {
+                        if (has_content)
+                            jsc.b.push(',');
+                        prop = JS_ToQuotedString(ctx, prop);
+                        if (JS_IsException(prop))
+                            return -1;
+                        jsc.b.push(sep);
+                        jsc.b.push(prop);
+                        jsc.b.push(':');
+                        jsc.b.push(sep1);
+                        if (js_json_to_str(ctx, jsc, val, v, indent1, depth + 1))
+                            return -1;
+                        has_content = true;
+                    }
+                }
+                if (has_content && jsc.gap !== '') {
+                    jsc.b.push('\n');
+                    jsc.b.push(indent);
+                }
+                jsc.b.push('}');
+            }
+            jsc.stack.pop();
+            return 0;
+        }
+    }
+    /* concat_primitive */
+    switch (typeof val) {
+        case 'string': {
+            const q = JS_ToQuotedString(ctx, val);
+            if (JS_IsException(q))
+                return -1;
+            jsc.b.push(q);
+            return 0;
+        }
+        case 'number':
+            if (!Number.isFinite(val)) {
+                jsc.b.push('null');
+            }
+            else {
+                jsc.b.push(String(val));
+            }
+            return 0;
+        case 'boolean':
+            jsc.b.push(val ? 'true' : 'false');
+            return 0;
+        case 'object':
+            if (val === null) {
+                jsc.b.push('null');
+                return 0;
+            }
+            return 0;
+        case 'bigint':
+            /* reject big numbers: use toJSON method to override */
+            JS_ThrowTypeError(ctx, 'Do not know how to serialize a BigInt');
+            return -1;
+        default:
+            return 0;
+    }
+}
+/* own enumerable string keys of an object (js_object_keys with JS_ITERATOR_KIND_KEY) */
+function js_object_keys(ctx, obj) {
+    const tab = JS_GetOwnPropertyNamesInternal(ctx, obj, JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY);
+    if (!tab)
+        return null;
+    const res = [];
+    for (const e of tab) {
+        const v = JS_AtomToValue(ctx, e.atom);
+        if (JS_IsException(v))
+            return null;
+        res.push(v);
+    }
+    return res;
+}
+export function JS_JSONStringify(ctx, obj, replacer, space0) {
+    const jsc = {
+        replacer_func: undefined,
+        stack: [],
+        property_list: null,
+        gap: '',
+        empty: '',
+        b: [],
+    };
+    if (JS_IsFunction(ctx, replacer)) {
+        jsc.replacer_func = replacer;
+    }
+    else {
+        const res = JS_IsArray(ctx, replacer);
+        if (res < 0)
+            return JS_EXCEPTION;
+        if (res) {
+            /* XXX: enumeration is not fully correct */
+            jsc.property_list = [];
+            const n = js_get_length64(ctx, replacer);
+            if (n < 0)
+                return JS_EXCEPTION;
+            for (let i = 0; i < n; i++) {
+                let v = JS_GetPropertyInt64(ctx, replacer, i);
+                if (JS_IsException(v))
+                    return JS_EXCEPTION;
+                if (Q.JS_IsObject(v)) {
+                    if (Q.JS_GetClassID(v) === 5 /* JSClassID.STRING */ || Q.JS_GetClassID(v) === 4 /* JSClassID.NUMBER */) {
+                        v = JS_ToString(ctx, v);
+                        if (JS_IsException(v))
+                            return JS_EXCEPTION;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                else if (typeof v === 'number') {
+                    v = JS_ToString(ctx, v);
+                    if (JS_IsException(v))
+                        return JS_EXCEPTION;
+                }
+                else if (typeof v !== 'string') {
+                    continue;
+                }
+                if (!jsc.property_list.includes(v)) {
+                    jsc.property_list.push(v);
+                }
+            }
+        }
+    }
+    let space = space0;
+    if (Q.JS_IsObject(space)) {
+        if (Q.JS_GetClassID(space) === 4 /* JSClassID.NUMBER */) {
+            space = JS_ToNumber(ctx, space);
+        }
+        else if (Q.JS_GetClassID(space) === 5 /* JSClassID.STRING */) {
+            space = JS_ToString(ctx, space);
+        }
+        if (JS_IsException(space))
+            return JS_EXCEPTION;
+    }
+    if (typeof space === 'number') {
+        const n = JS_ToInt32Clamp(ctx, space, 0, 10, 0);
+        if (JS_IsException(n))
+            return JS_EXCEPTION;
+        jsc.gap = '          '.substring(0, n);
+    }
+    else if (typeof space === 'string') {
+        jsc.gap = space.substring(0, Math.min(space.length, 10));
+    }
+    else {
+        jsc.gap = jsc.empty;
+    }
+    const wrapper = JS_NewObject(ctx);
+    if (JS_IsException(wrapper))
+        return JS_EXCEPTION;
+    if (JS_DefinePropertyValue(ctx, wrapper, JS_ATOM_empty_string, obj, JS_PROP_C_W_E) < 0)
+        return JS_EXCEPTION;
+    let val = js_json_check(ctx, jsc, wrapper, obj, jsc.empty);
+    if (JS_IsException(val))
+        return JS_EXCEPTION;
+    if (JS_IsUndefined(val))
+        return undefined;
+    if (js_json_to_str(ctx, jsc, wrapper, val, jsc.empty, 0))
+        return JS_EXCEPTION;
+    return jsc.b.join('');
+}
+function js_json_stringify(ctx, this_val, argv) {
+    // stringify(val, replacer, space)
+    /* fast path: the host serializer (toJSON/replacer are guest functions,
+       called natively). A host TypeError (BigInt, cycle) is reported by the
+       ported serializer with the QuickJS message; guest exceptions thrown by
+       toJSON/replacer/getters propagate. */
+    try {
+        return JSON.stringify(argv[0], argv[1], argv[2]);
+    }
+    catch (e) {
+        if (!(e instanceof TypeError))
+            return Q.js_host_exception_to_guest(ctx, e);
+    }
+    return JS_JSONStringify(ctx, argv[0], argv[1], argv[2]);
+}
+const js_json_funcs = [
+    JS_CFUNC_DEF('parse', 2, js_json_parse),
+    JS_CFUNC_DEF('stringify', 3, js_json_stringify),
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'JSON', JS_PROP_CONFIGURABLE),
+];
+const js_json_obj = [
+    JS_OBJECT_DEF('JSON', js_json_funcs, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE),
+];
+export function JS_AddIntrinsicJSON(ctx) {
+    /* add JSON as autoinit object */
+    JS_SetPropertyFunctionList(ctx, ctx.global_obj, js_json_obj);
+}
+//# sourceMappingURL=json.js.map