jseption 0.0.5 → 0.0.7

package/dist/builtins/json.js

@@ -4,7 +4,7 @@
  * 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 { 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_DefinePropertyValueStr, 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, JS_ATOM_NaN, JS_ATOM_Infinity, JS_ThrowSyntaxError, JS_PROP_ENUMERABLE, js_same_value, __JS_AtomIsTaggedInt, __JS_AtomToUInt32, } from "../quickjs.js";
 import { fix_deep_json } from "./native.js";
 /* ---------------------------------------------------------------------
    JSON parser (port of json_next_token / json_parse_value)
@@ -94,131 +94,67 @@ function is_ident_start_ascii(c) {
 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) */
+/* port of json_parse_string: 'p' is the position after the opening quote */
 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++;
+            return json_parse_error(s, 'Unexpected end of JSON input');
+        let c = s.at(p++);
         if (c === sep)
             break;
+        if (c < 0x20)
+            return json_parse_error_pos(s, p - 1, 'Bad control character in string literal');
         if (c === 92 /* \ */) {
-            const p_escape = p - 1;
-            c = s.at(p);
+            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 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 92: /* \ */
-                    p++;
+                case 47: /* / */
                     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;
-                        }
+                case 117: /* u */
+                    c = 0;
+                    for (let i = 0; i < 4; i++) {
+                        const h = from_hex(s.at(p++));
+                        if (h < 0)
+                            return json_parse_error_pos(s, p - 1, 'Bad Unicode escape');
+                        c = (c << 4) | h;
                     }
                     break;
+                case 10: /* escaped newline: multi-line string */
+                    if (s.ext_json)
+                        continue;
+                    return json_parse_error_pos(s, p - 1, 'Bad escaped character');
+                case 118: /* v */
+                    if (s.ext_json) {
+                        c = 11;
+                        break;
+                    }
+                    return json_parse_error_pos(s, p - 1, 'Bad escaped character');
+                default:
+                    if (c === sep)
+                        break;
+                    if (p > s.buf_end)
+                        return json_parse_error(s, 'Unexpected end of JSON input');
+                    return json_parse_error_pos(s, p - 1, 'Bad escaped character');
             }
         }
-        out += (c > 0xffff) ? String.fromCodePoint(c) : String.fromCharCode(c);
+        /* the input is UTF-16: other characters (surrogates included) are copied as is */
+        out += String.fromCharCode(c);
     }
     s.tok = -2 /* JSONTok.STRING */;
     s.tok_str = out;
@@ -239,80 +175,94 @@ function json_parse_ident(s, pp, c) {
     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. */
+/* the message of js_parse_error_pos(s, p, "Unexpected token '%c'", *p): the
+   NUL past the end of the C buffer ends the formatted message */
+function json_unexpected_char(s, p) {
+    const c = s.at(p);
+    return json_parse_error_pos(s, p, c === 0 ? "Unexpected token '" : `Unexpected token '${String.fromCharCode(c)}'`);
+}
+/* the input starts with 'str' at position p */
+function json_strstart(s, p, str) {
+    return s.buf.startsWith(str, p);
+}
+/* port of json_parse_number: 'p' is the position of the first character */
 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 /* - */) {
+    const p_start = p;
+    let d;
+    if (s.at(p) === 43 /* + */ || 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;
+    done: {
+        if (!is_digit(s.at(p))) {
+            if (!s.ext_json)
+                return json_unexpected_char(s, p);
+            if (json_strstart(s, p, 'Infinity')) {
+                p += 8;
+                d = s.at(p_start) === 45 ? -Infinity : Infinity;
+                break done;
+            }
+            else if (json_strstart(s, p, 'NaN')) {
+                p += 3;
+                d = NaN;
+                break done;
+            }
+            else if (s.at(p) !== 46 /* . */) {
+                return json_unexpected_char(s, p);
+            }
         }
-        else if (c1 === 98 || c1 === 66) {
-            p += 2;
-            radix = 2;
+        if (s.at(p) === 48 /* 0 */) {
+            if (s.ext_json) {
+                /* also accepts base 16, 8 and 2 prefix for integers */
+                let radix = 10;
+                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) {
+                    /* prefix is present */
+                    if (to_digit(s.at(p)) >= radix)
+                        return json_unexpected_char(s, p);
+                    const p_digits = p;
+                    while (to_digit(s.at(p)) < radix)
+                        p++;
+                    /* parseInt is exact for the radixes 2, 8 and 16 */
+                    d = parseInt(s.buf.substring(p_digits, p), radix);
+                    if (s.at(p_start) === 45)
+                        d = -d;
+                    break done;
+                }
+            }
+            if (is_digit(s.at(p + 1)))
+                return json_parse_error_pos(s, p, 'Unexpected number');
         }
-        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');
+        while (is_digit(s.at(p)))
+            p++;
+        if (s.at(p) === 46 /* . */) {
+            p++;
+            if (!is_digit(s.at(p)))
+                return json_parse_error_pos(s, p, 'Unterminated fractional number');
+            while (is_digit(s.at(p)))
+                p++;
         }
-    }
-    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)
+        if (s.at(p) === 101 /* e */ || s.at(p) === 69 /* E */) {
             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 (s.at(p) === 43 || s.at(p) === 45)
+                p++;
+            if (!is_digit(s.at(p)))
+                return json_parse_error_pos(s, p, 'Exponent part is missing a number');
+            while (is_digit(s.at(p)))
+                p++;
         }
+        d = Number(s.buf.substring(p_start, 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;
@@ -399,16 +349,14 @@ function json_next_token(s) {
                 }
                 break; /* def_token */
             case 43: /* + */
-                if (!s.ext_json || !is_digit(s.at(p + 1)))
+                if (!s.ext_json)
                     break;
                 return json_parse_number(s, p);
-            case 48: /* 0 */
-                if (is_digit(s.at(p + 1)))
+            case 46: /* . */
+                if (!s.ext_json || !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))
@@ -449,7 +397,13 @@ function json_parse_expect(s, tok) {
 }
 /* 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) {
+function json_parse_record_init_primitive(s, pr, val) {
+    pr.value = val;
+    pr.source_pos = s.tok_ptr;
+    pr.source_len = s.buf_ptr - s.tok_ptr;
+}
+/* 'pr' can be null */
+function json_parse_value(s, depth, pr) {
     const ctx = s.ctx;
     let val = null;
     if (depth > ctx.rt.max_stack_depth)
@@ -463,6 +417,10 @@ function json_parse_value(s, depth) {
                 val = JS_NewObject(ctx);
                 if (JS_IsException(val))
                     return val;
+                if (pr) {
+                    pr.value = val;
+                    pr.entries = new Map();
+                }
                 if (cur_tok(s) !== 125 /* } */) {
                     for (;;) {
                         let prop_name;
@@ -482,7 +440,12 @@ function json_parse_value(s, depth) {
                             return JS_EXCEPTION;
                         if (json_parse_expect(s, 58 /* : */))
                             return JS_EXCEPTION;
-                        const prop_val = json_parse_value(s, depth + 1);
+                        let pr1 = null;
+                        if (pr) {
+                            pr1 = { value: undefined };
+                            pr.entries.set(prop_name, pr1);
+                        }
+                        const prop_val = json_parse_value(s, depth + 1, pr1);
                         if (JS_IsException(prop_val))
                             return JS_EXCEPTION;
                         const ret = JS_DefinePropertyValue(ctx, val, prop_name, prop_val, JS_PROP_C_W_E);
@@ -507,10 +470,19 @@ function json_parse_value(s, depth) {
                 val = JS_NewArray(ctx);
                 if (JS_IsException(val))
                     return val;
+                if (pr) {
+                    pr.value = val;
+                    pr.elements = [];
+                }
                 if (cur_tok(s) !== 93 /* ] */) {
                     let idx = 0;
                     for (;;) {
-                        const el = json_parse_value(s, depth + 1);
+                        let pr1 = null;
+                        if (pr) {
+                            pr1 = { value: undefined };
+                            pr.elements.push(pr1);
+                        }
+                        const el = json_parse_value(s, depth + 1, pr1);
                         if (JS_IsException(el))
                             return JS_EXCEPTION;
                         const ret = JS_DefinePropertyValueUint32(ctx, val, idx, el, JS_PROP_C_W_E);
@@ -531,20 +503,36 @@ function json_parse_value(s, depth) {
             break;
         case -2 /* JSONTok.STRING */:
             val = s.tok_str;
+            if (pr)
+                json_parse_record_init_primitive(s, pr, val);
             if (json_next_token(s))
                 return JS_EXCEPTION;
             break;
         case -3 /* JSONTok.NUMBER */:
             val = s.tok_num;
+            if (pr)
+                json_parse_record_init_primitive(s, pr, val);
             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);
+                if (pr)
+                    json_parse_record_init_primitive(s, pr, val);
             }
             else if (s.tok_atom === JS_ATOM_null) {
                 val = null;
+                if (pr)
+                    json_parse_record_init_primitive(s, pr, val);
+            }
+            else if (s.tok_atom === JS_ATOM_NaN && s.ext_json) {
+                /* Note: json5 identifier handling is ambiguous e.g. is
+                   '{ NaN: 1 }' a valid JSON5 production ? */
+                val = NaN;
+            }
+            else if (s.tok_atom === JS_ATOM_Infinity && s.ext_json) {
+                val = Infinity;
             }
             else {
                 return json_unexpected_token(s);
@@ -566,12 +554,13 @@ function json_unexpected_token(s) {
     }
     return JS_EXCEPTION;
 }
-export function JS_ParseJSON2(ctx, buf, filename, flags) {
+/* 'pr' (can be null) receives the parse record of the value */
+export function JS_ParseJSON3(ctx, buf, filename, flags, pr) {
     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);
+    const val = json_parse_value(s, 0, pr);
     if (JS_IsException(val))
         return val;
     if (s.tok !== -1 /* JSONTok.EOF */) {
@@ -580,18 +569,36 @@ export function JS_ParseJSON2(ctx, buf, filename, flags) {
     }
     return val;
 }
+export function JS_ParseJSON2(ctx, buf, filename, flags) {
+    return JS_ParseJSON3(ctx, buf, filename, flags, null);
+}
 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 pr !== null, then pr.value === holder by construction */
+function internalize_json_property(ctx, holder, name, reviver, text_str, pr, 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 (pr) {
+        if (pr.elements) {
+            pr = __JS_AtomIsTaggedInt(name) ? (pr.elements[__JS_AtomToUInt32(name)] ?? null) : null;
+        }
+        else {
+            pr = pr.entries?.get(name) ?? null;
+        }
+        /* the source text is only given for an unmodified value */
+        if (pr && !js_same_value(ctx, pr.value, val))
+            pr = null;
+    }
+    const context = JS_NewObject(ctx);
+    if (JS_IsException(context))
+        return JS_EXCEPTION;
     if (JS_IsObject(val)) {
         const is_array = JS_IsArray(ctx, val);
         if (is_array < 0)
@@ -617,7 +624,7 @@ function internalize_json_property(ctx, holder, name, reviver, depth) {
             else {
                 prop = atoms[i].atom;
             }
-            const new_el = internalize_json_property(ctx, val, prop, reviver, depth + 1);
+            const new_el = internalize_json_property(ctx, val, prop, reviver, text_str, pr, depth + 1);
             if (JS_IsException(new_el))
                 return JS_EXCEPTION;
             let ret;
@@ -631,36 +638,89 @@ function internalize_json_property(ctx, holder, name, reviver, depth) {
                 return JS_EXCEPTION;
         }
     }
+    else if (pr) {
+        const source = text_str.substring(pr.source_pos, pr.source_pos + pr.source_len);
+        if (JS_DefinePropertyValueStr(ctx, context, 'source', source, JS_PROP_C_W_E) < 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]);
+    return JS_Call(ctx, reviver, holder, [name_val, val, context]);
 }
 function js_json_parse(ctx, this_val, argv) {
     const str = JS_ToString(ctx, argv[0]);
     if (JS_IsException(str))
         return JS_EXCEPTION;
+    if (argv.length > 1 && JS_IsFunction(ctx, argv[1])) {
+        /* the ported parser, which keeps the parse records giving the reviver
+           the source text of the primitives (its third argument) */
+        const reviver = argv[1];
+        const root = JS_NewObject(ctx);
+        if (JS_IsException(root))
+            return JS_EXCEPTION;
+        const pr1 = { value: undefined };
+        const pr = { value: root, entries: new Map([[JS_ATOM_empty_string, pr1]]) };
+        const obj = JS_ParseJSON3(ctx, str, '<input>', 0, pr1);
+        if (JS_IsException(obj))
+            return obj;
+        if (JS_DefinePropertyValue(ctx, root, JS_ATOM_empty_string, obj, JS_PROP_C_W_E) < 0)
+            return JS_EXCEPTION;
+        return internalize_json_property(ctx, root, JS_ATOM_empty_string, reviver, str, pr, 0);
+    }
     /* 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));
+        return fix_deep_json(ctx, JSON.parse(str));
     }
     catch {
-        obj = JS_ParseJSON(ctx, str, '<input>');
+        return JS_ParseJSON(ctx, str, '<input>');
     }
+}
+/* JSON.rawJSON objects. The host's are used when it has them, so that the
+   host serializer of the JSON.stringify fast path emits their text;
+   otherwise they are null-prototype objects recorded here, and
+   JSON.stringify uses the ported serializer once one exists. */
+/* (exported so that a test can run without the host functions) */
+export const json_host_raw = {
+    rawJSON: JSON.rawJSON,
+    isRawJSON: JSON.isRawJSON,
+};
+const guest_raw_json = new WeakSet();
+let guest_raw_json_used = false;
+function js_is_raw_json(v) {
+    if (!Q.JS_IsObject(v))
+        return false;
+    if (json_host_raw.isRawJSON && json_host_raw.isRawJSON(v))
+        return true;
+    return guest_raw_json_used && guest_raw_json.has(v);
+}
+function js_json_isRawJSON(ctx, this_val, argv) {
+    return js_is_raw_json(argv[0]);
+}
+function is_valid_raw_json_char(c) {
+    return (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c === 45 /* - */ || c === 34 /* " */;
+}
+function js_json_rawJSON(ctx, this_val, argv) {
+    const str = JS_ToString(ctx, argv[0]);
+    if (JS_IsException(str))
+        return str;
+    const s = str;
+    if (s.length === 0 || !is_valid_raw_json_char(s.charCodeAt(0)) || !is_valid_raw_json_char(s.charCodeAt(s.length - 1)) ||
+        JS_IsException(js_json_parse(ctx, undefined, [s]))) {
+        return JS_ThrowSyntaxError(ctx, 'invalid rawJSON string');
+    }
+    if (json_host_raw.rawJSON)
+        return json_host_raw.rawJSON(s);
+    const obj = Q.JS_NewObjectProtoClass(ctx, null, 1 /* JSClassID.OBJECT */);
     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);
-    }
+    if (JS_DefinePropertyValueStr(ctx, obj, 'rawJSON', s, JS_PROP_ENUMERABLE) < 0)
+        return JS_EXCEPTION;
+    Q.JS_PreventExtensions(ctx, obj);
+    guest_raw_json.add(obj);
+    guest_raw_json_used = true;
     return obj;
 }
 function js_json_check(ctx, jsc, holder, val, key) {
@@ -721,10 +781,17 @@ function js_json_to_str(ctx, jsc, holder, val, indent, depth) {
             if (JS_IsException(val))
                 return -1;
         }
-        else if (cl === 6 /* JSClassID.BOOLEAN */ || cl === 33 /* JSClassID.BIG_INT */) {
+        else if (cl === 6 /* JSClassID.BOOLEAN */ || cl === 34 /* JSClassID.BIG_INT */) {
             /* This will throw the same error as for the primitive object */
             val = Q.JS_GetAnyOpaque(p);
         }
+        else if (js_is_raw_json(p)) {
+            const raw = Q.JS_GetPropertyStr(ctx, p, 'rawJSON');
+            if (JS_IsException(raw))
+                return -1;
+            jsc.b.push(String(raw));
+            return 0;
+        }
         else {
             if (jsc.stack.includes(p)) {
                 JS_ThrowTypeError(ctx, 'circular reference');
@@ -959,18 +1026,23 @@ function js_json_stringify(ctx, this_val, argv) {
     /* 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);
+       toJSON/replacer/getters propagate. The host serializer does not know
+       the guest's own JSON.rawJSON objects (made when the host has none). */
+    if (!guest_raw_json_used) {
+        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('isRawJSON', 1, js_json_isRawJSON),
     JS_CFUNC_DEF('parse', 2, js_json_parse),
+    JS_CFUNC_DEF('rawJSON', 1, js_json_rawJSON),
     JS_CFUNC_DEF('stringify', 3, js_json_stringify),
     JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'JSON', JS_PROP_CONFIGURABLE),
 ];