diff --git a/debug/js.c b/debug/js.c
index 32b94ef2..c8af212f 100644
--- a/debug/js.c
+++ b/debug/js.c
@@ -1,4 +1,5 @@
 #include "cell.h"
+#include "cJSON.h"
 
 JSC_CCALL(os_mem_limit, JS_SetMemoryLimit(JS_GetRuntime(js), js2number(js,argv[0])))
 JSC_CCALL(os_max_stacksize, JS_SetMaxStackSize(JS_GetRuntime(js), js2number(js,argv[0])))
@@ -13,7 +14,6 @@ JSC_CCALL(os_calc_mem,
   JS_SetPropertyStr(js,ret,"memory_used_size",number2js(js,mu.memory_used_size));
   JS_SetPropertyStr(js,ret,"malloc_count",number2js(js,mu.malloc_count));
   JS_SetPropertyStr(js,ret,"memory_used_count",number2js(js,mu.memory_used_count));
-  /* atom_count and atom_size removed - atoms are now just strings */
   JS_SetPropertyStr(js,ret,"str_count",number2js(js,mu.str_count));
   JS_SetPropertyStr(js,ret,"str_size",number2js(js,mu.str_size));
   JS_SetPropertyStr(js,ret,"obj_count",number2js(js,mu.obj_count));
@@ -35,47 +35,14 @@ JSC_CCALL(os_calc_mem,
   JS_SetPropertyStr(js,ret,"binary_object_size",number2js(js,mu.binary_object_size));
 )
 
-// Evaluate a string of JavaScript code in the current QuickJS context.
+// Evaluate a string via MACH VM
 JSC_SSCALL(os_eval,
   if (!str2) return JS_ThrowReferenceError(js, "Second argument should be the script.");
   if (!str) return JS_ThrowReferenceError(js, "First argument should be the name of the script.");
-  JSValue bytecode = JS_Compile(js, str2, strlen(str2), str);
-  if (JS_IsException(bytecode)) return bytecode;
-  ret = JS_Integrate(js, bytecode, JS_NULL);
-)
-
-// Compile a string of JavaScript code into a function object.
-JSC_SSCALL(js_compile,
-  if (!str2) return JS_ThrowReferenceError(js, "Second argument should be the script.");
-  if (!str) return JS_ThrowReferenceError(js, "First argument should be the name of the script.");
-  ret = JS_Compile(js, str2, strlen(str2), str);
-)
-
-// Link compiled bytecode with environment and execute.
-JSC_CCALL(js_integrate,
-  JSValue env = (argc > 1 && !JS_IsNull(argv[1])) ? argv[1] : JS_NULL;
-  ret = JS_Integrate(js, argv[0], env);
-)
-
-// Compile a function object into a bytecode blob.
-JSC_CCALL(js_compile_blob,
-  size_t size;
-  uint8_t *data = JS_WriteObject(js, &size, argv[0], JS_WRITE_OBJ_BYTECODE);
-  if (!data) {
-    return JS_ThrowInternalError(js, "Failed to serialize bytecode");
-  }
-  ret = js_new_blob_stoned_copy(js, data, size);
-  js_free(js, data);
-)
-
-// Compile a bytecode blob into a function object.
-JSC_CCALL(js_compile_unblob,
-  size_t size;
-  void *data = js_get_blob_data(js, &size, argv[0]);
-  if (data == -1) return JS_EXCEPTION;
-  if (!data) return JS_ThrowReferenceError(js, "No data present in blob.");
-  
-  return JS_ReadObject(js, data, size, JS_READ_OBJ_BYTECODE);
+  cJSON *ast = JS_ASTTree(str2, strlen(str2), str);
+  if (!ast) return JS_ThrowSyntaxError(js, "eval: failed to parse");
+  ret = JS_RunMachTree(js, ast, JS_NULL);
+  cJSON_Delete(ast);
 )
 
 // Disassemble a function object into a string.
@@ -93,10 +60,6 @@ static const JSCFunctionListEntry js_js_funcs[] = {
   MIST_FUNC_DEF(os, mem_limit, 1),
   MIST_FUNC_DEF(os, max_stacksize, 1),
   MIST_FUNC_DEF(os, eval, 2),
-  MIST_FUNC_DEF(js, compile, 2),
-  MIST_FUNC_DEF(js, integrate, 2),
-  MIST_FUNC_DEF(js, compile_blob, 1),
-  MIST_FUNC_DEF(js, compile_unblob, 1),
   MIST_FUNC_DEF(js, disassemble, 1),
   MIST_FUNC_DEF(js, fn_info, 1),
 };
@@ -105,4 +68,4 @@ JSValue js_js_use(JSContext *js) {
   JSValue mod = JS_NewObject(js);
   JS_SetPropertyFunctionList(js,mod,js_js_funcs,countof(js_js_funcs));
   return mod;
-}
\ No newline at end of file
+}
diff --git a/meson.build b/meson.build
index f515a62a..d2e9617f 100644
--- a/meson.build
+++ b/meson.build
@@ -45,7 +45,6 @@ src += [        # core
   'qjs_actor.c',
   'miniz.c',
   'runtime.c',
-  'cell_js.c',
   'tokenize.c',
   'parse.c',
   'mach.c',
diff --git a/source/cell.c b/source/cell.c
index 56367f2b..a2169087 100644
--- a/source/cell.c
+++ b/source/cell.c
@@ -288,113 +288,11 @@ static int run_test_suite(size_t heap_size)
 }
 
 /* Run an immediate script string */
-static int run_eval(const char *script_or_file, int print_bytecode, int use_bootstrap_env)
-{
-  if (!find_cell_shop()) return 1;
-
-  /* Check if argument is a file path */
-  struct stat st;
-  char *script = NULL;
-  char *allocated_script = NULL;
-  const char *filename = "<eval>";
-
-  if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
-    /* It's a file, read its contents */
-    FILE *f = fopen(script_or_file, "r");
-    if (!f) {
-      printf("Failed to open file: %s\n", script_or_file);
-      return 1;
-    }
-    allocated_script = malloc(st.st_size + 1);
-    if (!allocated_script) {
-      fclose(f);
-      printf("Failed to allocate memory for script\n");
-      return 1;
-    }
-    size_t read_size = fread(allocated_script, 1, st.st_size, f);
-    fclose(f);
-    allocated_script[read_size] = '\0';
-    script = allocated_script;
-    filename = script_or_file;
-  } else {
-    /* Treat as inline script */
-    script = (char *)script_or_file;
-  }
-
-  JSRuntime *rt = JS_NewRuntime();
-  if (!rt) {
-    printf("Failed to create JS runtime\n");
-    free(allocated_script);
-    return 1;
-  }
-
-  JSContext *ctx = JS_NewContext(rt);
-  if (!ctx) {
-    printf("Failed to create JS context\n");
-    JS_FreeRuntime(rt);
-    free(allocated_script);
-    return 1;
-  }
-
-  int result = 0;
-
-  JSGCRef bytecode_ref;
-  JS_PushGCRef(ctx, &bytecode_ref);
-  bytecode_ref.val = JS_Compile(ctx, script, strlen(script), filename);
-  if (JS_IsException(bytecode_ref.val)) {
-    uncaught_exception(ctx, bytecode_ref.val);
-    JS_PopGCRef(ctx, &bytecode_ref);
-    result = 1;
-  } else {
-    if (print_bytecode) {
-      printf("=== Compiled Bytecode ===\n");
-      JS_DumpFunctionBytecode(ctx, bytecode_ref.val);
-    }
-    JSValue env = JS_NULL;
-    if (use_bootstrap_env) {
-      JSGCRef env_ref, json_ref, nota_ref, wota_ref;
-      JS_PushGCRef(ctx, &env_ref);
-      JS_PushGCRef(ctx, &json_ref);
-      JS_PushGCRef(ctx, &nota_ref);
-      JS_PushGCRef(ctx, &wota_ref);
-      env_ref.val = JS_NewObject(ctx);
-      /* Create modules with GC rooting, then stone them */
-      json_ref.val = js_json_use(ctx);
-      nota_ref.val = js_nota_use(ctx);
-      wota_ref.val = js_wota_use(ctx);
-      JS_SetPropertyStr(ctx, env_ref.val, "json", JS_Stone(ctx, json_ref.val));
-      JS_SetPropertyStr(ctx, env_ref.val, "nota", JS_Stone(ctx, nota_ref.val));
-      JS_SetPropertyStr(ctx, env_ref.val, "wota", JS_Stone(ctx, wota_ref.val));
-      env = JS_Stone(ctx, env_ref.val);
-      JS_PopGCRef(ctx, &wota_ref);
-      JS_PopGCRef(ctx, &nota_ref);
-      JS_PopGCRef(ctx, &json_ref);
-      JS_PopGCRef(ctx, &env_ref);
-    }
-    JSValue v = JS_Integrate(ctx, bytecode_ref.val, env);
-    JS_PopGCRef(ctx, &bytecode_ref);
-    if (JS_IsException(v)) {
-      uncaught_exception(ctx, v);
-      result = 1;
-    } else {
-      JS_FreeValue(ctx, v);
-    }
-  }
-
-  JS_FreeContext(ctx);
-  JS_FreeRuntime(rt);
-  free(allocated_script);
-  return result;
-}
-
 static void print_usage(const char *prog)
 {
   printf("Usage: %s [options] <script> [args...]\n\n", prog);
   printf("Run a cell script (.ce actor or .cm module).\n\n");
   printf("Options:\n");
-  printf("  -e, --eval <code|file>     Evaluate code or run a file directly\n");
-  printf("  -p, --print-bytecode <code|file>  Compile and print bytecode\n");
-  printf("  -s, --serializers <code|file>     Run with json/nota/wota in env\n");
   printf("  --ast <code|file>          Output AST as JSON\n");
   printf("  --tokenize <code|file>     Output token array as JSON\n");
   printf("  --mcode <code|file>        Output MCODE IR as JSON\n");
@@ -633,24 +531,11 @@ int cell_init(int argc, char **argv)
 
     JSValue result = JS_CallMcodeTreeEnv(ctx, mcode, hidden_env);
 
+    int exit_code = 0;
     if (JS_IsException(result)) {
-      JSValue exc = JS_GetException(ctx);
-      const char *str = JS_ToCString(ctx, exc);
-      if (str) { printf("Error: %s\n", str); JS_FreeCString(ctx, str); }
-      cJSON *stack = JS_GetStack(ctx);
-      if (stack) {
-        int n = cJSON_GetArraySize(stack);
-        for (int i = 0; i < n; i++) {
-          cJSON *fr = cJSON_GetArrayItem(stack, i);
-          const char *fn = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "function"));
-          const char *file = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "file"));
-          int line = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "line"));
-          int col = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "column"));
-          printf("    at %s (%s:%d:%d)\n", fn ? fn : "<anonymous>", file ? file : "<unknown>", line, col);
-        }
-        cJSON_Delete(stack);
-      }
-      JS_FreeValue(ctx, exc);
+      /* Error already printed to stderr by JS_Throw* */
+      JS_GetException(ctx);
+      exit_code = 1;
     } else if (!JS_IsNull(result)) {
       const char *str = JS_ToCString(ctx, result);
       if (str) { printf("%s\n", str); JS_FreeCString(ctx, str); }
@@ -658,7 +543,7 @@ int cell_init(int argc, char **argv)
 
     JS_FreeContext(ctx);
     JS_FreeRuntime(rt);
-    return JS_IsException(result) ? 1 : 0;
+    return exit_code;
   }
 
   /* Check for --mach flag to dump MACH bytecode */
@@ -774,26 +659,8 @@ int cell_init(int argc, char **argv)
 
     int exit_code = 0;
     if (JS_IsException(result)) {
-      JSValue exc = JS_GetException(ctx);
-      const char *err_str = JS_ToCString(ctx, exc);
-      if (err_str) {
-        printf("Error: %s\n", err_str);
-        JS_FreeCString(ctx, err_str);
-      }
-      cJSON *stack = JS_GetStack(ctx);
-      if (stack) {
-        int n = cJSON_GetArraySize(stack);
-        for (int i = 0; i < n; i++) {
-          cJSON *fr = cJSON_GetArrayItem(stack, i);
-          const char *fn = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "function"));
-          const char *file = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "file"));
-          int line = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "line"));
-          int col = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "column"));
-          printf("    at %s (%s:%d:%d)\n", fn ? fn : "<anonymous>", file ? file : "<unknown>", line, col);
-        }
-        cJSON_Delete(stack);
-      }
-      JS_FreeValue(ctx, exc);
+      /* Error already printed to stderr by JS_Throw* */
+      JS_GetException(ctx);
       exit_code = 1;
     } else if (!JS_IsNull(result)) {
       const char *str = JS_ToCString(ctx, result);
@@ -808,19 +675,6 @@ int cell_init(int argc, char **argv)
     return exit_code;
   }
 
-  /* Check for -e or --eval flag to run immediate script */
-  /* Also check for -p flag to print bytecode */
-  /* -s / --serializers flag provides json, nota, wota in env */
-  if (argc >= 3 && (strcmp(argv[1], "-e") == 0 || strcmp(argv[1], "--eval") == 0)) {
-    return run_eval(argv[2], 0, 0);
-  }
-  if (argc >= 3 && (strcmp(argv[1], "-p") == 0 || strcmp(argv[1], "--print-bytecode") == 0)) {
-    return run_eval(argv[2], 1, 0);
-  }
-  if (argc >= 3 && (strcmp(argv[1], "-s") == 0 || strcmp(argv[1], "--serializers") == 0)) {
-    return run_eval(argv[2], 0, 1);
-  }
-
   int script_start = 1;
 
   /* Find the cell shop at ~/.cell */
@@ -894,31 +748,11 @@ void cell_trace_sethook(cell_hook)
 
 int uncaught_exception(JSContext *js, JSValue v)
 {
-  cell_rt *rt = JS_GetContextOpaque(js);
-  if (!JS_HasException(js)) {
-    JS_FreeValue(js,v);
+  (void)v;
+  if (!JS_HasException(js))
     return 1;
-  }
-
-  JSValue exp = JS_GetException(js);
-  
-  JSValue message = JS_GetPropertyStr(js, exp, "message");
-  const char *msg_str = JS_ToCString(js, message);
-  if (msg_str) {
-    printf("Exception: %s\n", msg_str);
-    JS_FreeCString(js, msg_str);
-  }
-  JS_FreeValue(js, message);
-  
-  JSValue stack = JS_GetPropertyStr(js, exp, "stack");
-  const char *stack_str = JS_ToCString(js, stack);
-  if (stack_str) {
-    printf("Stack:\n%s\n", stack_str);
-    JS_FreeCString(js, stack_str);
-  }
-  JS_FreeValue(js, stack);
-  
-  JS_FreeValue(js, exp);
-  JS_FreeValue(js, v);
+  /* Error message and backtrace were already printed to stderr
+     by JS_ThrowError2 / print_backtrace. Just clear the flag. */
+  JS_GetException(js);
   return 0;
 }
\ No newline at end of file
diff --git a/source/cell_js.c b/source/cell_js.c
deleted file mode 100644
index 5d3b6c9b..00000000
--- a/source/cell_js.c
+++ /dev/null
@@ -1,12740 +0,0 @@
-/*
- * QuickJS Javascript Engine
- *
- * Copyright (c) 2017-2025 Fabrice Bellard
- * Copyright (c) 2017-2025 Charlie Gordon
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-#include "quickjs-internal.h"
-
-/* argument of OP_special_object */
-typedef enum {
-  OP_SPECIAL_OBJECT_THIS_FUNC,
-  OP_SPECIAL_OBJECT_VAR_OBJECT,
-} OPSpecialObjectEnum;
-
-JSValue JS_CallInternal (JSContext *caller_ctx, JSValue func_obj, JSValue this_obj, int argc, JSValue *argv, int flags) {
-  JSContext *ctx = caller_ctx;
-  JSFunction *f;
-  JSFunctionBytecode *b;
-  JSStackFrame sf_s, *sf = &sf_s;
-  const uint8_t *pc;
-  int opcode, arg_allocated_size, i;
-  JSValue *stack_buf, *var_buf, *arg_buf, *sp, ret_val;
-  size_t alloca_size;
-
-#if !DIRECT_DISPATCH
-#define SWITCH(pc) switch (opcode = *pc++)
-#define CASE(op) case op
-#define DEFAULT default
-#define BREAK break
-#define SWITCH_OPCODE(new_op, target_label)          \
-  do {                                               \
-    const uint8_t *instr_ptr = pc - 1;               \
-    uint8_t *bc = (uint8_t *)b->byte_code_buf;       \
-    size_t instr_idx = instr_ptr - b->byte_code_buf; \
-    bc[instr_idx] = new_op;                          \
-    goto target_label;                               \
-  } while (0)
-#else
-  static const void *const dispatch_table[256] = {
-#define DEF(id, size, n_pop, n_push, f) &&case_OP_##id,
-#if SHORT_OPCODES
-#define def(id, size, n_pop, n_push, f)
-#else
-#define def(id, size, n_pop, n_push, f) &&case_default,
-#endif
-#include "quickjs-opcode.h"
-    [OP_COUNT... 255] = &&case_default
-  };
-#define SWITCH(pc) goto *dispatch_table[opcode = *pc++];
-#define CASE(op) case_##op
-#define DEFAULT case_default
-#define BREAK SWITCH (pc)
-#endif
-
-  if (js_poll_interrupts (caller_ctx)) return JS_EXCEPTION;
-  if (unlikely (!JS_IsFunction (func_obj))) {
-  not_a_function:
-    return JS_ThrowTypeError (caller_ctx, "not a function");
-  }
-  f = JS_VALUE_GET_FUNCTION (func_obj);
-  /* Strict arity enforcement: too many arguments throws (length < 0 means variadic) */
-  if (unlikely (f->length >= 0 && argc > f->length)) {
-    char buf[KEY_GET_STR_BUF_SIZE];
-    return JS_ThrowTypeError (
-      caller_ctx, "too many arguments for %s: expected %d, got %d", JS_KeyGetStr (caller_ctx, buf, KEY_GET_STR_BUF_SIZE, f->name), f->length, argc);
-  }
-  switch (f->kind) {
-  case JS_FUNC_KIND_C:
-    return js_call_c_function (caller_ctx, func_obj, this_obj, argc, (JSValue *)argv);
-  case JS_FUNC_KIND_BYTECODE:
-    break; /* continue to bytecode execution below */
-  case JS_FUNC_KIND_REGISTER:
-    return JS_CallRegisterVM(caller_ctx, f->u.reg.code, this_obj, argc, (JSValue *)argv,
-                             f->u.reg.env_record, f->u.reg.outer_frame);
-  case JS_FUNC_KIND_MCODE:
-    return mcode_exec(caller_ctx, f->u.mcode.code, this_obj, argc, (JSValue *)argv, f->u.mcode.outer_frame);
-  default:
-    goto not_a_function;
-  }
-  b = f->u.func.function_bytecode;
-
-  if (unlikely (caller_ctx->trace_hook)
-      && (caller_ctx->trace_type & JS_HOOK_CALL)) {
-    js_debug dbg;
-    js_debug_info (caller_ctx, func_obj, &dbg);
-    caller_ctx->trace_hook (caller_ctx, JS_HOOK_CALL, &dbg, caller_ctx->trace_data);
-  }
-
-  if (unlikely (argc < b->arg_count || (flags & JS_CALL_FLAG_COPY_ARGV))) {
-    arg_allocated_size = b->arg_count;
-  } else {
-    arg_allocated_size = 0;
-  }
-
-  alloca_size
-    = sizeof (JSValue) * (arg_allocated_size + b->var_count + b->stack_size);
-  if (js_check_stack_overflow (ctx, alloca_size))
-    return JS_ThrowStackOverflow (caller_ctx);
-
-  sf->js_mode = b->js_mode;
-  sf->arg_count = argc;
-  sf->cur_func = (JSValue)func_obj;
-
-  /* Allocate JSFrame for args + vars on regular heap (stable pointers).
-     This enables the outer_frame closure model. */
-  {
-    int frame_slot_count = b->arg_count + b->var_count;
-    size_t frame_size = sizeof(JSFrame) + frame_slot_count * sizeof(JSValue);
-    JSFrame *jf = pjs_mallocz(frame_size);
-    if (!jf)
-      return JS_ThrowOutOfMemory(caller_ctx);
-    jf->header = objhdr_make(frame_slot_count, OBJ_FRAME, false, false, false, false);
-    jf->function = JS_MKPTR(f);
-    jf->caller = JS_NULL;
-    jf->return_pc = 0;
-    sf->js_frame = JS_MKPTR(jf);
-
-    /* Point arg_buf and var_buf into JSFrame slots */
-    arg_buf = jf->slots;
-    var_buf = jf->slots + b->arg_count;
-    sf->arg_buf = arg_buf;
-    sf->var_buf = var_buf;
-
-    /* Copy arguments into frame */
-    int n = min_int(argc, b->arg_count);
-    for (i = 0; i < n; i++)
-      arg_buf[i] = argv[i];
-    for (; i < b->arg_count; i++)
-      arg_buf[i] = JS_NULL;
-    if (argc < b->arg_count)
-      sf->arg_count = b->arg_count;
-
-    /* Initialize local variables */
-    for (i = 0; i < b->var_count; i++)
-      var_buf[i] = JS_NULL;
-  }
-
-  /* Stack is still on C stack (transient) */
-  stack_buf = alloca(sizeof(JSValue) * b->stack_size);
-  sp = stack_buf;
-  pc = b->byte_code_buf;
-  sf->stack_buf = stack_buf;
-  sf->p_sp = &sp;  /* GC uses this to find current stack top */
-  sf->prev_frame = ctx->current_stack_frame;
-  ctx->current_stack_frame = sf;
-
-restart:
-  for (;;) {
-    int call_argc;
-    JSValue *call_argv;
-
-    SWITCH (pc) {
-      CASE (OP_push_i32) : *sp++ = JS_NewInt32 (ctx, get_u32 (pc));
-      pc += 4;
-      BREAK;
-      CASE (OP_push_const) : *sp++ = b->cpool[get_u32 (pc)];
-      pc += 4;
-      BREAK;
-#if SHORT_OPCODES
-      CASE (OP_push_minus1)
-          : CASE (OP_push_0)
-          : CASE (OP_push_1)
-          : CASE (OP_push_2)
-          : CASE (OP_push_3)
-          : CASE (OP_push_4)
-          : CASE (OP_push_5)
-          : CASE (OP_push_6)
-          : CASE (OP_push_7) : *sp++ = JS_NewInt32 (ctx, opcode - OP_push_0);
-      BREAK;
-      CASE (OP_push_i8) : *sp++ = JS_NewInt32 (ctx, get_i8 (pc));
-      pc += 1;
-      BREAK;
-      CASE (OP_push_i16) : *sp++ = JS_NewInt32 (ctx, get_i16 (pc));
-      pc += 2;
-      BREAK;
-      CASE (OP_push_const8) : *sp++ = b->cpool[*pc++];
-      BREAK;
-      CASE (OP_fclosure8)
-          : *sp++ = js_closure (ctx, b->cpool[*pc++], sf);
-      if (unlikely (JS_IsException (sp[-1]))) goto exception;
-      BREAK;
-      CASE (OP_push_empty_string) : *sp++ = JS_KEY_empty;
-      BREAK;
-#endif
-      CASE (OP_null) : *sp++ = JS_NULL;
-      BREAK;
-      CASE (OP_push_this)
-          : /* OP_push_this is only called at the start of a function */
-      {
-        JSValue val = this_obj;
-        *sp++ = val;
-      }
-      BREAK;
-      CASE (OP_push_false) : *sp++ = JS_FALSE;
-      BREAK;
-      CASE (OP_push_true) : *sp++ = JS_TRUE;
-      BREAK;
-      CASE (OP_object) : *sp++ = JS_NewObject (ctx);
-      if (unlikely (JS_IsException (sp[-1]))) goto exception;
-      BREAK;
-      CASE (OP_special_object) : {
-        int arg = *pc++;
-        switch (arg) {
-        case OP_SPECIAL_OBJECT_THIS_FUNC:
-          *sp++ = sf->cur_func;
-          break;
-        case OP_SPECIAL_OBJECT_VAR_OBJECT:
-          *sp++ = JS_NewObjectProto (ctx, JS_NULL);
-          if (unlikely (JS_IsException (sp[-1]))) goto exception;
-          break;
-        default:
-          abort ();
-        }
-      }
-      BREAK;
-      CASE (OP_drop) : ;
-      sp--;
-      BREAK;
-      CASE (OP_nip) : ;
-      sp[-2] = sp[-1];
-      sp--;
-      BREAK;
-      CASE (OP_nip1)
-          : /* a b c -> b c */
-      sp[-3] = sp[-2];
-      sp[-2] = sp[-1];
-      sp--;
-      BREAK;
-      CASE (OP_dup) : sp[0] = sp[-1];
-      sp++;
-      BREAK;
-      CASE (OP_dup2)
-          : /* a b -> a b a b */
-            sp[0] = sp[-2];
-      sp[1] = sp[-1];
-      sp += 2;
-      BREAK;
-      CASE (OP_dup3)
-          : /* a b c -> a b c a b c */
-            sp[0] = sp[-3];
-      sp[1] = sp[-2];
-      sp[2] = sp[-1];
-      sp += 3;
-      BREAK;
-      CASE (OP_dup1)
-          : /* a b -> a a b */
-            sp[0] = sp[-1];
-      sp[-1] = sp[-2];
-      sp++;
-      BREAK;
-      CASE (OP_insert2)
-          : /* obj a -> a obj a (dup_x1) */
-            sp[0] = sp[-1];
-      sp[-1] = sp[-2];
-      sp[-2] = sp[0];
-      sp++;
-      BREAK;
-      CASE (OP_insert3)
-          : /* obj prop a -> a obj prop a (dup_x2) */
-            sp[0] = sp[-1];
-      sp[-1] = sp[-2];
-      sp[-2] = sp[-3];
-      sp[-3] = sp[0];
-      sp++;
-      BREAK;
-      CASE (OP_insert4)
-          : /* this obj prop a -> a this obj prop a */
-            sp[0] = sp[-1];
-      sp[-1] = sp[-2];
-      sp[-2] = sp[-3];
-      sp[-3] = sp[-4];
-      sp[-4] = sp[0];
-      sp++;
-      BREAK;
-      CASE (OP_perm3)
-          : /* obj a b -> a obj b (213) */
-      {
-        JSValue tmp;
-        tmp = sp[-2];
-        sp[-2] = sp[-3];
-        sp[-3] = tmp;
-      }
-      BREAK;
-      CASE (OP_rot3l)
-          : /* x a b -> a b x (231) */
-      {
-        JSValue tmp;
-        tmp = sp[-3];
-        sp[-3] = sp[-2];
-        sp[-2] = sp[-1];
-        sp[-1] = tmp;
-      }
-      BREAK;
-      CASE (OP_rot4l)
-          : /* x a b c -> a b c x */
-      {
-        JSValue tmp;
-        tmp = sp[-4];
-        sp[-4] = sp[-3];
-        sp[-3] = sp[-2];
-        sp[-2] = sp[-1];
-        sp[-1] = tmp;
-      }
-      BREAK;
-      CASE (OP_rot5l)
-          : /* x a b c d -> a b c d x */
-      {
-        JSValue tmp;
-        tmp = sp[-5];
-        sp[-5] = sp[-4];
-        sp[-4] = sp[-3];
-        sp[-3] = sp[-2];
-        sp[-2] = sp[-1];
-        sp[-1] = tmp;
-      }
-      BREAK;
-      CASE (OP_rot3r)
-          : /* a b x -> x a b (312) */
-      {
-        JSValue tmp;
-        tmp = sp[-1];
-        sp[-1] = sp[-2];
-        sp[-2] = sp[-3];
-        sp[-3] = tmp;
-      }
-      BREAK;
-      CASE (OP_perm4)
-          : /* obj prop a b -> a obj prop b */
-      {
-        JSValue tmp;
-        tmp = sp[-2];
-        sp[-2] = sp[-3];
-        sp[-3] = sp[-4];
-        sp[-4] = tmp;
-      }
-      BREAK;
-      CASE (OP_perm5)
-          : /* this obj prop a b -> a this obj prop b */
-      {
-        JSValue tmp;
-        tmp = sp[-2];
-        sp[-2] = sp[-3];
-        sp[-3] = sp[-4];
-        sp[-4] = sp[-5];
-        sp[-5] = tmp;
-      }
-      BREAK;
-      CASE (OP_swap)
-          : /* a b -> b a */
-      {
-        JSValue tmp;
-        tmp = sp[-2];
-        sp[-2] = sp[-1];
-        sp[-1] = tmp;
-      }
-      BREAK;
-      CASE (OP_swap2)
-          : /* a b c d -> c d a b */
-      {
-        JSValue tmp1, tmp2;
-        tmp1 = sp[-4];
-        tmp2 = sp[-3];
-        sp[-4] = sp[-2];
-        sp[-3] = sp[-1];
-        sp[-2] = tmp1;
-        sp[-1] = tmp2;
-      }
-      BREAK;
-
-      CASE (OP_fclosure) : {
-        JSValue bfunc = b->cpool[get_u32 (pc)];
-        pc += 4;
-        *sp++ = js_closure (ctx, bfunc, sf);
-        if (unlikely (JS_IsException (sp[-1]))) goto exception;
-      }
-      BREAK;
-#if SHORT_OPCODES
-      CASE (OP_call0)
-          : CASE (OP_call1)
-          : CASE (OP_call2) : CASE (OP_call3) : call_argc = opcode - OP_call0;
-      goto has_call_argc;
-#endif
-      CASE (OP_call) : CASE (OP_tail_call) : {
-        call_argc = get_u16 (pc);
-        pc += 2;
-        goto has_call_argc;
-      has_call_argc:
-        call_argv = sp - call_argc;
-        sf->cur_pc = pc;
-        /* TODO: Use trampoline - for now keep recursive */
-        ret_val = JS_CallInternal (ctx, call_argv[-1], JS_NULL, call_argc, call_argv, 0);
-        if (unlikely (JS_IsException (ret_val))) goto exception;
-        if (opcode == OP_tail_call) goto done;
-        sp -= call_argc + 1;
-        *sp++ = ret_val;
-      }
-      BREAK;
-      CASE (OP_call_method) : CASE (OP_tail_call_method) : {
-        call_argc = get_u16 (pc);
-        pc += 2;
-        call_argv = sp - call_argc;
-        sf->cur_pc = pc;
-        /* Proxy method-call: detect [func, "name", ...args]
-           and rewrite as func("name", [args]) */
-
-        if (JS_IsFunction (call_argv[-2])) {
-          JSValue name = call_argv[-1];
-          if (!JS_IsText (name)) {
-            ret_val
-              = JS_ThrowTypeError (ctx, "second argument must be a string");
-            goto exception;
-          }
-
-          JSValue args = JS_NewArrayLen (ctx, call_argc);
-          if (unlikely (JS_IsException (args))) goto exception;
-
-          /* Move args into the array, then null out stack slots. */
-          JSArray *ar = JS_VALUE_GET_ARRAY (args);
-          for (i = 0; i < call_argc; i++) {
-            ar->values[i] = call_argv[i];
-            call_argv[i] = JS_NULL;
-          }
-
-          JSValue proxy_argv[2];
-          proxy_argv[0]
-            = name; /* still owned by stack; freed by normal cleanup */
-          proxy_argv[1] = args;
-
-          ret_val
-            = JS_CallInternal (ctx, call_argv[-2], JS_NULL, 2, proxy_argv, 0);
-        } else {
-          ret_val = JS_CallInternal (ctx, call_argv[-1], call_argv[-2], call_argc, call_argv, 0);
-        }
-        if (unlikely (JS_IsException (ret_val))) goto exception;
-        if (opcode == OP_tail_call_method) goto done;
-        for (i = -2; i < call_argc; i++)
-        sp -= call_argc + 2;
-        *sp++ = ret_val;
-      }
-      BREAK;
-      CASE (OP_array_from) : {
-        int i;
-
-        call_argc = get_u16 (pc);
-        pc += 2;
-        ret_val = JS_NewArrayLen (ctx, call_argc);
-        if (unlikely (JS_IsException (ret_val))) goto exception;
-        call_argv = sp - call_argc;
-        JSArray *ar = JS_VALUE_GET_ARRAY (ret_val);
-        for (i = 0; i < call_argc; i++) {
-          ar->values[i] = call_argv[i];
-          call_argv[i] = JS_NULL;
-        }
-        sp -= call_argc;
-        *sp++ = ret_val;
-      }
-      BREAK;
-      CASE (OP_return) : ret_val = *--sp;
-      goto done;
-      CASE (OP_return_undef) : ret_val = JS_NULL;
-      goto done;
-
-      CASE (OP_throw) : JS_Throw (ctx, *--sp);
-      goto exception;
-
-      CASE (OP_throw_error)
-          :
-#define JS_THROW_VAR_RO 0
-#define JS_THROW_VAR_REDECL 1
-#define JS_THROW_VAR_UNINITIALIZED 2
-#define JS_THROW_ERROR_ITERATOR_THROW 4
-      {
-        JSValue key;
-        int type;
-        key = b->cpool[get_u32 (pc)];
-        type = pc[4];
-        pc += 5;
-        if (type == JS_THROW_VAR_REDECL)
-          JS_ThrowSyntaxErrorVarRedeclaration (ctx, key);
-        else if (type == JS_THROW_VAR_UNINITIALIZED)
-          JS_ThrowReferenceErrorUninitialized (ctx, key);
-        else if (type == JS_THROW_ERROR_ITERATOR_THROW)
-          JS_ThrowTypeError (ctx, "iterator does not have a throw method");
-        else
-          JS_ThrowInternalError (ctx, "invalid throw var type %d", type);
-      }
-      goto exception;
-
-      CASE (OP_regexp) : {
-        sp[-2] = js_regexp_constructor_internal (ctx, sp[-2], sp[-1]);
-        sp--;
-      }
-      BREAK;
-
-      /* Global variable opcodes - resolved by linker to get/set_global_slot */
-      CASE (OP_check_var) :
-        pc += 4;
-        JS_ThrowInternalError (ctx, "OP_check_var: linker should have resolved this");
-        goto exception;
-      BREAK;
-      CASE (OP_get_var_undef) :
-      CASE (OP_get_var) :
-        pc += 4;
-        JS_ThrowInternalError (ctx, "OP_get_var: linker should have resolved to get_global_slot");
-        goto exception;
-      BREAK;
-      CASE (OP_put_var) :
-      CASE (OP_put_var_init) :
-        pc += 4;
-        sp--;
-        JS_ThrowInternalError (ctx, "OP_put_var: global object is immutable, linker should resolve");
-        goto exception;
-      BREAK;
-      CASE (OP_put_var_strict) :
-        pc += 4;
-        sp -= 2;
-        JS_ThrowInternalError (ctx, "OP_put_var_strict: global object is immutable, linker should resolve");
-        goto exception;
-      BREAK;
-
-      CASE (OP_define_var) :
-      CASE (OP_check_define_var) :
-        pc += 5;
-        JS_ThrowInternalError (ctx, "global object is immutable - cannot define variables at runtime");
-        goto exception;
-      BREAK;
-      CASE (OP_define_func) :
-        pc += 5;
-        sp--;
-        JS_ThrowInternalError (ctx, "global object is immutable - cannot define functions at runtime");
-        goto exception;
-      BREAK;
-
-      CASE (OP_get_loc) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        sp[0] = var_buf[idx];
-        sp++;
-      }
-      BREAK;
-      CASE (OP_put_loc) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        set_value (ctx, &var_buf[idx], sp[-1]);
-        sp--;
-      }
-      BREAK;
-      CASE (OP_set_loc) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        set_value (ctx, &var_buf[idx], sp[-1]);
-      }
-      BREAK;
-      CASE (OP_get_arg) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        sp[0] = arg_buf[idx];
-        sp++;
-      }
-      BREAK;
-      CASE (OP_put_arg) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        set_value (ctx, &arg_buf[idx], sp[-1]);
-        sp--;
-      }
-      BREAK;
-      CASE (OP_set_arg) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        set_value (ctx, &arg_buf[idx], sp[-1]);
-      }
-      BREAK;
-
-#if SHORT_OPCODES
-      CASE (OP_get_loc8) : *sp++ = var_buf[*pc++];
-      BREAK;
-      CASE (OP_put_loc8) : set_value (ctx, &var_buf[*pc++], *--sp);
-      BREAK;
-      CASE (OP_set_loc8)
-          : set_value (ctx, &var_buf[*pc++], sp[-1]);
-      BREAK;
-
-      CASE (OP_get_loc0) : *sp++ = var_buf[0];
-      BREAK;
-      CASE (OP_get_loc1) : *sp++ = var_buf[1];
-      BREAK;
-      CASE (OP_get_loc2) : *sp++ = var_buf[2];
-      BREAK;
-      CASE (OP_get_loc3) : *sp++ = var_buf[3];
-      BREAK;
-      CASE (OP_put_loc0) : set_value (ctx, &var_buf[0], *--sp);
-      BREAK;
-      CASE (OP_put_loc1) : set_value (ctx, &var_buf[1], *--sp);
-      BREAK;
-      CASE (OP_put_loc2) : set_value (ctx, &var_buf[2], *--sp);
-      BREAK;
-      CASE (OP_put_loc3) : set_value (ctx, &var_buf[3], *--sp);
-      BREAK;
-      CASE (OP_set_loc0)
-          : set_value (ctx, &var_buf[0], sp[-1]);
-      BREAK;
-      CASE (OP_set_loc1)
-          : set_value (ctx, &var_buf[1], sp[-1]);
-      BREAK;
-      CASE (OP_set_loc2)
-          : set_value (ctx, &var_buf[2], sp[-1]);
-      BREAK;
-      CASE (OP_set_loc3)
-          : set_value (ctx, &var_buf[3], sp[-1]);
-      BREAK;
-      CASE (OP_get_arg0) : *sp++ = arg_buf[0];
-      BREAK;
-      CASE (OP_get_arg1) : *sp++ = arg_buf[1];
-      BREAK;
-      CASE (OP_get_arg2) : *sp++ = arg_buf[2];
-      BREAK;
-      CASE (OP_get_arg3) : *sp++ = arg_buf[3];
-      BREAK;
-      CASE (OP_put_arg0) : set_value (ctx, &arg_buf[0], *--sp);
-      BREAK;
-      CASE (OP_put_arg1) : set_value (ctx, &arg_buf[1], *--sp);
-      BREAK;
-      CASE (OP_put_arg2) : set_value (ctx, &arg_buf[2], *--sp);
-      BREAK;
-      CASE (OP_put_arg3) : set_value (ctx, &arg_buf[3], *--sp);
-      BREAK;
-      CASE (OP_set_arg0)
-          : set_value (ctx, &arg_buf[0], sp[-1]);
-      BREAK;
-      CASE (OP_set_arg1)
-          : set_value (ctx, &arg_buf[1], sp[-1]);
-      BREAK;
-      CASE (OP_set_arg2)
-          : set_value (ctx, &arg_buf[2], sp[-1]);
-      BREAK;
-      CASE (OP_set_arg3)
-          : set_value (ctx, &arg_buf[3], sp[-1]);
-      BREAK;
-#endif
-      CASE (OP_set_loc_uninitialized) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        set_value (ctx, &var_buf[idx], JS_UNINITIALIZED);
-      }
-      BREAK;
-      CASE (OP_get_loc_check) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        if (unlikely (JS_IsUninitialized (var_buf[idx]))) {
-          JS_ThrowReferenceErrorUninitialized2 (ctx, b, idx, FALSE);
-          goto exception;
-        }
-        sp[0] = var_buf[idx];
-        sp++;
-      }
-      BREAK;
-      CASE (OP_get_loc_checkthis) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        if (unlikely (JS_IsUninitialized (var_buf[idx]))) {
-          JS_ThrowReferenceErrorUninitialized2 (caller_ctx, b, idx, FALSE);
-          goto exception;
-        }
-        sp[0] = var_buf[idx];
-        sp++;
-      }
-      BREAK;
-      CASE (OP_put_loc_check) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        if (unlikely (JS_IsUninitialized (var_buf[idx]))) {
-          JS_ThrowReferenceErrorUninitialized2 (ctx, b, idx, FALSE);
-          goto exception;
-        }
-        set_value (ctx, &var_buf[idx], sp[-1]);
-        sp--;
-      }
-      BREAK;
-      CASE (OP_put_loc_check_init) : {
-        int idx;
-        idx = get_u16 (pc);
-        pc += 2;
-        if (unlikely (!JS_IsUninitialized (var_buf[idx]))) {
-          JS_ThrowReferenceError (ctx, "'this' can be initialized only once");
-          goto exception;
-        }
-        set_value (ctx, &var_buf[idx], sp[-1]);
-        sp--;
-      }
-      BREAK;
-
-      CASE (OP_goto) : pc += (int32_t)get_u32 (pc);
-      if (unlikely (js_poll_interrupts (ctx))) goto exception;
-      BREAK;
-#if SHORT_OPCODES
-      CASE (OP_goto16) : pc += (int16_t)get_u16 (pc);
-      if (unlikely (js_poll_interrupts (ctx))) goto exception;
-      BREAK;
-      CASE (OP_goto8) : pc += (int8_t)pc[0];
-      if (unlikely (js_poll_interrupts (ctx))) goto exception;
-      BREAK;
-#endif
-      CASE (OP_if_true) : {
-        int res;
-        JSValue op1;
-
-        op1 = sp[-1];
-        pc += 4;
-        if ((uint32_t)JS_VALUE_GET_TAG (op1) <= JS_TAG_NULL) {
-          res = JS_VALUE_GET_INT (op1);
-        } else {
-          res = JS_ToBool (ctx, op1);
-        }
-        sp--;
-        if (res) { pc += (int32_t)get_u32 (pc - 4) - 4; }
-        if (unlikely (js_poll_interrupts (ctx))) goto exception;
-      }
-      BREAK;
-      CASE (OP_if_false) : {
-        int res;
-        JSValue op1;
-
-        op1 = sp[-1];
-        pc += 4;
-        /* quick and dirty test for JS_TAG_INT, JS_TAG_BOOL, JS_TAG_NULL and
-         * JS_TAG_UNDEFINED */
-        if ((uint32_t)JS_VALUE_GET_TAG (op1) <= JS_TAG_NULL) {
-          res = JS_VALUE_GET_INT (op1);
-        } else {
-          res = JS_ToBool (ctx, op1);
-        }
-        sp--;
-        if (!res) { pc += (int32_t)get_u32 (pc - 4) - 4; }
-        if (unlikely (js_poll_interrupts (ctx))) goto exception;
-      }
-      BREAK;
-#if SHORT_OPCODES
-      CASE (OP_if_true8) : {
-        int res;
-        JSValue op1;
-
-        op1 = sp[-1];
-        pc += 1;
-        if ((uint32_t)JS_VALUE_GET_TAG (op1) <= JS_TAG_NULL) {
-          res = JS_VALUE_GET_INT (op1);
-        } else {
-          res = JS_ToBool (ctx, op1);
-        }
-        sp--;
-        if (res) { pc += (int8_t)pc[-1] - 1; }
-        if (unlikely (js_poll_interrupts (ctx))) goto exception;
-      }
-      BREAK;
-      CASE (OP_if_false8) : {
-        int res;
-        JSValue op1;
-
-        op1 = sp[-1];
-        pc += 1;
-        if ((uint32_t)JS_VALUE_GET_TAG (op1) <= JS_TAG_NULL) {
-          res = JS_VALUE_GET_INT (op1);
-        } else {
-          res = JS_ToBool (ctx, op1);
-        }
-        sp--;
-        if (!res) { pc += (int8_t)pc[-1] - 1; }
-        if (unlikely (js_poll_interrupts (ctx))) goto exception;
-      }
-      BREAK;
-#endif
-      CASE (OP_catch) : {
-        int32_t diff;
-        diff = get_u32 (pc);
-        sp[0] = JS_NewCatchOffset (ctx, pc + diff - b->byte_code_buf);
-        sp++;
-        pc += 4;
-      }
-      BREAK;
-      CASE (OP_gosub) : {
-        int32_t diff;
-        diff = get_u32 (pc);
-        /* XXX: should have a different tag to avoid security flaw */
-        sp[0] = JS_NewInt32 (ctx, pc + 4 - b->byte_code_buf);
-        sp++;
-        pc += diff;
-      }
-      BREAK;
-      CASE (OP_ret) : {
-        JSValue op1;
-        uint32_t pos;
-        op1 = sp[-1];
-        if (unlikely (JS_VALUE_GET_TAG (op1) != JS_TAG_INT)) goto ret_fail;
-        pos = JS_VALUE_GET_INT (op1);
-        if (unlikely (pos >= b->byte_code_len)) {
-        ret_fail:
-          JS_ThrowInternalError (ctx, "invalid ret value");
-          goto exception;
-        }
-        sp--;
-        pc = b->byte_code_buf + pos;
-      }
-      BREAK;
-
-      CASE (OP_nip_catch) : {
-        JSValue ret_val;
-        /* catch_offset ... ret_val -> ret_eval */
-        ret_val = *--sp;
-        while (sp > stack_buf
-               && JS_VALUE_GET_TAG (sp[-1]) != JS_TAG_CATCH_OFFSET) {
-        }
-        if (unlikely (sp == stack_buf)) {
-          JS_ThrowInternalError (ctx, "nip_catch");
-          goto exception;
-        }
-        sp[-1] = ret_val;
-      }
-      BREAK;
-
-      CASE (OP_lnot) : {
-        int res;
-        JSValue op1;
-
-        op1 = sp[-1];
-        if ((uint32_t)JS_VALUE_GET_TAG (op1) <= JS_TAG_NULL) {
-          res = JS_VALUE_GET_INT (op1) != 0;
-        } else {
-          res = JS_ToBool (ctx, op1);
-        }
-        sp[-1] = JS_NewBool (ctx, !res);
-      }
-      BREAK;
-
-      CASE (OP_get_field) : {
-        JSValue val;
-        uint32_t idx;
-        JSValue key;
-        JSValue obj;
-
-        idx = get_u32 (pc);
-        pc += 4;
-
-        sf->cur_pc = pc;
-
-        /* Get JSValue key from cpool */
-        key = b->cpool[idx];
-
-        obj = sp[-1];
-
-        /* Record property access - use JSValue key directly */
-        if (JS_IsRecord (obj)) {
-          JSRecord *rec = JS_VALUE_GET_RECORD (obj);
-          val = rec_get (ctx, rec, key);
-          sp[-1] = val;
-        } else {
-          /* Non-record: return null */
-          sp[-1] = JS_NULL;
-        }
-      }
-      BREAK;
-
-      CASE (OP_get_field2) : {
-        JSValue val;
-        uint32_t idx;
-        JSValue key;
-        JSValue obj;
-
-        idx = get_u32 (pc);
-        pc += 4;
-
-        sf->cur_pc = pc;
-
-        /* Get JSValue key from cpool */
-        key = b->cpool[idx];
-
-        obj = sp[-1];
-
-        /* Proxy method-call sugar: func.name(...) -> func("name", [args...])
-           OP_get_field2 is only emitted when a call immediately follows. */
-        if (JS_IsFunction (obj)) {
-          val = key; /* "name" as JSValue string */
-          *sp++ = val;                  /* stack becomes [func, "name"] */
-        } else if (JS_IsRecord (obj)) {
-          /* Record property access - use JSValue key directly */
-          JSRecord *rec = JS_VALUE_GET_RECORD (obj);
-          val = rec_get (ctx, rec, key);
-          *sp++ = val;
-        } else {
-          /* Non-record: push null */
-          *sp++ = JS_NULL;
-        }
-      }
-      BREAK;
-
-      CASE (OP_put_field) : {
-        int ret;
-        uint32_t idx;
-        JSValue key;
-
-        idx = get_u32 (pc);
-        pc += 4;
-        sf->cur_pc = pc;
-
-        /* Get JSValue key from cpool */
-        key = b->cpool[idx];
-
-        /* Must be a record to set property */
-        if (!JS_IsRecord (sp[-2])) {
-          sp -= 2;
-          JS_ThrowTypeError (ctx, "cannot set property of non-record");
-          goto exception;
-        }
-
-        /* Record property set - use JSValue key directly */
-        ret = rec_set_own (ctx, &sp[-2], key, sp[-1]);
-        sp -= 2;
-        if (unlikely (ret < 0)) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_define_field) : {
-        int ret;
-        uint32_t idx;
-        JSValue key;
-
-        idx = get_u32 (pc);
-        pc += 4;
-
-        /* Get JSValue key from cpool */
-        key = b->cpool[idx];
-
-        /* Must be a record */
-        if (!JS_IsRecord (sp[-2])) {
-          sp--;
-          JS_ThrowTypeError (ctx, "cannot define field on non-record");
-          goto exception;
-        }
-
-        /* Record property set - use JSValue key directly */
-        ret = rec_set_own (ctx, &sp[-2], key, sp[-1]);
-        sp--;
-        if (unlikely (ret < 0)) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_set_name) : {
-        int ret;
-        JSValue key;
-        key = b->cpool[get_u32 (pc)];
-        pc += 4;
-
-        ret = JS_DefineObjectName (ctx, sp[-1], key);
-        if (unlikely (ret < 0)) goto exception;
-      }
-      BREAK;
-      CASE (OP_set_name_computed) : {
-        int ret;
-        ret = JS_DefineObjectNameComputed (ctx, sp[-1], sp[-2]);
-        if (unlikely (ret < 0)) goto exception;
-      }
-      BREAK;
-      CASE (OP_define_method) : CASE (OP_define_method_computed) : {
-        JSValue value;
-        JSValue obj;
-        JSValue key;
-        int ret, op_flags;
-        BOOL is_computed;
-#define OP_DEFINE_METHOD_METHOD 0
-#define OP_DEFINE_METHOD_ENUMERABLE 4
-
-        is_computed = (opcode == OP_define_method_computed);
-        if (is_computed) {
-          key = sp[-2];
-          opcode += OP_define_method - OP_define_method_computed;
-        } else {
-          key = b->cpool[get_u32 (pc)];
-          pc += 4;
-        }
-        op_flags = *pc++;
-
-        obj = sp[-2 - is_computed];
-        op_flags &= 3;
-        value = JS_NULL;
-
-        if (op_flags == OP_DEFINE_METHOD_METHOD) { value = sp[-1]; }
-        ret = js_method_set_properties (ctx, sp[-1], key, 0, obj);
-        if (ret >= 0) {
-          /* JS_SetProperty consumes value, so don't free sp[-1] on success */
-          ret = JS_SetProperty (ctx, obj, key, value);
-        } else {
-        }
-        if (is_computed) { ; }
-        sp -= 1 + is_computed;
-        if (unlikely (ret < 0)) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_define_class)
-          : CASE (OP_define_class_computed)
-          : JS_ThrowTypeError (ctx, "classes are not supported");
-      goto exception;
-
-      CASE (OP_get_array_el) : {
-        JSValue val;
-        sf->cur_pc = pc;
-        val = JS_GetPropertyValue (ctx, sp[-2], sp[-1]);
-        sp[-2] = val;
-        sp--;
-        if (unlikely (JS_IsException (val))) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_get_array_el2) : {
-        JSValue val;
-        sf->cur_pc = pc;
-        val = JS_GetPropertyValue (ctx, sp[-2], sp[-1]);
-        sp[-1] = val;
-        if (unlikely (JS_IsException (val))) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_get_array_el3) : {
-        JSValue val;
-        switch (JS_VALUE_GET_TAG (sp[-2])) {
-        case JS_TAG_INT:
-        case JS_TAG_STRING:
-          break;
-        default:
-          /* must be tested nefore JS_ToPropertyKey */
-          if (unlikely (JS_IsNull (sp[-2]))) {
-            JS_ThrowTypeError (ctx, "value has no property");
-            goto exception;
-          }
-          sf->cur_pc = pc;
-          ret_val = sp[-1]; // JS_ToPropertyKey (ctx, sp[-1]); // is this correct? No conversion can happen.
-          if (JS_IsException (ret_val)) goto exception;
-          sp[-1] = ret_val;
-          break;
-        }
-        sf->cur_pc = pc;
-        val = JS_GetPropertyValue (ctx, sp[-2], sp[-1]);
-        *sp++ = val;
-        if (unlikely (JS_IsException (val))) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_put_array_el) : {
-        int ret;
-
-        /* Functions don't support property assignment in cell script */
-        if (JS_IsFunction (sp[-3])) {
-          JS_ThrowTypeError (ctx, "cannot set property of function");
-          goto exception;
-        }
-
-        sf->cur_pc = pc;
-        ret = JS_SetPropertyValue (ctx, sp[-3], sp[-2], sp[-1]);
-        sp -= 3;
-        if (unlikely (ret < 0)) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_define_array_el) : {
-        int ret;
-        ret = JS_SetPropertyValue (ctx, sp[-3], sp[-2], sp[-1]);
-        sp -= 1;
-        if (unlikely (ret < 0)) goto exception;
-      }
-      BREAK;
-
-      CASE (OP_copy_data_properties)
-          : /* target source excludeList */
-      {
-        /* stack offsets (-1 based):
-           2 bits for target,
-           3 bits for source,
-           2 bits for exclusionList */
-        int mask;
-
-        mask = *pc++;
-        sf->cur_pc = pc;
-        if (JS_CopyDataProperties (ctx, sp[-1 - (mask & 3)], sp[-1 - ((mask >> 2) & 7)], sp[-1 - ((mask >> 5) & 7)], 0))
-          goto exception;
-      }
-      BREAK;
-
-      CASE (OP_add) : CASE (OP_add_float) : {
-        JSValue op1 = sp[-2], op2 = sp[-1], res;
-        int tag1 = JS_VALUE_GET_NORM_TAG (op1);
-        int tag2 = JS_VALUE_GET_NORM_TAG (op2);
-
-        /* 1) both ints? keep fast int path with overflow check */
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          int64_t tmp
-            = (int64_t)JS_VALUE_GET_INT (op1) + JS_VALUE_GET_INT (op2);
-          if (likely ((int)tmp == tmp)) {
-            res = JS_NewInt32 (ctx, (int)tmp);
-          } else {
-            res = __JS_NewFloat64 (ctx, (double)JS_VALUE_GET_INT (op1) + (double)JS_VALUE_GET_INT (op2));
-          }
-        }
-        /* 2) both floats? */
-        else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)) {
-          res = __JS_NewFloat64 (ctx, JS_VALUE_GET_FLOAT64 (op1) + JS_VALUE_GET_FLOAT64 (op2));
-        }
-        /* 3) both strings? */
-        else if (JS_IsText (op1) && JS_IsText (op2)) {
-          res = JS_ConcatString (ctx, op1, op2);
-          if (JS_IsException (res)) goto exception;
-        }
-        /* 4) mixed int/float? promote to float */
-        // TODO: Seems slow
-        else if ((tag1 == JS_TAG_INT && tag2 == JS_TAG_FLOAT64)
-                 || (tag1 == JS_TAG_FLOAT64 && tag2 == JS_TAG_INT)) {
-          double a, b;
-          if (tag1 == JS_TAG_INT)
-            a = (double)JS_VALUE_GET_INT (op1);
-          else
-            a = JS_VALUE_GET_FLOAT64 (op1);
-          if (tag2 == JS_TAG_INT)
-            b = (double)JS_VALUE_GET_INT (op2);
-          else
-            b = JS_VALUE_GET_FLOAT64 (op2);
-          res = __JS_NewFloat64 (ctx, a + b);
-        } else if (tag1 == JS_TAG_NULL || tag2 == JS_TAG_NULL) {
-          /* null + string or string + null should throw */
-          if (JS_IsText (op1) || JS_IsText (op2)) {
-            JS_ThrowTypeError (ctx, "cannot concatenate null with string");
-            goto exception;
-          }
-          res = JS_NULL;
-        }
-        /* 5) anything else → throw */
-        else {
-          JS_ThrowTypeError (ctx, "cannot concatenate with string");
-          goto exception;
-        }
-
-        sp[-2] = res;
-        sp--;
-      }
-      BREAK;
-      CASE (OP_add_loc) : {
-        int idx = *pc++;
-        JSValue rhs = sp[-1];
-        JSValue lhs = var_buf[idx];
-        JSValue res;
-        int tag1 = JS_VALUE_GET_NORM_TAG (lhs);
-        int tag2 = JS_VALUE_GET_NORM_TAG (rhs);
-
-        /* 1) both ints? fast path, overflow → float64 */
-        if (likely (JS_VALUE_IS_BOTH_INT (lhs, rhs))) {
-          int a_i = JS_VALUE_GET_INT (lhs);
-          int b_i = JS_VALUE_GET_INT (rhs);
-          int64_t tmp = (int64_t)a_i + b_i;
-          if ((int)tmp == tmp)
-            res = JS_NewInt32 (ctx, (int)tmp);
-          else
-            res = __JS_NewFloat64 (ctx, (double)a_i + (double)b_i);
-        }
-        /* 2) both floats? */
-        else if (JS_VALUE_IS_BOTH_FLOAT (lhs, rhs)) {
-          res = __JS_NewFloat64 (ctx, JS_VALUE_GET_FLOAT64 (lhs) + JS_VALUE_GET_FLOAT64 (rhs));
-        }
-        /* 3) both strings? */
-        else if (JS_IsText (lhs) && JS_IsText (rhs)) {
-          res = JS_ConcatString (ctx, lhs, rhs);
-          if (JS_IsException (res)) goto exception;
-        }
-        /* 4) mixed int/float? promote to float64 */
-        else if ((tag1 == JS_TAG_INT && tag2 == JS_TAG_FLOAT64)
-                 || (tag1 == JS_TAG_FLOAT64 && tag2 == JS_TAG_INT)) {
-          double a = tag1 == JS_TAG_INT ? (double)JS_VALUE_GET_INT (lhs)
-                                        : JS_VALUE_GET_FLOAT64 (lhs);
-          double b = tag2 == JS_TAG_INT ? (double)JS_VALUE_GET_INT (rhs)
-                                        : JS_VALUE_GET_FLOAT64 (rhs);
-          res = __JS_NewFloat64 (ctx, a + b);
-        }
-        /* 5) anything else → throw */
-        else {
-          JS_ThrowTypeError (ctx, "cannot concatenate with string");
-          goto exception;
-        }
-
-        var_buf[idx] = res;
-        sp--;
-      }
-      BREAK;
-      CASE (OP_sub) : CASE (OP_sub_float) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          int64_t r;
-          r = (int64_t)JS_VALUE_GET_INT (op1) - JS_VALUE_GET_INT (op2);
-          if (unlikely ((int)r != r)) goto binary_arith_slow;
-          sp[-2] = JS_NewInt32 (ctx, r);
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)) {
-          sp[-2] = __JS_NewFloat64 (ctx, JS_VALUE_GET_FLOAT64 (op1) - JS_VALUE_GET_FLOAT64 (op2));
-          sp--;
-        } else {
-          goto binary_arith_slow;
-        }
-      }
-      BREAK;
-      CASE (OP_mul) : CASE (OP_mul_float) : {
-        JSValue op1, op2;
-        double d;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          int32_t v1, v2;
-          int64_t r;
-          v1 = JS_VALUE_GET_INT (op1);
-          v2 = JS_VALUE_GET_INT (op2);
-          r = (int64_t)v1 * v2;
-          if (unlikely ((int)r != r)) {
-            d = (double)r;
-            goto mul_fp_res;
-          }
-          /* -0 normalized to 0, no special case needed */
-          sp[-2] = JS_NewInt32 (ctx, r);
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)) {
-          d = JS_VALUE_GET_FLOAT64 (op1) * JS_VALUE_GET_FLOAT64 (op2);
-        mul_fp_res:
-          sp[-2] = __JS_NewFloat64 (ctx, d);
-          sp--;
-        } else {
-          goto binary_arith_slow;
-        }
-      }
-      BREAK;
-      CASE (OP_div) : CASE (OP_div_float) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          int v1, v2;
-          v1 = JS_VALUE_GET_INT (op1);
-          v2 = JS_VALUE_GET_INT (op2);
-          sp[-2] = JS_NewFloat64 (ctx, (double)v1 / (double)v2);
-          sp--;
-        } else {
-          goto binary_arith_slow;
-        }
-      }
-      BREAK;
-      CASE (OP_mod) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          int v1, v2, r;
-          v1 = JS_VALUE_GET_INT (op1);
-          v2 = JS_VALUE_GET_INT (op2);
-          /* We must avoid v2 = 0, v1 = INT32_MIN and v2 =
-             -1 and the cases where the result is -0. */
-          if (unlikely (v1 < 0 || v2 <= 0)) goto binary_arith_slow;
-          r = v1 % v2;
-          sp[-2] = JS_NewInt32 (ctx, r);
-          sp--;
-        } else {
-          goto binary_arith_slow;
-        }
-      }
-      BREAK;
-      CASE (OP_pow) : binary_arith_slow : sf->cur_pc = pc;
-      if (js_binary_arith_slow (ctx, sp, opcode)) goto exception;
-      sp--;
-      BREAK;
-
-      CASE (OP_plus) : {
-        JSValue op1;
-        uint32_t tag;
-        op1 = sp[-1];
-        tag = JS_VALUE_GET_TAG (op1);
-        if (tag == JS_TAG_INT || JS_TAG_IS_FLOAT64 (tag)) {
-        } else {
-          sf->cur_pc = pc;
-          if (js_unary_arith_slow (ctx, sp, opcode)) goto exception;
-        }
-      }
-      BREAK;
-      CASE (OP_neg) : {
-        JSValue op1;
-        uint32_t tag;
-        int val;
-        double d;
-        op1 = sp[-1];
-        tag = JS_VALUE_GET_TAG (op1);
-        if (tag == JS_TAG_INT) {
-          val = JS_VALUE_GET_INT (op1);
-          /* -0 normalized to 0, val==0 just stays 0 */
-          if (unlikely (val == INT32_MIN)) {
-            d = -(double)val;
-            goto neg_fp_res;
-          }
-          sp[-1] = JS_NewInt32 (ctx, -val);
-        } else if (JS_TAG_IS_FLOAT64 (tag)) {
-          d = -JS_VALUE_GET_FLOAT64 (op1);
-        neg_fp_res:
-          sp[-1] = __JS_NewFloat64 (ctx, d);
-        } else {
-          sf->cur_pc = pc;
-          if (js_unary_arith_slow (ctx, sp, opcode)) goto exception;
-        }
-      }
-      BREAK;
-      CASE (OP_inc) : {
-        JSValue op1;
-        int val;
-        op1 = sp[-1];
-        if (JS_VALUE_GET_TAG (op1) == JS_TAG_INT) {
-          val = JS_VALUE_GET_INT (op1);
-          if (unlikely (val == INT32_MAX)) goto inc_slow;
-          sp[-1] = JS_NewInt32 (ctx, val + 1);
-        } else {
-        inc_slow:
-          sf->cur_pc = pc;
-          if (js_unary_arith_slow (ctx, sp, opcode)) goto exception;
-        }
-      }
-      BREAK;
-      CASE (OP_dec) : {
-        JSValue op1;
-        int val;
-        op1 = sp[-1];
-        if (JS_VALUE_GET_TAG (op1) == JS_TAG_INT) {
-          val = JS_VALUE_GET_INT (op1);
-          if (unlikely (val == INT32_MIN)) goto dec_slow;
-          sp[-1] = JS_NewInt32 (ctx, val - 1);
-        } else {
-        dec_slow:
-          sf->cur_pc = pc;
-          if (js_unary_arith_slow (ctx, sp, opcode)) goto exception;
-        }
-      }
-      BREAK;
-      CASE (OP_post_inc) : CASE (OP_post_dec) : sf->cur_pc = pc;
-      if (js_post_inc_slow (ctx, sp, opcode)) goto exception;
-      sp++;
-      BREAK;
-      CASE (OP_inc_loc) : {
-        JSValue op1;
-        int val;
-        int idx;
-        idx = *pc;
-        pc += 1;
-
-        op1 = var_buf[idx];
-        if (JS_VALUE_GET_TAG (op1) == JS_TAG_INT) {
-          val = JS_VALUE_GET_INT (op1);
-          if (unlikely (val == INT32_MAX)) goto inc_loc_slow;
-          var_buf[idx] = JS_NewInt32 (ctx, val + 1);
-        } else {
-        inc_loc_slow:
-          sf->cur_pc = pc;
-          /* op1 is read from var_buf, passed by reference to js_unary_arith_slow */
-          if (js_unary_arith_slow (ctx, &op1 + 1, OP_inc)) goto exception;
-          set_value (ctx, &var_buf[idx], op1);
-        }
-      }
-      BREAK;
-      CASE (OP_dec_loc) : {
-        JSValue op1;
-        int val;
-        int idx;
-        idx = *pc;
-        pc += 1;
-
-        op1 = var_buf[idx];
-        if (JS_VALUE_GET_TAG (op1) == JS_TAG_INT) {
-          val = JS_VALUE_GET_INT (op1);
-          if (unlikely (val == INT32_MIN)) goto dec_loc_slow;
-          var_buf[idx] = JS_NewInt32 (ctx, val - 1);
-        } else {
-        dec_loc_slow:
-          sf->cur_pc = pc;
-          /* op1 is read from var_buf, passed by reference to js_unary_arith_slow */
-          if (js_unary_arith_slow (ctx, &op1 + 1, OP_dec)) goto exception;
-          set_value (ctx, &var_buf[idx], op1);
-        }
-      }
-      BREAK;
-      CASE (OP_not) : {
-        JSValue op1;
-        op1 = sp[-1];
-        if (JS_VALUE_GET_TAG (op1) == JS_TAG_INT) {
-          sp[-1] = JS_NewInt32 (ctx, ~JS_VALUE_GET_INT (op1));
-        } else {
-          sf->cur_pc = pc;
-          if (js_not_slow (ctx, sp)) goto exception;
-        }
-      }
-      BREAK;
-
-      CASE (OP_shl) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          uint32_t v1, v2;
-          v1 = JS_VALUE_GET_INT (op1);
-          v2 = JS_VALUE_GET_INT (op2);
-          v2 &= 0x1f;
-          sp[-2] = JS_NewInt32 (ctx, v1 << v2);
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)
-                   || (JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                       && JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op2)))
-                   || (JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op1))
-                       && JS_VALUE_GET_TAG (op2) == JS_TAG_INT)) {
-          uint32_t v1, v2;
-          v1 = JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op1)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op1);
-          v2 = JS_VALUE_GET_TAG (op2) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op2)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op2);
-          v2 &= 0x1f;
-          sp[-2] = JS_NewInt32 (ctx, v1 << v2);
-          sp--;
-        } else {
-          sp[-2] = JS_NULL;
-          sp--;
-        }
-      }
-      BREAK;
-      CASE (OP_shr) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          uint32_t v2;
-          v2 = JS_VALUE_GET_INT (op2);
-          v2 &= 0x1f;
-          sp[-2] = JS_NewUint32 (ctx, (uint32_t)JS_VALUE_GET_INT (op1) >> v2);
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)
-                   || (JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                       && JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op2)))
-                   || (JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op1))
-                       && JS_VALUE_GET_TAG (op2) == JS_TAG_INT)) {
-          uint32_t v1, v2;
-          v1 = JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op1)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op1);
-          v2 = JS_VALUE_GET_TAG (op2) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op2)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op2);
-          v2 &= 0x1f;
-          sp[-2] = JS_NewUint32 (ctx, v1 >> v2);
-          sp--;
-        } else {
-          sp[-2] = JS_NULL;
-          sp--;
-        }
-      }
-      BREAK;
-      CASE (OP_sar) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          uint32_t v2;
-          v2 = JS_VALUE_GET_INT (op2);
-          v2 &= 0x1f;
-          sp[-2] = JS_NewInt32 (ctx, (int)JS_VALUE_GET_INT (op1) >> v2);
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)
-                   || (JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                       && JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op2)))
-                   || (JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op1))
-                       && JS_VALUE_GET_TAG (op2) == JS_TAG_INT)) {
-          int32_t v1;
-          uint32_t v2;
-          v1 = JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op1)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op1);
-          v2 = JS_VALUE_GET_TAG (op2) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op2)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op2);
-          v2 &= 0x1f;
-          sp[-2] = JS_NewInt32 (ctx, v1 >> v2);
-          sp--;
-        } else {
-          sp[-2] = JS_NULL;
-          sp--;
-        }
-      }
-      BREAK;
-      CASE (OP_and) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          sp[-2] = JS_NewInt32 (ctx, JS_VALUE_GET_INT (op1) & JS_VALUE_GET_INT (op2));
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)
-                   || (JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                       && JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op2)))
-                   || (JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op1))
-                       && JS_VALUE_GET_TAG (op2) == JS_TAG_INT)) {
-          int32_t v1, v2;
-          v1 = JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op1)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op1);
-          v2 = JS_VALUE_GET_TAG (op2) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op2)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op2);
-          sp[-2] = JS_NewInt32 (ctx, v1 & v2);
-          sp--;
-        } else {
-          sp[-2] = JS_NULL;
-          sp--;
-        }
-      }
-      BREAK;
-      CASE (OP_or) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          sp[-2] = JS_NewInt32 (ctx, JS_VALUE_GET_INT (op1) | JS_VALUE_GET_INT (op2));
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)
-                   || (JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                       && JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op2)))
-                   || (JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op1))
-                       && JS_VALUE_GET_TAG (op2) == JS_TAG_INT)) {
-          int32_t v1, v2;
-          v1 = JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op1)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op1);
-          v2 = JS_VALUE_GET_TAG (op2) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op2)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op2);
-          sp[-2] = JS_NewInt32 (ctx, v1 | v2);
-          sp--;
-        } else {
-          sp[-2] = JS_NULL;
-          sp--;
-        }
-      }
-      BREAK;
-      CASE (OP_xor) : {
-        JSValue op1, op2;
-        op1 = sp[-2];
-        op2 = sp[-1];
-        if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {
-          sp[-2] = JS_NewInt32 (ctx, JS_VALUE_GET_INT (op1) ^ JS_VALUE_GET_INT (op2));
-          sp--;
-        } else if (JS_VALUE_IS_BOTH_FLOAT (op1, op2)
-                   || (JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                       && JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op2)))
-                   || (JS_TAG_IS_FLOAT64 (JS_VALUE_GET_TAG (op1))
-                       && JS_VALUE_GET_TAG (op2) == JS_TAG_INT)) {
-          int32_t v1, v2;
-          v1 = JS_VALUE_GET_TAG (op1) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op1)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op1);
-          v2 = JS_VALUE_GET_TAG (op2) == JS_TAG_INT
-                 ? JS_VALUE_GET_INT (op2)
-                 : (int32_t)JS_VALUE_GET_FLOAT64 (op2);
-          sp[-2] = JS_NewInt32 (ctx, v1 ^ v2);
-          sp--;
-        } else {
-          sp[-2] = JS_NULL;
-          sp--;
-        }
-      }
-      BREAK;
-
-#define OP_CMP(opcode, binary_op, slow_call)                                              \
-  CASE (opcode) : {                                                                       \
-    JSValue op1, op2;                                                                     \
-    op1 = sp[-2];                                                                         \
-    op2 = sp[-1];                                                                         \
-    if (likely (JS_VALUE_IS_BOTH_INT (op1, op2))) {                                       \
-      sp[-2] = JS_NewBool (ctx, JS_VALUE_GET_INT (op1) binary_op JS_VALUE_GET_INT (op2)); \
-      sp--;                                                                               \
-    } else {                                                                              \
-      sf->cur_pc = pc;                                                                    \
-      if (slow_call) goto exception;                                                      \
-      sp--;                                                                               \
-    }                                                                                     \
-  }                                                                                       \
-  BREAK
-
-      OP_CMP (OP_lt, <, js_relational_slow (ctx, sp, opcode));
-      OP_CMP (OP_lte, <=, js_relational_slow (ctx, sp, opcode));
-      OP_CMP (OP_gt, >, js_relational_slow (ctx, sp, opcode));
-      OP_CMP (OP_gte, >=, js_relational_slow (ctx, sp, opcode));
-      OP_CMP (OP_strict_eq, ==, js_strict_eq_slow (ctx, sp, 0));
-      OP_CMP (OP_strict_neq, !=, js_strict_eq_slow (ctx, sp, 1));
-
-      CASE (OP_in) : sf->cur_pc = pc;
-      if (js_operator_in (ctx, sp)) goto exception;
-      sp--;
-      BREAK;
-      CASE (OP_delete) : sf->cur_pc = pc;
-      if (js_operator_delete (ctx, sp)) goto exception;
-      sp--;
-      BREAK;
-
-      CASE (OP_delete_var) :
-        pc += 4;
-        JS_ThrowInternalError (ctx, "OP_delete_var: global object is immutable");
-        goto exception;
-      BREAK;
-
-      CASE (OP_to_propkey) : switch (JS_VALUE_GET_TAG (sp[-1])) {
-      case JS_TAG_INT:
-      case JS_TAG_STRING:
-        break;
-      default:
-        sf->cur_pc = pc;
-        ret_val = sp[-1]; //  JS_ToPropertyKey (ctx, sp[-1]); // is this correct? No conversion can happen.
-        if (JS_IsException (ret_val)) goto exception;
-        sp[-1] = ret_val;
-        break;
-      }
-      BREAK;
-
-      CASE (OP_format_template) : {
-        int expr_count = get_u16 (pc); pc += 2;
-        uint32_t cpool_idx = get_u32 (pc); pc += 4;
-
-        /* Expression values are on the stack. We'll process them in place,
-           building the result string using pretext. */
-        JSText *result = pretext_init (ctx, 64);
-        if (!result) goto exception;
-
-        /* Re-read format_str after pretext_init (may have triggered GC) */
-        JSValue format_str = b->cpool[cpool_idx];
-
-        /* Parse format string and substitute {N} with stringified stack values.
-           Format string is like "hello {0} world {1}" for `hello ${a} world ${b}`.
-           Each {N} refers to stack value at position N (0-indexed from base). */
-        JSValue *expr_base = sp - expr_count;
-        int fmt_len = js_string_value_len (format_str);
-        int pos = 0;
-
-        while (pos < fmt_len) {
-          /* Re-read format_str in case GC moved the cpool entry */
-          format_str = b->cpool[cpool_idx];
-
-          /* Find next '{' */
-          int brace_start = -1;
-          for (int i = pos; i < fmt_len; i++) {
-            if (js_string_value_get (format_str, i) == '{') {
-              brace_start = i;
-              break;
-            }
-          }
-
-          if (brace_start < 0) {
-            /* No more braces, copy rest of string */
-            format_str = b->cpool[cpool_idx];  /* Re-read */
-            for (int i = pos; i < fmt_len; i++) {
-              result = pretext_putc (ctx, result, js_string_value_get (format_str, i));
-              if (!result) goto exception;
-            }
-            break;
-          }
-
-          /* Copy text before brace */
-          format_str = b->cpool[cpool_idx];  /* Re-read */
-          for (int i = pos; i < brace_start; i++) {
-            result = pretext_putc (ctx, result, js_string_value_get (format_str, i));
-            if (!result) goto exception;
-          }
-
-          /* Find closing '}' */
-          format_str = b->cpool[cpool_idx];  /* Re-read */
-          int brace_end = -1;
-          for (int i = brace_start + 1; i < fmt_len; i++) {
-            if (js_string_value_get (format_str, i) == '}') {
-              brace_end = i;
-              break;
-            }
-          }
-
-          if (brace_end < 0) {
-            /* No closing brace, copy '{' and continue */
-            result = pretext_putc (ctx, result, '{');
-            if (!result) goto exception;
-            pos = brace_start + 1;
-            continue;
-          }
-
-          /* Parse index from {N} */
-          int idx = 0;
-          format_str = b->cpool[cpool_idx];  /* Re-read */
-          for (int i = brace_start + 1; i < brace_end; i++) {
-            uint32_t c = js_string_value_get (format_str, i);
-            if (c >= '0' && c <= '9') {
-              idx = idx * 10 + (c - '0');
-            } else {
-              idx = -1;  /* Invalid */
-              break;
-            }
-          }
-
-          if (idx >= 0 && idx < expr_count) {
-            /* Valid index, stringify the stack value */
-            JSValue val = expr_base[idx];
-            JSValue str_val = JS_ToString (ctx, val);
-            if (JS_IsException (str_val)) {
-              goto exception;
-            }
-            /* Append stringified value to result */
-            int str_len = js_string_value_len (str_val);
-            for (int i = 0; i < str_len; i++) {
-              result = pretext_putc (ctx, result, js_string_value_get (str_val, i));
-              if (!result) goto exception;
-            }
-          } else {
-            /* Invalid index, keep original {N} */
-            format_str = b->cpool[cpool_idx];  /* Re-read */
-            for (int i = brace_start; i <= brace_end; i++) {
-              result = pretext_putc (ctx, result, js_string_value_get (format_str, i));
-              if (!result) goto exception;
-            }
-          }
-
-          pos = brace_end + 1;
-        }
-
-        /* Finalize result string */
-        JSValue result_str = pretext_end (ctx, result);
-        if (JS_IsException (result_str)) goto exception;
-
-        /* Pop expr values, push result */
-        sp -= expr_count;
-        *sp++ = result_str;
-      }
-      BREAK;
-
-      /* Upvalue access via outer_frame chain (Phase 5) */
-      CASE (OP_get_up) : {
-        int depth = *pc++;
-        int slot = get_u16 (pc); pc += 2;
-        JSValue *p = get_upvalue_ptr(sf->js_frame, depth, slot);
-        if (!p) {
-          JS_ThrowInternalError(ctx, "invalid upvalue: depth=%d slot=%d", depth, slot);
-          goto exception;
-        }
-        *sp++ = *p;
-      }
-      BREAK;
-
-      CASE (OP_set_up) : {
-        int depth = *pc++;
-        int slot = get_u16 (pc); pc += 2;
-        JSValue *p = get_upvalue_ptr(sf->js_frame, depth, slot);
-        if (!p) {
-          JS_ThrowInternalError(ctx, "invalid upvalue: depth=%d slot=%d", depth, slot);
-          goto exception;
-        }
-        *p = *--sp;
-      }
-      BREAK;
-
-      /* Name resolution with bytecode patching (Phase 6) */
-      CASE (OP_get_name) : {
-        uint32_t idx = get_u32 (pc); pc += 4;
-        (void)idx;
-        JS_ThrowInternalError (ctx, "OP_get_name not yet implemented");
-        goto exception;
-      }
-      BREAK;
-
-      CASE (OP_get_env_slot) : {
-        int slot = get_u16 (pc); pc += 2;
-        /* Get env_record from current function, not global ctx->eval_env */
-        JSFunction *fn = JS_VALUE_GET_FUNCTION (sf->cur_func);
-        JSValue env_val = fn->u.func.env_record;
-        if (JS_IsNull (env_val)) {
-          JS_ThrowReferenceError (ctx, "no environment record");
-          goto exception;
-        }
-        JSRecord *env = (JSRecord *)JS_VALUE_GET_OBJ (env_val);
-        *sp++ = env->slots[slot].val;
-      }
-      BREAK;
-
-      CASE (OP_set_env_slot) : {
-        int slot = get_u16 (pc); pc += 2;
-        /* Get env_record from current function */
-        JSFunction *fn = JS_VALUE_GET_FUNCTION (sf->cur_func);
-        JSValue env_val = fn->u.func.env_record;
-        if (JS_IsNull (env_val)) {
-          JS_ThrowReferenceError (ctx, "no environment record");
-          goto exception;
-        }
-        JSRecord *env = (JSRecord *)JS_VALUE_GET_OBJ (env_val);
-        env->slots[slot].val = *--sp;
-      }
-      BREAK;
-
-      CASE (OP_get_global_slot) : {
-        int slot = get_u16 (pc); pc += 2;
-        JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-        *sp++ = global->slots[slot].val;
-      }
-      BREAK;
-
-      CASE (OP_set_global_slot) : {
-        int slot = get_u16 (pc); pc += 2;
-        JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-        global->slots[slot].val = *--sp;
-      }
-      BREAK;
-
-      CASE (OP_nop) : BREAK;
-      CASE (OP_is_null) : if (JS_VALUE_GET_TAG (sp[-1]) == JS_TAG_NULL) {
-        goto set_true;
-      }
-      else { goto free_and_set_false; }
-    set_true:
-      sp[-1] = JS_TRUE;
-      BREAK;
-    free_and_set_false:
-      sp[-1] = JS_FALSE;
-      BREAK;
-      CASE (OP_invalid)
-          : DEFAULT
-          : JS_ThrowInternalError (ctx, "invalid opcode: pc=%u opcode=0x%02x", (int)(pc - b->byte_code_buf - 1), opcode);
-      goto exception;
-    }
-  }
-exception:
-  if (is_backtrace_needed (ctx, ctx->current_exception)) {
-    /* add the backtrace information now (it is not done
-       before if the exception happens in a bytecode
-       operation */
-    sf->cur_pc = pc;
-    build_backtrace (ctx, ctx->current_exception, NULL, 0, 0, 0);
-  }
-  /* All exceptions are catchable in the simplified runtime */
-  while (sp > stack_buf) {
-    JSValue val = *--sp;
-    if (JS_VALUE_GET_TAG (val) == JS_TAG_CATCH_OFFSET) {
-      int pos = JS_VALUE_GET_INT (val);
-      if (pos != 0) {
-        *sp++ = ctx->current_exception;
-        ctx->current_exception = JS_UNINITIALIZED;
-        pc = b->byte_code_buf + pos;
-        goto restart;
-      }
-    }
-  }
-  ret_val = JS_EXCEPTION;
-done:
-  ctx->current_stack_frame = sf->prev_frame;
-
-  if (unlikely (caller_ctx->trace_hook)
-      && (caller_ctx->trace_type & JS_HOOK_RET))
-    caller_ctx->trace_hook (caller_ctx, JS_HOOK_RET, NULL, caller_ctx->trace_data);
-
-  return ret_val;
-}
-
-/* JS parser */
-
-
-/* Map token values to kind strings for tokenizer output */
-
-typedef struct BlockEnv {
-  struct BlockEnv *prev;
-  JSValue label_name; /* JS_NULL if none */
-  int label_break;    /* -1 if none */
-  int label_cont;     /* -1 if none */
-  int drop_count;     /* number of stack elements to drop */
-  int label_finally;  /* -1 if none */
-  int scope_level;
-  uint8_t is_regular_stmt : 1; /* i.e. not a loop statement */
-} BlockEnv;
-
-typedef struct JSGlobalVar {
-  int cpool_idx;          /* if >= 0, index in the constant pool for hoisted
-                             function defintion*/
-  uint8_t force_init : 1; /* force initialization to undefined */
-  uint8_t is_lexical : 1; /* global let/const definition */
-  uint8_t is_const : 1;   /* const definition */
-  int scope_level;        /* scope of definition */
-  JSValue var_name;       /* variable name as JSValue text */
-} JSGlobalVar;
-
-typedef struct RelocEntry {
-  struct RelocEntry *next;
-  uint32_t addr; /* address to patch */
-  int size;      /* address size: 1, 2 or 4 bytes */
-} RelocEntry;
-
-typedef struct JumpSlot {
-  int op;
-  int size;
-  int pos;
-  int label;
-} JumpSlot;
-
-typedef struct LabelSlot {
-  int ref_count;
-  int pos;  /* phase 1 address, -1 means not resolved yet */
-  int pos2; /* phase 2 address, -1 means not resolved yet */
-  int addr; /* phase 3 address, -1 means not resolved yet */
-  RelocEntry *first_reloc;
-} LabelSlot;
-
-typedef struct LineNumberSlot {
-  uint32_t pc;
-  uint32_t source_pos;
-} LineNumberSlot;
-
-
-typedef enum JSParseFunctionEnum {
-  JS_PARSE_FUNC_STATEMENT,
-  JS_PARSE_FUNC_VAR,
-  JS_PARSE_FUNC_EXPR,
-  JS_PARSE_FUNC_ARROW,
-  JS_PARSE_FUNC_GETTER,
-  JS_PARSE_FUNC_SETTER,
-  JS_PARSE_FUNC_METHOD,
-  JS_PARSE_FUNC_CLASS_STATIC_INIT,
-} JSParseFunctionEnum;
-
-typedef struct JSFunctionDef {
-  JSContext *ctx;
-  struct JSFunctionDef *parent;
-  int parent_cpool_idx;        /* index in the constant pool of the parent
-                                  or -1 if none */
-  int parent_scope_level;      /* scope level in parent at point of definition */
-  struct list_head child_list; /* list of JSFunctionDef.link */
-  struct list_head link;
-
-  BOOL is_global_var; /* TRUE if variables are not defined locally */
-  BOOL is_func_expr;  /* TRUE if function expression */
-  BOOL has_prototype; /* true if a prototype field is necessary */
-  BOOL has_simple_parameter_list;
-  BOOL has_parameter_expressions; /* if true, an argument scope is created */
-  BOOL has_use_strict;            /* to reject directive in special cases */
-  BOOL has_this_binding;          /* true if the 'this' binding is available in the
-                                     function */
-  BOOL in_function_body;
-  JSParseFunctionEnum func_type : 8;
-  uint8_t js_mode;   /* bitmap of JS_MODE_x */
-  JSValue func_name; /* JS_NULL if no name */
-
-  JSVarDef *vars;
-  int var_size; /* allocated size for vars[] */
-  int var_count;
-  JSVarDef *args;
-  int arg_size;  /* allocated size for args[] */
-  int arg_count; /* number of arguments */
-  int defined_arg_count;
-  int var_object_idx;           /* -1 if none */
-  int arg_var_object_idx;       /* -1 if none (var object for the argument scope) */
-  int func_var_idx;             /* variable containing the current function (-1
-                                   if none, only used if is_func_expr is true) */
-  int this_var_idx;             /* variable containg the 'this' value, -1 if none */
-  int this_active_func_var_idx; /* variable containg the 'this.active_func'
-                                   value, -1 if none */
-
-  int scope_level; /* index into fd->scopes if the current lexical scope */
-  int scope_first; /* index into vd->vars of first lexically scoped variable */
-  int scope_size;  /* allocated size of fd->scopes array */
-  int scope_count; /* number of entries used in the fd->scopes array */
-  JSVarScope *scopes;
-  JSVarScope def_scope_array[4];
-  int body_scope; /* scope of the body of the function or eval */
-
-  int global_var_count;
-  int global_var_size;
-  JSGlobalVar *global_vars;
-
-  DynBuf byte_code;
-  int last_opcode_pos; /* -1 if no last opcode */
-  const uint8_t *last_opcode_source_ptr;
-  BOOL use_short_opcodes; /* true if short opcodes are used in byte_code */
-
-  LabelSlot *label_slots;
-  int label_size; /* allocated size for label_slots[] */
-  int label_count;
-  BlockEnv *top_break; /* break/continue label stack */
-
-  /* constant pool (strings, functions, numbers) */
-  JSValue *cpool;
-  int cpool_count;
-  int cpool_size;
-
-  /* list of variables in the closure */
-  int closure_var_count;
-  int closure_var_size;
-  JSClosureVar *closure_var;
-
-  JumpSlot *jump_slots;
-  int jump_size;
-  int jump_count;
-
-  LineNumberSlot *line_number_slots;
-  int line_number_size;
-  int line_number_count;
-  int line_number_last;
-  int line_number_last_pc;
-
-  /* pc2line table */
-  BOOL strip_debug
-    : 1;                 /* strip all debug info (implies strip_source = TRUE) */
-  BOOL strip_source : 1; /* strip only source code */
-  JSValue filename;
-  uint32_t source_pos;                 /* pointer in the eval() source */
-  GetLineColCache *get_line_col_cache; /* XXX: could remove to save memory */
-  DynBuf pc2line;
-
-  char *source; /* raw source, utf-8 encoded */
-  int source_len;
-} JSFunctionDef;
-
-/* Scan a single JSFunctionDef's cpool and recursively scan its children */
-void gc_scan_parser_fd (JSContext *ctx, JSFunctionDef *fd,
-                               uint8_t *from_base, uint8_t *from_end,
-                               uint8_t *to_base, uint8_t **to_free, uint8_t *to_end) {
-  if (!fd) return;
-  /* Scan constant pool */
-  for (int i = 0; i < fd->cpool_count; i++) {
-    fd->cpool[i] = gc_copy_value (ctx, fd->cpool[i], from_base, from_end, to_base, to_free, to_end);
-  }
-  /* Scan func_name */
-  fd->func_name = gc_copy_value (ctx, fd->func_name, from_base, from_end, to_base, to_free, to_end);
-  /* Scan filename */
-  fd->filename = gc_copy_value (ctx, fd->filename, from_base, from_end, to_base, to_free, to_end);
-  /* Recursively scan child functions */
-  struct list_head *el;
-  list_for_each (el, &fd->child_list) {
-    JSFunctionDef *child = list_entry (el, JSFunctionDef, link);
-    gc_scan_parser_fd (ctx, child, from_base, from_end, to_base, to_free, to_end);
-  }
-}
-
-/* Scan parser's cpool values during GC - called when parsing is in progress */
-void gc_scan_parser_cpool (JSContext *ctx, uint8_t *from_base, uint8_t *from_end,
-                                  uint8_t *to_base, uint8_t **to_free, uint8_t *to_end) {
-  gc_scan_parser_fd (ctx, ctx->current_parse_fd, from_base, from_end, to_base, to_free, to_end);
-}
-
-typedef struct JSToken {
-  int val;
-  const uint8_t *ptr; /* position in the source */
-  union {
-    struct {
-      JSValue str;
-      int sep;
-    } str;
-    struct {
-      JSValue val;
-    } num;
-    struct {
-      JSValue str; /* identifier as JSValue text */
-      BOOL has_escape;
-      BOOL is_reserved;
-    } ident;
-    struct {
-      JSValue body;
-      JSValue flags;
-    } regexp;
-  } u;
-} JSToken;
-
-typedef struct JSParseState {
-  JSContext *ctx;
-  const char *filename;
-  JSToken token;
-  BOOL got_lf; /* true if got line feed before the current token */
-  const uint8_t *last_ptr;
-  const uint8_t *buf_start;
-  const uint8_t *buf_ptr;
-  const uint8_t *buf_end;
-
-  /* current function code */
-  JSFunctionDef *cur_func;
-  BOOL ext_json; /* true if accepting JSON superset */
-  GetLineColCache get_line_col_cache;
-} JSParseState;
-
-
-/* Clone bytecode and resolve OP_get_var to OP_get_global_slot.
-   Returns new bytecode on success, NULL on link error.
-   The linked bytecode is a separate allocation that can be modified.
-   Note: closure_var is not copied - closures use outer_frame chain at runtime. */
-JSFunctionBytecode *js_link_bytecode (JSContext *ctx,
-                                              JSFunctionBytecode *tpl,
-                                              JSValue env) {
-  /* Calculate total size of bytecode allocation */
-  int function_size;
-  int cpool_offset, vardefs_offset, byte_code_offset;
-
-  if (tpl->has_debug) {
-    function_size = sizeof (JSFunctionBytecode);
-  } else {
-    function_size = offsetof (JSFunctionBytecode, debug);
-  }
-
-  cpool_offset = function_size;
-  function_size += tpl->cpool_count * sizeof (JSValue);
-
-  vardefs_offset = function_size;
-  if (tpl->vardefs) {
-    function_size += (tpl->arg_count + tpl->var_count) * sizeof (JSVarDef);
-  }
-
-  /* closure_var not needed at runtime - closures use outer_frame chain */
-
-  byte_code_offset = function_size;
-  function_size += tpl->byte_code_len;
-
-  /* Allocate and copy */
-  JSFunctionBytecode *linked = pjs_malloc (function_size);
-  if (!linked) return NULL;
-
-  /* Copy base structure */
-  if (tpl->has_debug) {
-    memcpy (linked, tpl, sizeof (JSFunctionBytecode));
-  } else {
-    memcpy (linked, tpl, offsetof (JSFunctionBytecode, debug));
-  }
-
-  /* Clear closure_var - not needed at runtime */
-  linked->closure_var = NULL;
-  linked->closure_var_count = 0;
-
-  /* Fix up self pointers */
-  if (tpl->cpool_count > 0) {
-    linked->cpool = (JSValue *)((uint8_t *)linked + cpool_offset);
-    memcpy (linked->cpool, tpl->cpool, tpl->cpool_count * sizeof (JSValue));
-  }
-
-  if (tpl->vardefs) {
-    linked->vardefs = (JSVarDef *)((uint8_t *)linked + vardefs_offset);
-    memcpy (linked->vardefs, tpl->vardefs,
-            (tpl->arg_count + tpl->var_count) * sizeof (JSVarDef));
-  }
-
-  linked->byte_code_buf = (uint8_t *)linked + byte_code_offset;
-  memcpy (linked->byte_code_buf, tpl->byte_code_buf, tpl->byte_code_len);
-
-  /* Mark as writable (for patching) */
-  linked->read_only_bytecode = 0;
-
-  /* Walk bytecode and patch global variable access opcodes */
-  uint8_t *bc = linked->byte_code_buf;
-  int pos = 0;
-
-  /* Get env record if provided */
-  JSRecord *env_rec = NULL;
-  if (!JS_IsNull (env) && JS_IsRecord (env)) {
-    env_rec = (JSRecord *)JS_VALUE_GET_OBJ (env);
-  }
-
-  while (pos < linked->byte_code_len) {
-    uint8_t op = bc[pos];
-    int len = short_opcode_info (op).size;
-
-    /* Patch OP_get_var -> OP_get_global_slot or OP_get_env_slot */
-    if (op == OP_get_var || op == OP_get_var_undef) {
-      uint32_t cpool_idx = get_u32 (bc + pos + 1);
-      JSValue name = linked->cpool[cpool_idx];
-
-      /* Try env first (if provided) */
-      if (env_rec) {
-        int slot = rec_find_slot (env_rec, name);
-        if (slot > 0) {
-          bc[pos] = OP_get_env_slot;
-          put_u16 (bc + pos + 1, (uint16_t)slot);
-          bc[pos + 3] = OP_nop;
-          bc[pos + 4] = OP_nop;
-          pos += len;
-          continue;
-        }
-      }
-
-      /* Try global_obj (intrinsics like 'print') */
-      JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-      int slot = rec_find_slot (global, name);
-      if (slot > 0) {
-        bc[pos] = OP_get_global_slot;
-        put_u16 (bc + pos + 1, (uint16_t)slot);
-        bc[pos + 3] = OP_nop;
-        bc[pos + 4] = OP_nop;
-        pos += len;
-        continue;
-      }
-
-      /* Link error: variable not found */
-      if (op == OP_get_var) {
-        char buf[64];
-        JS_ThrowReferenceError (ctx, "'%s' is not defined",
-                                JS_KeyGetStr (ctx, buf, sizeof (buf), name));
-        pjs_free (linked);
-        return NULL;
-      }
-      /* OP_get_var_undef is ok - leaves as is for runtime check */
-    }
-
-    /* Patch OP_put_var family -> OP_set_env_slot or error */
-    if (op == OP_put_var || op == OP_put_var_init || op == OP_put_var_strict) {
-      uint32_t cpool_idx = get_u32 (bc + pos + 1);
-      JSValue name = linked->cpool[cpool_idx];
-
-      /* Try env first (if provided) - env is writable */
-      if (env_rec) {
-        int slot = rec_find_slot (env_rec, name);
-        if (slot > 0) {
-          bc[pos] = OP_set_env_slot;
-          put_u16 (bc + pos + 1, (uint16_t)slot);
-          bc[pos + 3] = OP_nop;
-          bc[pos + 4] = OP_nop;
-          pos += len;
-          continue;
-        }
-      }
-
-      /* Try global for set_global_slot */
-      JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-      int slot = rec_find_slot (global, name);
-      if (slot > 0) {
-        bc[pos] = OP_set_global_slot;
-        put_u16 (bc + pos + 1, (uint16_t)slot);
-        bc[pos + 3] = OP_nop;
-        bc[pos + 4] = OP_nop;
-        pos += len;
-        continue;
-      }
-
-      /* Global object is immutable - can't write to intrinsics */
-      char buf[64];
-      JS_ThrowReferenceError (ctx, "cannot assign to '%s' - not found in environment",
-                              JS_KeyGetStr (ctx, buf, sizeof (buf), name));
-      pjs_free (linked);
-      return NULL;
-    }
-
-    /* Patch OP_check_var -> OP_nop (if variable exists) */
-    if (op == OP_check_var) {
-      uint32_t cpool_idx = get_u32 (bc + pos + 1);
-      JSValue name = linked->cpool[cpool_idx];
-
-      BOOL found = FALSE;
-      if (env_rec && rec_find_slot (env_rec, name) > 0) {
-        found = TRUE;
-      }
-      if (!found) {
-        JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-        if (rec_find_slot (global, name) > 0) {
-          found = TRUE;
-        }
-      }
-
-      if (found) {
-        /* Variable exists, replace with NOPs */
-        bc[pos] = OP_nop;
-        bc[pos + 1] = OP_nop;
-        bc[pos + 2] = OP_nop;
-        bc[pos + 3] = OP_nop;
-        bc[pos + 4] = OP_nop;
-      }
-      /* else leave check_var for runtime */
-    }
-
-    pos += len;
-  }
-
-  return linked;
-}
-
-/* New simplified linker producing JSCompiledUnit.
-   Converts JSFunctionBytecode template to JSCompiledUnit:
-   - Copies bytecode, cpool (no vardefs, no closure_var)
-   - Patches OP_get_var -> OP_get_env_slot or OP_get_global_slot
-   - Returns standalone unit ready for execution */
-static JSCompiledUnit *js_link_unit (JSContext *ctx,
-                                      JSFunctionBytecode *tpl,
-                                      JSValue env) {
-  int function_size;
-  int cpool_offset, byte_code_offset;
-
-  /* Calculate size: base struct + cpool + bytecode */
-  if (tpl->has_debug) {
-    function_size = sizeof (JSCompiledUnit);
-  } else {
-    function_size = offsetof (JSCompiledUnit, debug);
-  }
-
-  cpool_offset = function_size;
-  function_size += tpl->cpool_count * sizeof (JSValue);
-
-  byte_code_offset = function_size;
-  function_size += tpl->byte_code_len;
-
-  /* Allocate */
-  JSCompiledUnit *unit = pjs_malloc (function_size);
-  if (!unit) return NULL;
-
-  /* Initialize header */
-  unit->header = objhdr_make (0, OBJ_CODE, false, false, false, false);
-  unit->has_debug = tpl->has_debug;
-  unit->read_only_bytecode = 0;
-
-  /* Copy stack requirements */
-  unit->local_count = tpl->arg_count + tpl->var_count;
-  unit->stack_size = tpl->stack_size;
-
-  /* Setup cpool */
-  unit->cpool_count = tpl->cpool_count;
-  if (tpl->cpool_count > 0) {
-    unit->cpool = (JSValue *)((uint8_t *)unit + cpool_offset);
-    memcpy (unit->cpool, tpl->cpool, tpl->cpool_count * sizeof (JSValue));
-  } else {
-    unit->cpool = NULL;
-  }
-
-  /* Copy bytecode */
-  unit->byte_code_buf = (uint8_t *)unit + byte_code_offset;
-  unit->byte_code_len = tpl->byte_code_len;
-  memcpy (unit->byte_code_buf, tpl->byte_code_buf, tpl->byte_code_len);
-
-  /* Copy debug info if present */
-  if (tpl->has_debug) {
-    unit->debug.filename = tpl->debug.filename;
-    unit->debug.source_len = tpl->debug.source_len;
-    unit->debug.pc2line_len = tpl->debug.pc2line_len;
-    unit->debug.pc2line_buf = tpl->debug.pc2line_buf;
-    unit->debug.source = tpl->debug.source;
-  }
-
-  /* Walk bytecode and patch global variable access opcodes */
-  uint8_t *bc = unit->byte_code_buf;
-  int pos = 0;
-
-  /* Get env record if provided */
-  JSRecord *env_rec = NULL;
-  if (!JS_IsNull (env) && JS_IsRecord (env)) {
-    env_rec = (JSRecord *)JS_VALUE_GET_OBJ (env);
-  }
-
-  while (pos < unit->byte_code_len) {
-    uint8_t op = bc[pos];
-    int len = short_opcode_info (op).size;
-
-    /* Patch OP_get_var -> OP_get_global_slot or OP_get_env_slot */
-    if (op == OP_get_var || op == OP_get_var_undef) {
-      uint32_t cpool_idx = get_u32 (bc + pos + 1);
-      JSValue name = unit->cpool[cpool_idx];
-
-      /* Try env first (if provided) */
-      if (env_rec) {
-        int slot = rec_find_slot (env_rec, name);
-        if (slot > 0) {
-          bc[pos] = OP_get_env_slot;
-          put_u16 (bc + pos + 1, (uint16_t)slot);
-          bc[pos + 3] = OP_nop;
-          bc[pos + 4] = OP_nop;
-          pos += len;
-          continue;
-        }
-      }
-
-      /* Try global_obj (intrinsics like 'print') */
-      JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-      int slot = rec_find_slot (global, name);
-      if (slot > 0) {
-        bc[pos] = OP_get_global_slot;
-        put_u16 (bc + pos + 1, (uint16_t)slot);
-        bc[pos + 3] = OP_nop;
-        bc[pos + 4] = OP_nop;
-        pos += len;
-        continue;
-      }
-
-      /* Link error: variable not found */
-      if (op == OP_get_var) {
-        char buf[64];
-        JS_ThrowReferenceError (ctx, "'%s' is not defined",
-                                JS_KeyGetStr (ctx, buf, sizeof (buf), name));
-        pjs_free (unit);
-        return NULL;
-      }
-    }
-
-    /* Patch OP_put_var family -> error (global is immutable) */
-    if (op == OP_put_var || op == OP_put_var_init || op == OP_put_var_strict) {
-      uint32_t cpool_idx = get_u32 (bc + pos + 1);
-      JSValue name = unit->cpool[cpool_idx];
-      char buf[64];
-      JS_ThrowReferenceError (ctx, "cannot assign to '%s' - global object is immutable",
-                              JS_KeyGetStr (ctx, buf, sizeof (buf), name));
-      pjs_free (unit);
-      return NULL;
-    }
-
-    /* Patch OP_check_var -> OP_nop (if variable exists) */
-    if (op == OP_check_var) {
-      uint32_t cpool_idx = get_u32 (bc + pos + 1);
-      JSValue name = unit->cpool[cpool_idx];
-
-      BOOL found = FALSE;
-      if (env_rec && rec_find_slot (env_rec, name) > 0) {
-        found = TRUE;
-      }
-      if (!found) {
-        JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-        if (rec_find_slot (global, name) > 0) {
-          found = TRUE;
-        }
-      }
-
-      if (found) {
-        bc[pos] = OP_nop;
-        bc[pos + 1] = OP_nop;
-        bc[pos + 2] = OP_nop;
-        bc[pos + 3] = OP_nop;
-        bc[pos + 4] = OP_nop;
-      }
-    }
-
-    pos += len;
-  }
-
-  return unit;
-}
-
-static __exception int next_token (JSParseState *s);
-
-static void free_token (JSParseState *s, JSToken *token) {
-  switch (token->val) {
-  case TOK_NUMBER:
-    break;
-  case TOK_STRING:
-  case TOK_TEMPLATE:
-    break;
-  case TOK_REGEXP:
-    break;
-  case TOK_IDENT:
-    break;
-  default:
-    if (token->val >= TOK_FIRST_KEYWORD && token->val <= TOK_LAST_KEYWORD) {
-    }
-    break;
-  }
-}
-
-static void __attribute ((unused)) dump_token (JSParseState *s,
-                                               const JSToken *token) {
-  switch (token->val) {
-  case TOK_NUMBER: {
-    double d;
-    JS_ToFloat64 (s->ctx, &d, token->u.num.val); /* no exception possible */
-    printf ("number: %.14g\n", d);
-  } break;
-  case TOK_IDENT:
-  dump_ident: {
-    const char *str = JS_ToCString (s->ctx, token->u.ident.str);
-    printf ("ident: '%s'\n", str ? str : "<null>");
-    JS_FreeCString (s->ctx, str);
-  } break;
-  case TOK_STRING: {
-    const char *str;
-    /* XXX: quote the string */
-    str = JS_ToCString (s->ctx, token->u.str.str);
-    printf ("string: '%s'\n", str);
-    JS_FreeCString (s->ctx, str);
-  } break;
-  case TOK_TEMPLATE: {
-    const char *str;
-    str = JS_ToCString (s->ctx, token->u.str.str);
-    printf ("template: `%s`\n", str);
-    JS_FreeCString (s->ctx, str);
-  } break;
-  case TOK_REGEXP: {
-    const char *str, *str2;
-    str = JS_ToCString (s->ctx, token->u.regexp.body);
-    str2 = JS_ToCString (s->ctx, token->u.regexp.flags);
-    printf ("regexp: '%s' '%s'\n", str, str2);
-    JS_FreeCString (s->ctx, str);
-    JS_FreeCString (s->ctx, str2);
-  } break;
-  case TOK_EOF:
-    printf ("eof\n");
-    break;
-  default:
-    if (s->token.val >= TOK_NULL && s->token.val <= TOK_LAST_KEYWORD) {
-      goto dump_ident;
-    } else if (s->token.val >= 256) {
-      printf ("token: %d\n", token->val);
-    } else {
-      printf ("token: '%c'\n", token->val);
-    }
-    break;
-  }
-}
-
-/* return the zero based line and column number in the source. */
-/* Note: we no longer support '\r' as line terminator */
-int get_line_col (int *pcol_num, const uint8_t *buf, size_t len) {
-  int line_num, col_num, c;
-  size_t i;
-
-  line_num = 0;
-  col_num = 0;
-  for (i = 0; i < len; i++) {
-    c = buf[i];
-    if (c == '\n') {
-      line_num++;
-      col_num = 0;
-    } else if (c < 0x80 || c >= 0xc0) {
-      col_num++;
-    }
-  }
-  *pcol_num = col_num;
-  return line_num;
-}
-
-int get_line_col_cached (GetLineColCache *s, int *pcol_num, const uint8_t *ptr) {
-  int line_num, col_num;
-  if (ptr >= s->ptr) {
-    line_num = get_line_col (&col_num, s->ptr, ptr - s->ptr);
-    if (line_num == 0) {
-      s->col_num += col_num;
-    } else {
-      s->line_num += line_num;
-      s->col_num = col_num;
-    }
-  } else {
-    line_num = get_line_col (&col_num, ptr, s->ptr - ptr);
-    if (line_num == 0) {
-      s->col_num -= col_num;
-    } else {
-      const uint8_t *p;
-      s->line_num -= line_num;
-      /* find the absolute column position */
-      col_num = 0;
-      for (p = ptr - 1; p >= s->buf_start; p--) {
-        if (*p == '\n') {
-          break;
-        } else if (*p < 0x80 || *p >= 0xc0) {
-          col_num++;
-        }
-      }
-      s->col_num = col_num;
-    }
-  }
-  s->ptr = ptr;
-  *pcol_num = s->col_num;
-  return s->line_num;
-}
-
-/* 'ptr' is the position of the error in the source */
-static int js_parse_error_v (JSParseState *s, const uint8_t *ptr, const char *fmt, va_list ap) {
-  JSContext *ctx = s->ctx;
-  int line_num, col_num;
-  line_num = get_line_col (&col_num, s->buf_start, ptr - s->buf_start);
-  JS_ThrowError2 (ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
-  build_backtrace (ctx, ctx->current_exception, s->filename, line_num + 1, col_num + 1, 0);
-  return -1;
-}
-
-static __attribute__ ((format (printf, 3, 4))) int
-js_parse_error_pos (JSParseState *s, const uint8_t *ptr, const char *fmt, ...) {
-  va_list ap;
-  int ret;
-
-  va_start (ap, fmt);
-  ret = js_parse_error_v (s, ptr, fmt, ap);
-  va_end (ap);
-  return ret;
-}
-
-static __attribute__ ((format (printf, 2, 3))) int
-js_parse_error (JSParseState *s, const char *fmt, ...) {
-  va_list ap;
-  int ret;
-
-  va_start (ap, fmt);
-  ret = js_parse_error_v (s, s->token.ptr, fmt, ap);
-  va_end (ap);
-  return ret;
-}
-
-static int js_parse_expect (JSParseState *s, int tok) {
-  if (s->token.val != tok) {
-    /* XXX: dump token correctly in all cases */
-    return js_parse_error (s, "expecting '%c'", tok);
-  }
-  return next_token (s);
-}
-
-static int js_parse_expect_semi (JSParseState *s) {
-  if (s->token.val != ';') {
-    /* automatic insertion of ';' */
-    if (s->token.val == TOK_EOF || s->token.val == '}' || s->got_lf
-        || s->token.val == TOK_ELSE) {
-      return 0;
-    }
-    return js_parse_error (s, "expecting '%c'", ';');
-  }
-  return next_token (s);
-}
-
-static int js_parse_error_reserved_identifier (JSParseState *s) {
-  char buf1[KEY_GET_STR_BUF_SIZE];
-  return js_parse_error (
-    s, "'%s' is a reserved identifier", JS_KeyGetStr (s->ctx, buf1, sizeof (buf1), s->token.u.ident.str));
-}
-
-static __exception int js_parse_template_part (JSParseState *s,
-                                               const uint8_t *p) {
-  uint32_t c;
-  PPretext *b;
-  JSValue str;
-
-  /* p points to the first byte of the template part */
-  b = ppretext_init (32);
-  if (!b) goto fail;
-  for (;;) {
-    if (p >= s->buf_end) goto unexpected_eof;
-    c = *p++;
-    if (c == '`') {
-      /* template end part */
-      break;
-    }
-    if (c == '$' && *p == '{') {
-      /* template start or middle part */
-      p++;
-      break;
-    }
-    if (c == '\\') {
-      b = ppretext_putc (b, c);
-      if (!b) goto fail;
-      if (p >= s->buf_end) goto unexpected_eof;
-      c = *p++;
-    }
-    /* newline sequences are normalized as single '\n' bytes */
-    if (c == '\r') {
-      if (*p == '\n') p++;
-      c = '\n';
-    }
-    if (c >= 0x80) {
-      const uint8_t *p_next;
-      c = unicode_from_utf8 (p - 1, UTF8_CHAR_LEN_MAX, &p_next);
-      if (c > 0x10FFFF) {
-        js_parse_error_pos (s, p - 1, "invalid UTF-8 sequence");
-        goto fail;
-      }
-      p = p_next;
-    }
-    b = ppretext_putc (b, c);
-    if (!b) goto fail;
-  }
-  str = ppretext_end (s->ctx, b);
-  if (JS_IsException (str)) return -1;
-  s->token.val = TOK_TEMPLATE;
-  s->token.u.str.sep = c;
-  s->token.u.str.str = str;
-  s->buf_ptr = p;
-  return 0;
-
-unexpected_eof:
-  js_parse_error (s, "unexpected end of string");
-fail:
-  ppretext_free (b);
-  return -1;
-}
-
-static __exception int js_parse_string (JSParseState *s, int sep, BOOL do_throw, const uint8_t *p, JSToken *token, const uint8_t **pp) {
-  int ret;
-  uint32_t c;
-  PPretext *b;
-  const uint8_t *p_escape;
-  JSValue str;
-
-  /* string */
-  b = ppretext_init (32);
-  if (!b) goto fail;
-  for (;;) {
-    if (p >= s->buf_end) goto invalid_char;
-    c = *p;
-    if (c < 0x20) {
-      if (sep == '`') {
-        if (c == '\r') {
-          if (p[1] == '\n') p++;
-          c = '\n';
-        }
-        /* do not update s->line_num */
-      } else if (c == '\n' || c == '\r')
-        goto invalid_char;
-    }
-    p++;
-    if (c == sep) break;
-    if (c == '$' && *p == '{' && sep == '`') {
-      /* template start or middle part */
-      p++;
-      break;
-    }
-    if (c == '\\') {
-      p_escape = p - 1;
-      c = *p;
-      /* XXX: need a specific JSON case to avoid
-         accepting invalid escapes */
-      switch (c) {
-      case '\0':
-        if (p >= s->buf_end) goto invalid_char;
-        p++;
-        break;
-      case '\'':
-      case '\"':
-      case '\\':
-        p++;
-        break;
-      case '\r': /* accept DOS and MAC newline sequences */
-        if (p[1] == '\n') { p++; }
-        /* fall thru */
-      case '\n':
-        /* ignore escaped newline sequence */
-        p++;
-        continue;
-      default:
-        if (c >= '0' && c <= '9') {
-          if (c == '0' && !(p[1] >= '0' && p[1] <= '9')) {
-            p++;
-            c = '\0';
-          } else {
-            if (c >= '8' || sep == '`') {
-              /* Note: according to ES2021, \8 and \9 are not
-                 accepted in strict mode or in templates. */
-              goto invalid_escape;
-            } else {
-              if (do_throw)
-                js_parse_error_pos (
-                  s, p_escape, "octal escape sequences are not allowed in strict mode");
-            }
-            goto fail;
-          }
-        } else if (c >= 0x80) {
-          const uint8_t *p_next;
-          c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p_next);
-          if (c > 0x10FFFF) { goto invalid_utf8; }
-          p = p_next;
-          /* LS or PS are skipped */
-          if (c == CP_LS || c == CP_PS) continue;
-        } else {
-          ret = lre_parse_escape (&p, TRUE);
-          if (ret == -1) {
-          invalid_escape:
-            if (do_throw)
-              js_parse_error_pos (
-                s, p_escape, "malformed escape sequence in string literal");
-            goto fail;
-          } else if (ret < 0) {
-            /* ignore the '\' (could output a warning) */
-            p++;
-          } else {
-            c = ret;
-          }
-        }
-        break;
-      }
-    } else if (c >= 0x80) {
-      const uint8_t *p_next;
-      c = unicode_from_utf8 (p - 1, UTF8_CHAR_LEN_MAX, &p_next);
-      if (c > 0x10FFFF) goto invalid_utf8;
-      p = p_next;
-    }
-    b = ppretext_putc (b, c);
-    if (!b) goto fail;
-  }
-  str = ppretext_end (s->ctx, b);
-  if (JS_IsException (str)) return -1;
-  token->val = TOK_STRING;
-  token->u.str.sep = c;
-  token->u.str.str = str;
-  *pp = p;
-  return 0;
-
-invalid_utf8:
-  if (do_throw) js_parse_error (s, "invalid UTF-8 sequence");
-  goto fail;
-invalid_char:
-  if (do_throw) js_parse_error (s, "unexpected end of string");
-fail:
-  ppretext_free (b);
-  return -1;
-}
-
-static inline BOOL token_is_pseudo_keyword (JSParseState *s, JSValue key) {
-  return s->token.val == TOK_IDENT && js_key_equal (s->token.u.ident.str, key)
-         && !s->token.u.ident.has_escape;
-}
-
-static __exception int js_parse_regexp (JSParseState *s) {
-  const uint8_t *p;
-  BOOL in_class;
-  PPretext *b = NULL;
-  PPretext *b2 = NULL;
-  uint32_t c;
-  JSValue body_str, flags_str;
-
-  p = s->buf_ptr;
-  p++;
-  in_class = FALSE;
-  b = ppretext_init (32);
-  if (!b) return -1;
-  b2 = ppretext_init (1);
-  if (!b2) goto fail;
-  for (;;) {
-    if (p >= s->buf_end) {
-    eof_error:
-      js_parse_error (s, "unexpected end of regexp");
-      goto fail;
-    }
-    c = *p++;
-    if (c == '\n' || c == '\r') {
-      goto eol_error;
-    } else if (c == '/') {
-      if (!in_class) break;
-    } else if (c == '[') {
-      in_class = TRUE;
-    } else if (c == ']') {
-      /* XXX: incorrect as the first character in a class */
-      in_class = FALSE;
-    } else if (c == '\\') {
-      b = ppretext_putc (b, c);
-      if (!b) goto fail;
-      c = *p++;
-      if (c == '\n' || c == '\r')
-        goto eol_error;
-      else if (c == '\0' && p >= s->buf_end)
-        goto eof_error;
-      else if (c >= 0x80) {
-        const uint8_t *p_next;
-        c = unicode_from_utf8 (p - 1, UTF8_CHAR_LEN_MAX, &p_next);
-        if (c > 0x10FFFF) { goto invalid_utf8; }
-        p = p_next;
-        if (c == CP_LS || c == CP_PS) goto eol_error;
-      }
-    } else if (c >= 0x80) {
-      const uint8_t *p_next;
-      c = unicode_from_utf8 (p - 1, UTF8_CHAR_LEN_MAX, &p_next);
-      if (c > 0x10FFFF) {
-      invalid_utf8:
-        js_parse_error_pos (s, p - 1, "invalid UTF-8 sequence");
-        goto fail;
-      }
-      /* LS or PS are considered as line terminator */
-      if (c == CP_LS || c == CP_PS) {
-      eol_error:
-        js_parse_error_pos (s, p - 1, "unexpected line terminator in regexp");
-        goto fail;
-      }
-      p = p_next;
-    }
-    b = ppretext_putc (b, c);
-    if (!b) goto fail;
-  }
-
-  /* flags */
-  for (;;) {
-    const uint8_t *p_next = p;
-    c = *p_next++;
-    if (c >= 0x80) {
-      c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p_next);
-      if (c > 0x10FFFF) {
-        p++;
-        goto invalid_utf8;
-      }
-    }
-    if (!lre_js_is_ident_next (c)) break;
-    b2 = ppretext_putc (b2, c);
-    if (!b2) goto fail;
-    p = p_next;
-  }
-
-  body_str = ppretext_end (s->ctx, b);
-  flags_str = ppretext_end (s->ctx, b2);
-  if (JS_IsException (body_str) || JS_IsException (flags_str)) {
-    return -1;
-  }
-  s->token.val = TOK_REGEXP;
-  s->token.u.regexp.body = body_str;
-  s->token.u.regexp.flags = flags_str;
-  s->buf_ptr = p;
-  return 0;
-fail:
-  ppretext_free (b);
-  ppretext_free (b2);
-  return -1;
-}
-
-static __exception int ident_realloc (JSContext *ctx, char **pbuf, size_t *psize, char *static_buf) {
-  (void)ctx; /* unused - uses system allocator */
-  char *buf, *new_buf;
-  size_t size, new_size;
-
-  buf = *pbuf;
-  size = *psize;
-  if (size >= (SIZE_MAX / 3) * 2)
-    new_size = SIZE_MAX;
-  else
-    new_size = size + (size >> 1);
-  if (buf == static_buf) {
-    new_buf = pjs_malloc (new_size);
-    if (!new_buf) return -1;
-    memcpy (new_buf, buf, size);
-  } else {
-    new_buf = pjs_realloc (buf, new_size);
-    if (!new_buf) return -1;
-  }
-  *pbuf = new_buf;
-  *psize = new_size;
-  return 0;
-}
-
-/* keyword lookup table */
-typedef struct {
-  const char *name;
-  int token;
-  BOOL is_strict_reserved; /* TRUE if reserved only in strict mode */
-} JSKeywordEntry;
-
-static const JSKeywordEntry js_keywords[] = {
-  { "null", TOK_NULL, FALSE },
-  { "false", TOK_FALSE, FALSE },
-  { "true", TOK_TRUE, FALSE },
-  { "if", TOK_IF, FALSE },
-  { "else", TOK_ELSE, FALSE },
-  { "return", TOK_RETURN, FALSE },
-  { "go", TOK_GO, FALSE },
-  { "var", TOK_VAR, FALSE },
-  { "def", TOK_DEF, FALSE },
-  { "this", TOK_THIS, FALSE },
-  { "delete", TOK_DELETE, FALSE },
-  { "in", TOK_IN, FALSE },
-  { "do", TOK_DO, FALSE },
-  { "while", TOK_WHILE, FALSE },
-  { "for", TOK_FOR, FALSE },
-  { "break", TOK_BREAK, FALSE },
-  { "continue", TOK_CONTINUE, FALSE },
-  { "disrupt", TOK_DISRUPT, FALSE },
-  { "disruption", TOK_DISRUPTION, FALSE },
-  { "function", TOK_FUNCTION, FALSE },
-  { "debugger", TOK_DEBUGGER, FALSE },
-  { "with", TOK_WITH, FALSE },
-  { "class", TOK_CLASS, FALSE },
-  { "const", TOK_CONST, FALSE },
-  { "enum", TOK_ENUM, FALSE },
-  { "export", TOK_EXPORT, FALSE },
-  { "extends", TOK_EXTENDS, FALSE },
-  { "import", TOK_IMPORT, FALSE },
-  { "super", TOK_SUPER, FALSE },
-  /* strict mode future reserved words */
-  { "implements", TOK_IMPLEMENTS, TRUE },
-  { "interface", TOK_INTERFACE, TRUE },
-  { "let", TOK_LET, TRUE },
-  { "private", TOK_PRIVATE, TRUE },
-  { "protected", TOK_PROTECTED, TRUE },
-  { "public", TOK_PUBLIC, TRUE },
-  { "static", TOK_STATIC, TRUE },
-  { "yield", TOK_YIELD, TRUE },
-  { "await", TOK_AWAIT, TRUE },
-};
-
-#define JS_KEYWORD_COUNT (sizeof (js_keywords) / sizeof (js_keywords[0]))
-
-/* lookup keyword by JSValue string, return token or -1 if not found */
-static int js_keyword_lookup (JSValue str, BOOL *is_strict_reserved) {
-  char buf[16];
-  const char *cstr;
-  size_t len;
-
-  if (MIST_IsImmediateASCII (str)) {
-    len = MIST_GetImmediateASCIILen (str);
-    if (len >= sizeof (buf)) return -1;
-    for (size_t i = 0; i < len; i++) {
-      buf[i] = MIST_GetImmediateASCIIChar (str, i);
-    }
-    buf[len] = '\0';
-    cstr = buf;
-  } else if (JS_IsPtr (str)) {
-    /* Handle heap strings (JSText) - keywords like "function" are 8 chars */
-    JSText *text = (JSText *)JS_VALUE_GET_PTR (str);
-#ifdef PRINT_LEXER
-    fprintf(stderr, "DEBUG: JS_IsPtr branch, ptr=%p, hdr_type=%d\n", (void*)text, objhdr_type(text->hdr));
-#endif
-    if (objhdr_type (text->hdr) != OBJ_TEXT) return -1;
-    len = JSText_len (text);
-#ifdef PRINT_LEXER
-    fprintf(stderr, "DEBUG: text len=%zu\n", len);
-#endif
-    if (len >= sizeof (buf)) return -1;
-    for (size_t i = 0; i < len; i++) {
-      uint32_t c = string_get (text, i);
-      if (c >= 128) return -1; /* Keywords are ASCII only */
-      buf[i] = (char)c;
-    }
-    buf[len] = '\0';
-    cstr = buf;
-#ifdef PRINT_LEXER
-    fprintf(stderr, "DEBUG: extracted string='%s' len=%zu\n", cstr, len);
-#endif
-  } else {
-#ifdef PRINT_LEXER
-    fprintf(stderr, "DEBUG: unknown str type, tag=%llx\n", (unsigned long long)(str & 0xFF));
-#endif
-    return -1;
-  }
-
-#ifdef PRINT_LEXER
-  fprintf(stderr, "DEBUG: looking up '%s' in %zu keywords\n", cstr, (size_t)JS_KEYWORD_COUNT);
-#endif
-  for (size_t i = 0; i < JS_KEYWORD_COUNT; i++) {
-    if (strcmp (cstr, js_keywords[i].name) == 0) {
-#ifdef PRINT_LEXER
-      fprintf(stderr, "DEBUG: matched keyword '%s' -> token %d\n", js_keywords[i].name, js_keywords[i].token);
-#endif
-      if (is_strict_reserved)
-        *is_strict_reserved = js_keywords[i].is_strict_reserved;
-      return js_keywords[i].token;
-    }
-  }
-#ifdef PRINT_LEXER
-  fprintf(stderr, "DEBUG: no keyword match for '%s'\n", cstr);
-#endif
-  return -1;
-}
-
-/* convert a TOK_IDENT to a keyword when needed */
-static void update_token_ident (JSParseState *s) {
-  BOOL is_strict_reserved = FALSE;
-  int token = js_keyword_lookup (s->token.u.ident.str, &is_strict_reserved);
-
-  if (token != -1) {
-    if (s->token.u.ident.has_escape) {
-      /* identifiers with escape sequences stay identifiers */
-      s->token.u.ident.is_reserved = TRUE;
-      s->token.val = TOK_IDENT;
-    } else {
-      s->token.val = token;
-    }
-  }
-}
-
-/* if the current token is an identifier or keyword, reparse it
-   according to the current function type */
-static void reparse_ident_token (JSParseState *s) {
-  if (s->token.val == TOK_IDENT
-      || (s->token.val >= TOK_FIRST_KEYWORD
-          && s->token.val <= TOK_LAST_KEYWORD)) {
-    s->token.val = TOK_IDENT;
-    s->token.u.ident.is_reserved = FALSE;
-    update_token_ident (s);
-  }
-}
-
-/* 'c' is the first character. Return JS_NULL in case of error */
-static JSValue parse_ident (JSParseState *s, const uint8_t **pp, BOOL *pident_has_escape, int c) {
-  const uint8_t *p, *p1;
-  char ident_buf[128], *buf;
-  size_t ident_size, ident_pos;
-  JSValue str;
-
-  p = *pp;
-  buf = ident_buf;
-  ident_size = sizeof (ident_buf);
-  ident_pos = 0;
-  for (;;) {
-    p1 = p;
-
-    if (c < 128) {
-      buf[ident_pos++] = c;
-    } else {
-      ident_pos += unicode_to_utf8 ((uint8_t *)buf + ident_pos, c);
-    }
-    c = *p1++;
-    if (c == '\\' && *p1 == 'u') {
-      c = lre_parse_escape (&p1, TRUE);
-      *pident_has_escape = TRUE;
-    } else if (c >= 128) {
-      c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p1);
-    }
-    if (!lre_js_is_ident_next (c) && c != '?' && c != '!') break;
-    p = p1;
-    if (unlikely (ident_pos >= ident_size - UTF8_CHAR_LEN_MAX)) {
-      if (ident_realloc (s->ctx, &buf, &ident_size, ident_buf)) {
-        str = JS_NULL;
-        goto done;
-      }
-    }
-  }
-  /* Create interned JSValue key */
-  str = js_key_new_len (s->ctx, buf, ident_pos);
-done:
-  if (unlikely (buf != ident_buf)) pjs_free (buf);
-  *pp = p;
-  return str;
-}
-
-static __exception int next_token (JSParseState *s) {
-  const uint8_t *p;
-  int c;
-  BOOL ident_has_escape;
-  JSValue ident_str;
-
-  if (js_check_stack_overflow (s->ctx, 0)) {
-    return js_parse_error (s, "stack overflow");
-  }
-
-  free_token (s, &s->token);
-
-  p = s->last_ptr = s->buf_ptr;
-  s->got_lf = FALSE;
-redo:
-  s->token.ptr = p;
-  c = *p;
-  switch (c) {
-  case 0:
-    if (p >= s->buf_end) {
-      s->token.val = TOK_EOF;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '`':
-    if (js_parse_template_part (s, p + 1)) goto fail;
-    p = s->buf_ptr;
-    break;
-  case '\'':
-  case '\"':
-    if (js_parse_string (s, c, TRUE, p + 1, &s->token, &p)) goto fail;
-    break;
-  case '\r': /* accept DOS and MAC newline sequences */
-    if (p[1] == '\n') { p++; }
-    /* fall thru */
-  case '\n':
-    p++;
-  line_terminator:
-    s->got_lf = TRUE;
-    goto redo;
-  case '\f':
-  case '\v':
-  case ' ':
-  case '\t':
-    p++;
-    goto redo;
-  case '/':
-    if (p[1] == '*') {
-      /* comment */
-      p += 2;
-      for (;;) {
-        if (*p == '\0' && p >= s->buf_end) {
-          js_parse_error (s, "unexpected end of comment");
-          goto fail;
-        }
-        if (p[0] == '*' && p[1] == '/') {
-          p += 2;
-          break;
-        }
-        if (*p == '\n' || *p == '\r') {
-          s->got_lf = TRUE; /* considered as LF for ASI */
-          p++;
-        } else if (*p >= 0x80) {
-          c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p);
-          if (c == CP_LS || c == CP_PS) {
-            s->got_lf = TRUE; /* considered as LF for ASI */
-          } else if (c == -1) {
-            p++; /* skip invalid UTF-8 */
-          }
-        } else {
-          p++;
-        }
-      }
-      goto redo;
-    } else if (p[1] == '/') {
-      /* line comment */
-      p += 2;
-      for (;;) {
-        if (*p == '\0' && p >= s->buf_end) break;
-        if (*p == '\r' || *p == '\n') break;
-        if (*p >= 0x80) {
-          c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p);
-          /* LS or PS are considered as line terminator */
-          if (c == CP_LS || c == CP_PS) {
-            break;
-          } else if (c == -1) {
-            p++; /* skip invalid UTF-8 */
-          }
-        } else {
-          p++;
-        }
-      }
-      goto redo;
-    } else if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_DIV_ASSIGN;
-    } else {
-      p++;
-      s->token.val = c;
-    }
-    break;
-  case '\\':
-    if (p[1] == 'u') {
-      const uint8_t *p1 = p + 1;
-      int c1 = lre_parse_escape (&p1, TRUE);
-      if (c1 >= 0 && lre_js_is_ident_first (c1)) {
-        c = c1;
-        p = p1;
-        ident_has_escape = TRUE;
-        goto has_ident;
-      } else {
-        /* XXX: syntax error? */
-      }
-    }
-    goto def_token;
-  case 'a':
-  case 'b':
-  case 'c':
-  case 'd':
-  case 'e':
-  case 'f':
-  case 'g':
-  case 'h':
-  case 'i':
-  case 'j':
-  case 'k':
-  case 'l':
-  case 'm':
-  case 'n':
-  case 'o':
-  case 'p':
-  case 'q':
-  case 'r':
-  case 's':
-  case 't':
-  case 'u':
-  case 'v':
-  case 'w':
-  case 'x':
-  case 'y':
-  case 'z':
-  case 'A':
-  case 'B':
-  case 'C':
-  case 'D':
-  case 'E':
-  case 'F':
-  case 'G':
-  case 'H':
-  case 'I':
-  case 'J':
-  case 'K':
-  case 'L':
-  case 'M':
-  case 'N':
-  case 'O':
-  case 'P':
-  case 'Q':
-  case 'R':
-  case 'S':
-  case 'T':
-  case 'U':
-  case 'V':
-  case 'W':
-  case 'X':
-  case 'Y':
-  case 'Z':
-  case '_':
-  case '$':
-    /* identifier */
-    p++;
-    ident_has_escape = FALSE;
-  has_ident:
-    ident_str = parse_ident (s, &p, &ident_has_escape, c);
-    if (JS_IsNull (ident_str)) goto fail;
-    s->token.u.ident.str = ident_str;
-    s->token.u.ident.has_escape = ident_has_escape;
-    s->token.u.ident.is_reserved = FALSE;
-    s->token.val = TOK_IDENT;
-    update_token_ident (s);
-    break;
-  case '.':
-    if (p[1] == '.' && p[2] == '.') {
-      js_parse_error (s, "ellipsis (...) is not supported");
-      goto fail;
-    }
-    if (p[1] >= '0' && p[1] <= '9') {
-      goto parse_number;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '0':
-    /* in strict mode, octal literals are not accepted */
-    if (is_digit (p[1])) {
-      js_parse_error (s, "octal literals are not allowed");
-      goto fail;
-    }
-    goto parse_number;
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-    /* number */
-  parse_number: {
-    JSValue ret;
-    const uint8_t *p1;
-    int flags;
-    flags = ATOD_ACCEPT_BIN_OCT | ATOD_ACCEPT_LEGACY_OCTAL
-            | ATOD_ACCEPT_UNDERSCORES | ATOD_ACCEPT_SUFFIX;
-    ret = js_atof (s->ctx, (const char *)p, (const char **)&p, 0, flags);
-    if (JS_IsException (ret)) goto fail;
-    /* reject number immediately followed by identifier */
-    if (JS_IsNull (ret)
-        || lre_js_is_ident_next (
-          unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p1))) {
-      js_parse_error (s, "invalid number literal");
-      goto fail;
-    }
-    s->token.val = TOK_NUMBER;
-    s->token.u.num.val = ret;
-  } break;
-  case '*':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_MUL_ASSIGN;
-    } else if (p[1] == '*') {
-      if (p[2] == '=') {
-        p += 3;
-        s->token.val = TOK_POW_ASSIGN;
-      } else {
-        p += 2;
-        s->token.val = TOK_POW;
-      }
-    } else {
-      goto def_token;
-    }
-    break;
-  case '%':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_MOD_ASSIGN;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '+':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_PLUS_ASSIGN;
-    } else if (p[1] == '+') {
-      p += 2;
-      s->token.val = TOK_INC;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '-':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_MINUS_ASSIGN;
-    } else if (p[1] == '-') {
-      p += 2;
-      s->token.val = TOK_DEC;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '<':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_LTE;
-    } else if (p[1] == '<') {
-      if (p[2] == '=') {
-        p += 3;
-        s->token.val = TOK_SHL_ASSIGN;
-      } else {
-        p += 2;
-        s->token.val = TOK_SHL;
-      }
-    } else {
-      goto def_token;
-    }
-    break;
-  case '>':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_GTE;
-    } else if (p[1] == '>') {
-      if (p[2] == '>') {
-        if (p[3] == '=') {
-          p += 4;
-          s->token.val = TOK_SHR_ASSIGN;
-        } else {
-          p += 3;
-          s->token.val = TOK_SHR;
-        }
-      } else if (p[2] == '=') {
-        p += 3;
-        s->token.val = TOK_SAR_ASSIGN;
-      } else {
-        p += 2;
-        s->token.val = TOK_SAR;
-      }
-    } else {
-      goto def_token;
-    }
-    break;
-  case '=':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_STRICT_EQ;
-    } else if (p[1] == '>') {
-      p += 2;
-      s->token.val = TOK_ARROW;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '!':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_STRICT_NEQ;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '&':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_AND_ASSIGN;
-    } else if (p[1] == '&') {
-      if (p[2] == '=') {
-        p += 3;
-        s->token.val = TOK_LAND_ASSIGN;
-      } else {
-        p += 2;
-        s->token.val = TOK_LAND;
-      }
-    } else {
-      goto def_token;
-    }
-    break;
-  case '^':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_XOR_ASSIGN;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '|':
-    if (p[1] == '=') {
-      p += 2;
-      s->token.val = TOK_OR_ASSIGN;
-    } else if (p[1] == '|') {
-      if (p[2] == '=') {
-        p += 3;
-        s->token.val = TOK_LOR_ASSIGN;
-      } else {
-        p += 2;
-        s->token.val = TOK_LOR;
-      }
-    } else {
-      goto def_token;
-    }
-    break;
-  case '?':
-    goto def_token;
-  default:
-    if (c >= 128) {
-      /* unicode value */
-      c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p);
-      switch (c) {
-      case CP_PS:
-      case CP_LS:
-        /* XXX: should avoid incrementing line_number, but
-           needed to handle HTML comments */
-        goto line_terminator;
-      default:
-        if (lre_is_space (c)) {
-          goto redo;
-        } else if (lre_js_is_ident_first (c)) {
-          ident_has_escape = FALSE;
-          goto has_ident;
-        } else {
-          js_parse_error (s, "unexpected character");
-          goto fail;
-        }
-      }
-    }
-  def_token:
-    s->token.val = c;
-    p++;
-    break;
-  }
-  s->buf_ptr = p;
-
-  //    dump_token(s, &s->token);
-  return 0;
-
-fail:
-  s->token.val = TOK_ERROR;
-  return -1;
-}
-
-/* 'c' is the first character. Return JS_NULL in case of error */
-/* XXX: accept unicode identifiers as JSON5 ? */
-static JSValue json_parse_ident (JSParseState *s, const uint8_t **pp, int c) {
-  const uint8_t *p;
-  char ident_buf[128], *buf;
-  size_t ident_size, ident_pos;
-  JSValue str;
-
-  p = *pp;
-  buf = ident_buf;
-  ident_size = sizeof (ident_buf);
-  ident_pos = 0;
-  for (;;) {
-    buf[ident_pos++] = c;
-    c = *p;
-    if (c >= 128 || !lre_is_id_continue_byte (c)) break;
-    p++;
-    if (unlikely (ident_pos >= ident_size - UTF8_CHAR_LEN_MAX)) {
-      if (ident_realloc (s->ctx, &buf, &ident_size, ident_buf)) {
-        str = JS_NULL;
-        goto done;
-      }
-    }
-  }
-  /* Create interned JSValue key */
-  str = js_key_new_len (s->ctx, buf, ident_pos);
-done:
-  if (unlikely (buf != ident_buf)) pjs_free (buf);
-  *pp = p;
-  return str;
-}
-
-static int json_parse_string (JSParseState *s, const uint8_t **pp, int sep) {
-  const uint8_t *p, *p_next;
-  int i;
-  uint32_t c;
-  PPretext *b;
-
-  b = ppretext_init (32);
-  if (!b) goto fail;
-
-  p = *pp;
-  for (;;) {
-    if (p >= s->buf_end) { goto end_of_input; }
-    c = *p++;
-    if (c == sep) break;
-    if (c < 0x20) {
-      js_parse_error_pos (s, p - 1, "Bad control character in string literal");
-      goto fail;
-    }
-    if (c == '\\') {
-      c = *p++;
-      switch (c) {
-      case 'b':
-        c = '\b';
-        break;
-      case 'f':
-        c = '\f';
-        break;
-      case 'n':
-        c = '\n';
-        break;
-      case 'r':
-        c = '\r';
-        break;
-      case 't':
-        c = '\t';
-        break;
-      case '\\':
-        break;
-      case '/':
-        break;
-      case 'u':
-        c = 0;
-        for (i = 0; i < 4; i++) {
-          int h = from_hex (*p++);
-          if (h < 0) {
-            js_parse_error_pos (s, p - 1, "Bad Unicode escape");
-            goto fail;
-          }
-          c = (c << 4) | h;
-        }
-        break;
-      case '\n':
-        if (s->ext_json) continue;
-        goto bad_escape;
-      case 'v':
-        if (s->ext_json) {
-          c = '\v';
-          break;
-        }
-        goto bad_escape;
-      default:
-        if (c == sep) break;
-        if (p > s->buf_end) goto end_of_input;
-      bad_escape:
-        js_parse_error_pos (s, p - 1, "Bad escaped character");
-        goto fail;
-      }
-    } else if (c >= 0x80) {
-      c = unicode_from_utf8 (p - 1, UTF8_CHAR_LEN_MAX, &p_next);
-      if (c > 0x10FFFF) {
-        js_parse_error_pos (s, p - 1, "Bad UTF-8 sequence");
-        goto fail;
-      }
-      p = p_next;
-    }
-    b = ppretext_putc (b, c);
-    if (!b) goto fail;
-  }
-  s->token.val = TOK_STRING;
-  s->token.u.str.sep = sep;
-  s->token.u.str.str = ppretext_end (s->ctx, b);
-  *pp = p;
-  return 0;
-
-end_of_input:
-  js_parse_error (s, "Unexpected end of JSON input");
-fail:
-  ppretext_free (b);
-  return -1;
-}
-
-static int json_parse_number (JSParseState *s, const uint8_t **pp) {
-  const uint8_t *p = *pp;
-  const uint8_t *p_start = p;
-  int radix;
-  double d;
-  JSATODTempMem atod_mem;
-
-  if (*p == '+' || *p == '-') p++;
-
-  if (!is_digit (*p)) {
-    if (s->ext_json) {
-      if (strstart ((const char *)p, "Infinity", (const char **)&p)) {
-        d = 1.0 / 0.0;
-        if (*p_start == '-') d = -d;
-        goto done;
-      } else if (strstart ((const char *)p, "NaN", (const char **)&p)) {
-        d = NAN;
-        goto done;
-      } else if (*p != '.') {
-        goto unexpected_token;
-      }
-    } else {
-      goto unexpected_token;
-    }
-  }
-
-  if (p[0] == '0') {
-    if (s->ext_json) {
-      /* also accepts base 16, 8 and 2 prefix for integers */
-      radix = 10;
-      if (p[1] == 'x' || p[1] == 'X') {
-        p += 2;
-        radix = 16;
-      } else if ((p[1] == 'o' || p[1] == 'O')) {
-        p += 2;
-        radix = 8;
-      } else if ((p[1] == 'b' || p[1] == 'B')) {
-        p += 2;
-        radix = 2;
-      }
-      if (radix != 10) {
-        /* prefix is present */
-        if (to_digit (*p) >= radix) {
-        unexpected_token:
-          return js_parse_error_pos (s, p, "Unexpected token '%c'", *p);
-        }
-        d = js_atod ((const char *)p_start, (const char **)&p, 0, JS_ATOD_INT_ONLY | JS_ATOD_ACCEPT_BIN_OCT, &atod_mem);
-        goto done;
-      }
-    }
-    if (is_digit (p[1])) return js_parse_error_pos (s, p, "Unexpected number");
-  }
-
-  while (is_digit (*p))
-    p++;
-
-  if (*p == '.') {
-    p++;
-    if (!is_digit (*p))
-      return js_parse_error_pos (s, p, "Unterminated fractional number");
-    while (is_digit (*p))
-      p++;
-  }
-  if (*p == 'e' || *p == 'E') {
-    p++;
-    if (*p == '+' || *p == '-') p++;
-    if (!is_digit (*p))
-      return js_parse_error_pos (s, p, "Exponent part is missing a number");
-    while (is_digit (*p))
-      p++;
-  }
-  d = js_atod ((const char *)p_start, NULL, 10, 0, &atod_mem);
-done:
-  s->token.val = TOK_NUMBER;
-  s->token.u.num.val = JS_NewFloat64 (s->ctx, d);
-  *pp = p;
-  return 0;
-}
-
-static __exception int json_next_token (JSParseState *s) {
-  const uint8_t *p;
-  int c;
-  JSValue ident_str;
-
-  if (js_check_stack_overflow (s->ctx, 0)) {
-    return js_parse_error (s, "stack overflow");
-  }
-
-  free_token (s, &s->token);
-
-  p = s->last_ptr = s->buf_ptr;
-redo:
-  s->token.ptr = p;
-  c = *p;
-  switch (c) {
-  case 0:
-    if (p >= s->buf_end) {
-      s->token.val = TOK_EOF;
-    } else {
-      goto def_token;
-    }
-    break;
-  case '\'':
-    if (!s->ext_json) {
-      /* JSON does not accept single quoted strings */
-      goto def_token;
-    }
-    /* fall through */
-  case '\"':
-    p++;
-    if (json_parse_string (s, &p, c)) goto fail;
-    break;
-  case '\r': /* accept DOS and MAC newline sequences */
-    if (p[1] == '\n') { p++; }
-    /* fall thru */
-  case '\n':
-    p++;
-    goto redo;
-  case '\f':
-  case '\v':
-    if (!s->ext_json) {
-      /* JSONWhitespace does not match <VT>, nor <FF> */
-      goto def_token;
-    }
-    /* fall through */
-  case ' ':
-  case '\t':
-    p++;
-    goto redo;
-  case '/':
-    if (!s->ext_json) {
-      /* JSON does not accept comments */
-      goto def_token;
-    }
-    if (p[1] == '*') {
-      /* comment */
-      p += 2;
-      for (;;) {
-        if (*p == '\0' && p >= s->buf_end) {
-          js_parse_error (s, "unexpected end of comment");
-          goto fail;
-        }
-        if (p[0] == '*' && p[1] == '/') {
-          p += 2;
-          break;
-        }
-        if (*p >= 0x80) {
-          c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p);
-          if (c == -1) { p++; /* skip invalid UTF-8 */ }
-        } else {
-          p++;
-        }
-      }
-      goto redo;
-    } else if (p[1] == '/') {
-      /* line comment */
-      p += 2;
-      for (;;) {
-        if (*p == '\0' && p >= s->buf_end) break;
-        if (*p == '\r' || *p == '\n') break;
-        if (*p >= 0x80) {
-          c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p);
-          /* LS or PS are considered as line terminator */
-          if (c == CP_LS || c == CP_PS) {
-            break;
-          } else if (c == -1) {
-            p++; /* skip invalid UTF-8 */
-          }
-        } else {
-          p++;
-        }
-      }
-      goto redo;
-    } else {
-      goto def_token;
-    }
-    break;
-  case 'a':
-  case 'b':
-  case 'c':
-  case 'd':
-  case 'e':
-  case 'f':
-  case 'g':
-  case 'h':
-  case 'i':
-  case 'j':
-  case 'k':
-  case 'l':
-  case 'm':
-  case 'n':
-  case 'o':
-  case 'p':
-  case 'q':
-  case 'r':
-  case 's':
-  case 't':
-  case 'u':
-  case 'v':
-  case 'w':
-  case 'x':
-  case 'y':
-  case 'z':
-  case 'A':
-  case 'B':
-  case 'C':
-  case 'D':
-  case 'E':
-  case 'F':
-  case 'G':
-  case 'H':
-  case 'I':
-  case 'J':
-  case 'K':
-  case 'L':
-  case 'M':
-  case 'N':
-  case 'O':
-  case 'P':
-  case 'Q':
-  case 'R':
-  case 'S':
-  case 'T':
-  case 'U':
-  case 'V':
-  case 'W':
-  case 'X':
-  case 'Y':
-  case 'Z':
-  case '_':
-  case '$':
-    p++;
-    ident_str = json_parse_ident (s, &p, c);
-    if (JS_IsNull (ident_str)) goto fail;
-    s->token.u.ident.str = ident_str;
-    s->token.u.ident.has_escape = FALSE;
-    s->token.u.ident.is_reserved = FALSE;
-    s->token.val = TOK_IDENT;
-    break;
-  case '+':
-    if (!s->ext_json) goto def_token;
-    goto parse_number;
-  case '.':
-    if (s->ext_json && is_digit (p[1]))
-      goto parse_number;
-    else
-      goto def_token;
-  case '-':
-  case '0':
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-    /* number */
-  parse_number:
-    if (json_parse_number (s, &p)) goto fail;
-    break;
-  default:
-    if (c >= 128) {
-      js_parse_error (s, "unexpected character");
-      goto fail;
-    }
-  def_token:
-    s->token.val = c;
-    p++;
-    break;
-  }
-  s->buf_ptr = p;
-
-  //    dump_token(s, &s->token);
-  return 0;
-
-fail:
-  s->token.val = TOK_ERROR;
-  return -1;
-}
-
-static int match_identifier (const uint8_t *p, const char *s) {
-  uint32_t c;
-  while (*s) {
-    if ((uint8_t)*s++ != *p++) return 0;
-  }
-  c = *p;
-  if (c >= 128) c = unicode_from_utf8 (p, UTF8_CHAR_LEN_MAX, &p);
-  return !lre_js_is_ident_next (c);
-}
-
-/* simple_next_token() is used to check for the next token in simple cases.
-   It is only used for ':' and '=>', 'let' or 'function' look-ahead.
-   (*pp) is only set if TOK_IMPORT is returned for JS_DetectModule()
-   Whitespace and comments are skipped correctly.
-   Then the next token is analyzed, only for specific words.
-   Return values:
-   - '\n' if !no_line_terminator
-   - TOK_ARROW, TOK_IN, TOK_IMPORT, TOK_OF, TOK_EXPORT, TOK_FUNCTION
-   - TOK_IDENT is returned for other identifiers and keywords
-   - otherwise the next character or unicode codepoint is returned.
- */
-static int simple_next_token (const uint8_t **pp, BOOL no_line_terminator) {
-  const uint8_t *p;
-  uint32_t c;
-
-  /* skip spaces and comments */
-  p = *pp;
-  for (;;) {
-    switch (c = *p++) {
-    case '\r':
-    case '\n':
-      if (no_line_terminator) return '\n';
-      continue;
-    case ' ':
-    case '\t':
-    case '\v':
-    case '\f':
-      continue;
-    case '/':
-      if (*p == '/') {
-        if (no_line_terminator) return '\n';
-        while (*p && *p != '\r' && *p != '\n')
-          p++;
-        continue;
-      }
-      if (*p == '*') {
-        while (*++p) {
-          if ((*p == '\r' || *p == '\n') && no_line_terminator) return '\n';
-          if (*p == '*' && p[1] == '/') {
-            p += 2;
-            break;
-          }
-        }
-        continue;
-      }
-      break;
-    case '=':
-      if (*p == '>') return TOK_ARROW;
-      break;
-    case 'i':
-      if (match_identifier (p, "n")) return TOK_IN;
-      if (match_identifier (p, "mport")) {
-        *pp = p + 5;
-        return TOK_IMPORT;
-      }
-      return TOK_IDENT;
-    case 'o':
-      if (match_identifier (p, "f")) return TOK_OF;
-      return TOK_IDENT;
-    case 'e':
-      if (match_identifier (p, "xport")) return TOK_EXPORT;
-      return TOK_IDENT;
-    case 'f':
-      if (match_identifier (p, "unction")) return TOK_FUNCTION;
-      return TOK_IDENT;
-    case '\\':
-      if (*p == 'u') {
-        if (lre_js_is_ident_first (lre_parse_escape (&p, TRUE)))
-          return TOK_IDENT;
-      }
-      break;
-    default:
-      if (c >= 128) {
-        c = unicode_from_utf8 (p - 1, UTF8_CHAR_LEN_MAX, &p);
-        if (no_line_terminator && (c == CP_PS || c == CP_LS)) return '\n';
-      }
-      if (lre_is_space (c)) continue;
-      if (lre_js_is_ident_first (c)) return TOK_IDENT;
-      break;
-    }
-    return c;
-  }
-}
-
-static int peek_token (JSParseState *s, BOOL no_line_terminator) {
-  const uint8_t *p = s->buf_ptr;
-  return simple_next_token (&p, no_line_terminator);
-}
-
-static inline int get_prev_opcode (JSFunctionDef *fd) {
-  if (fd->last_opcode_pos < 0 || dbuf_error (&fd->byte_code))
-    return OP_invalid;
-  else
-    return fd->byte_code.buf[fd->last_opcode_pos];
-}
-
-static BOOL js_is_live_code (JSParseState *s) {
-  switch (get_prev_opcode (s->cur_func)) {
-  case OP_tail_call:
-  case OP_tail_call_method:
-  case OP_return:
-  case OP_return_undef:
-  case OP_throw:
-  case OP_throw_error:
-  case OP_goto:
-#if SHORT_OPCODES
-  case OP_goto8:
-  case OP_goto16:
-#endif
-  case OP_ret:
-    return FALSE;
-  default:
-    return TRUE;
-  }
-}
-
-static void emit_u8 (JSParseState *s, uint8_t val) {
-  dbuf_putc (&s->cur_func->byte_code, val);
-}
-
-static void emit_u16 (JSParseState *s, uint16_t val) {
-  dbuf_put_u16 (&s->cur_func->byte_code, val);
-}
-
-static void emit_u32 (JSParseState *s, uint32_t val) {
-  dbuf_put_u32 (&s->cur_func->byte_code, val);
-}
-
-static void emit_source_pos (JSParseState *s, const uint8_t *source_ptr) {
-  JSFunctionDef *fd = s->cur_func;
-  DynBuf *bc = &fd->byte_code;
-
-  if (unlikely (fd->last_opcode_source_ptr != source_ptr)) {
-    dbuf_putc (bc, OP_line_num);
-    dbuf_put_u32 (bc, source_ptr - s->buf_start);
-    fd->last_opcode_source_ptr = source_ptr;
-  }
-}
-
-static void emit_op (JSParseState *s, uint8_t val) {
-  JSFunctionDef *fd = s->cur_func;
-  DynBuf *bc = &fd->byte_code;
-
-  fd->last_opcode_pos = bc->size;
-  dbuf_putc (bc, val);
-}
-
-/* Forward declarations for cpool */
-static int fd_cpool_add (JSContext *ctx, JSFunctionDef *fd, JSValue val);
-static int cpool_add (JSParseState *s, JSValue val);
-
-/* Emit a key (JSValue) by adding to cpool and emitting the index.
-   Used for variable opcodes (get_var, put_var, etc.) and property ops. */
-static int emit_key (JSParseState *s, JSValue name) {
-  int idx = cpool_add (s, name);
-  if (idx < 0) return -1;
-  emit_u32 (s, idx);
-  return 0;
-}
-
-/* Emit a property key for field access opcodes. */
-static int emit_prop_key (JSParseState *s, JSValue key) {
-  return emit_key (s, key);
-}
-
-static int update_label (JSFunctionDef *s, int label, int delta) {
-  LabelSlot *ls;
-
-  assert (label >= 0 && label < s->label_count);
-  ls = &s->label_slots[label];
-  ls->ref_count += delta;
-  assert (ls->ref_count >= 0);
-  return ls->ref_count;
-}
-
-static int new_label_fd (JSFunctionDef *fd) {
-  int label;
-  LabelSlot *ls;
-
-  if (pjs_resize_array ((void **)&fd->label_slots, sizeof (fd->label_slots[0]), &fd->label_size, fd->label_count + 1))
-    return -1;
-  label = fd->label_count++;
-  ls = &fd->label_slots[label];
-  ls->ref_count = 0;
-  ls->pos = -1;
-  ls->pos2 = -1;
-  ls->addr = -1;
-  ls->first_reloc = NULL;
-  return label;
-}
-
-static int new_label (JSParseState *s) {
-  int label;
-  label = new_label_fd (s->cur_func);
-  if (unlikely (label < 0)) { dbuf_set_error (&s->cur_func->byte_code); }
-  return label;
-}
-
-/* don't update the last opcode and don't emit line number info */
-static void emit_label_raw (JSParseState *s, int label) {
-  emit_u8 (s, OP_label);
-  emit_u32 (s, label);
-  s->cur_func->label_slots[label].pos = s->cur_func->byte_code.size;
-}
-
-/* return the label ID offset */
-static int emit_label (JSParseState *s, int label) {
-  if (label >= 0) {
-    emit_op (s, OP_label);
-    emit_u32 (s, label);
-    s->cur_func->label_slots[label].pos = s->cur_func->byte_code.size;
-    return s->cur_func->byte_code.size - 4;
-  } else {
-    return -1;
-  }
-}
-
-/* return label or -1 if dead code */
-static int emit_goto (JSParseState *s, int opcode, int label) {
-  if (js_is_live_code (s)) {
-    if (label < 0) {
-      label = new_label (s);
-      if (label < 0) return -1;
-    }
-    emit_op (s, opcode);
-    emit_u32 (s, label);
-    s->cur_func->label_slots[label].ref_count++;
-    return label;
-  }
-  return -1;
-}
-
-/* return the constant pool index. 'val' is not duplicated. */
-static int fd_cpool_add (JSContext *ctx, JSFunctionDef *fd, JSValue val) {
-  (void)ctx;
-  if (pjs_resize_array ((void **)&fd->cpool, sizeof (fd->cpool[0]), &fd->cpool_size, fd->cpool_count + 1))
-    return -1;
-  fd->cpool[fd->cpool_count++] = val;
-  return fd->cpool_count - 1;
-}
-
-/* return the constant pool index. 'val' is not duplicated. */
-static int cpool_add (JSParseState *s, JSValue val) {
-  return fd_cpool_add (s->ctx, s->cur_func, val);
-}
-
-static __exception int emit_push_const (JSParseState *s, JSValue val) {
-  int idx;
-  idx = cpool_add (s, val);
-  if (idx < 0) return -1;
-  emit_op (s, OP_push_const);
-  emit_u32 (s, idx);
-  return 0;
-}
-
-/* return the variable index or -1 if not found,
-   add ARGUMENT_VAR_OFFSET for argument variables */
-static int find_arg (JSContext *ctx, JSFunctionDef *fd, JSValue name) {
-  int i;
-  for (i = fd->arg_count; i-- > 0;) {
-    if (js_key_equal (fd->args[i].var_name, name))
-      return i | ARGUMENT_VAR_OFFSET;
-  }
-  return -1;
-}
-
-static int find_var (JSContext *ctx, JSFunctionDef *fd, JSValue name) {
-  int i;
-  for (i = fd->var_count; i-- > 0;) {
-    if (js_key_equal (fd->vars[i].var_name, name) && fd->vars[i].scope_level == 0)
-      return i;
-  }
-  return find_arg (ctx, fd, name);
-}
-
-/* return true if scope == parent_scope or if scope is a child of
-   parent_scope */
-static BOOL is_child_scope (JSContext *ctx, JSFunctionDef *fd, int scope, int parent_scope) {
-  while (scope >= 0) {
-    if (scope == parent_scope) return TRUE;
-    scope = fd->scopes[scope].parent;
-  }
-  return FALSE;
-}
-
-/* find a 'var' declaration in the same scope or a child scope */
-static int find_var_in_child_scope (JSContext *ctx, JSFunctionDef *fd, JSValue name, int scope_level) {
-  int i;
-  for (i = 0; i < fd->var_count; i++) {
-    JSVarDef *vd = &fd->vars[i];
-    if (js_key_equal (vd->var_name, name) && vd->scope_level == 0) {
-      if (is_child_scope (ctx, fd, vd->scope_next, scope_level)) return i;
-    }
-  }
-  return -1;
-}
-
-static JSGlobalVar *find_global_var (JSFunctionDef *fd, JSValue name) {
-  int i;
-  for (i = 0; i < fd->global_var_count; i++) {
-    JSGlobalVar *hf = &fd->global_vars[i];
-    if (js_key_equal (hf->var_name, name)) return hf;
-  }
-  return NULL;
-}
-
-static JSGlobalVar *find_lexical_global_var (JSFunctionDef *fd, JSValue name) {
-  JSGlobalVar *hf = find_global_var (fd, name);
-  if (hf && hf->is_lexical)
-    return hf;
-  else
-    return NULL;
-}
-
-static int find_lexical_decl (JSContext *ctx, JSFunctionDef *fd, JSValue name, int scope_idx, BOOL check_catch_var) {
-  while (scope_idx >= 0) {
-    JSVarDef *vd = &fd->vars[scope_idx];
-    if (js_key_equal (vd->var_name, name)
-        && (vd->is_lexical
-            || (vd->var_kind == JS_VAR_CATCH && check_catch_var)))
-      return scope_idx;
-    scope_idx = vd->scope_next;
-  }
-
-  return -1;
-}
-
-static int push_scope (JSParseState *s) {
-  if (s->cur_func) {
-    JSFunctionDef *fd = s->cur_func;
-    int scope = fd->scope_count;
-    /* XXX: should check for scope overflow */
-    if ((fd->scope_count + 1) > fd->scope_size) {
-      int new_size;
-      JSVarScope *new_buf;
-      /* XXX: potential arithmetic overflow */
-      new_size = max_int (fd->scope_count + 1, fd->scope_size * 3 / 2);
-      if (fd->scopes == fd->def_scope_array) {
-        new_buf = pjs_malloc (new_size * sizeof (*fd->scopes));
-        if (!new_buf) return -1;
-        memcpy (new_buf, fd->scopes, fd->scope_count * sizeof (*fd->scopes));
-      } else {
-        new_buf = pjs_realloc (fd->scopes, new_size * sizeof (*fd->scopes));
-        if (!new_buf) return -1;
-      }
-      fd->scopes = new_buf;
-      fd->scope_size = new_size;
-    }
-    fd->scope_count++;
-    fd->scopes[scope].parent = fd->scope_level;
-    fd->scopes[scope].first = fd->scope_first;
-    emit_op (s, OP_enter_scope);
-    emit_u16 (s, scope);
-    return fd->scope_level = scope;
-  }
-  return 0;
-}
-
-static int get_first_lexical_var (JSFunctionDef *fd, int scope) {
-  while (scope >= 0) {
-    int scope_idx = fd->scopes[scope].first;
-    if (scope_idx >= 0) return scope_idx;
-    scope = fd->scopes[scope].parent;
-  }
-  return -1;
-}
-
-static void pop_scope (JSParseState *s) {
-  if (s->cur_func) {
-    /* disable scoped variables */
-    JSFunctionDef *fd = s->cur_func;
-    int scope = fd->scope_level;
-    emit_op (s, OP_leave_scope);
-    emit_u16 (s, scope);
-    fd->scope_level = fd->scopes[scope].parent;
-    fd->scope_first = get_first_lexical_var (fd, fd->scope_level);
-  }
-}
-
-static void close_scopes (JSParseState *s, int scope, int scope_stop) {
-  while (scope > scope_stop) {
-    emit_op (s, OP_leave_scope);
-    emit_u16 (s, scope);
-    scope = s->cur_func->scopes[scope].parent;
-  }
-}
-
-/* return the variable index or -1 if error */
-static int add_var (JSContext *ctx, JSFunctionDef *fd, JSValue name) {
-  JSVarDef *vd;
-
-  /* the local variable indexes are currently stored on 16 bits */
-  if (fd->var_count >= JS_MAX_LOCAL_VARS) {
-    JS_ThrowInternalError (ctx, "too many local variables");
-    return -1;
-  }
-  if (pjs_resize_array ((void **)&fd->vars, sizeof (fd->vars[0]), &fd->var_size, fd->var_count + 1))
-    return -1;
-  vd = &fd->vars[fd->var_count++];
-  memset (vd, 0, sizeof (*vd));
-  vd->var_name = name;
-  vd->func_pool_idx = -1;
-  return fd->var_count - 1;
-}
-
-static int add_scope_var (JSContext *ctx, JSFunctionDef *fd, JSValue name, JSVarKindEnum var_kind) {
-  int idx = add_var (ctx, fd, name);
-  if (idx >= 0) {
-    JSVarDef *vd = &fd->vars[idx];
-    vd->var_kind = var_kind;
-    vd->scope_level = fd->scope_level;
-    vd->scope_next = fd->scope_first;
-    fd->scopes[fd->scope_level].first = idx;
-    fd->scope_first = idx;
-  }
-  return idx;
-}
-
-static int add_func_var (JSContext *ctx, JSFunctionDef *fd, JSValue name) {
-  int idx = fd->func_var_idx;
-  if (idx < 0 && (idx = add_var (ctx, fd, name)) >= 0) {
-    fd->func_var_idx = idx;
-    fd->vars[idx].var_kind = JS_VAR_FUNCTION_NAME;
-    fd->vars[idx].is_const = TRUE;
-  }
-  return idx;
-}
-
-static int add_arg (JSContext *ctx, JSFunctionDef *fd, JSValue name) {
-  JSVarDef *vd;
-
-  /* the local variable indexes are currently stored on 16 bits */
-  if (fd->arg_count >= JS_MAX_LOCAL_VARS) {
-    JS_ThrowInternalError (ctx, "too many arguments");
-    return -1;
-  }
-  if (pjs_resize_array ((void **)&fd->args, sizeof (fd->args[0]), &fd->arg_size, fd->arg_count + 1))
-    return -1;
-  vd = &fd->args[fd->arg_count++];
-  memset (vd, 0, sizeof (*vd));
-  vd->var_name = name;
-  vd->func_pool_idx = -1;
-  return fd->arg_count - 1;
-}
-
-/* add a global variable definition */
-static JSGlobalVar *add_global_var (JSContext *ctx, JSFunctionDef *s, JSValue name) {
-  JSGlobalVar *hf;
-  (void)ctx;
-
-  if (pjs_resize_array ((void **)&s->global_vars, sizeof (s->global_vars[0]), &s->global_var_size, s->global_var_count + 1))
-    return NULL;
-  hf = &s->global_vars[s->global_var_count++];
-  hf->cpool_idx = -1;
-  hf->force_init = FALSE;
-  hf->is_lexical = FALSE;
-  hf->is_const = FALSE;
-  hf->scope_level = s->scope_level;
-  hf->var_name = name;
-  return hf;
-}
-
-typedef enum {
-  JS_VAR_DEF_WITH,
-  JS_VAR_DEF_LET,
-  JS_VAR_DEF_CONST,
-  JS_VAR_DEF_FUNCTION_DECL,     /* function declaration */
-  JS_VAR_DEF_NEW_FUNCTION_DECL, /* async/generator function declaration */
-  JS_VAR_DEF_CATCH,
-  JS_VAR_DEF_VAR,
-} JSVarDefEnum;
-
-static int define_var (JSParseState *s, JSFunctionDef *fd, JSValue name, JSVarDefEnum var_def_type) {
-  JSContext *ctx = s->ctx;
-  JSVarDef *vd;
-  int idx;
-
-  switch (var_def_type) {
-  case JS_VAR_DEF_WITH:
-    idx = add_scope_var (ctx, fd, name, JS_VAR_NORMAL);
-    break;
-
-  case JS_VAR_DEF_LET:
-  case JS_VAR_DEF_CONST:
-  case JS_VAR_DEF_FUNCTION_DECL:
-  case JS_VAR_DEF_NEW_FUNCTION_DECL:
-    idx = find_lexical_decl (ctx, fd, name, fd->scope_first, TRUE);
-    if (idx >= 0) {
-      if (idx < GLOBAL_VAR_OFFSET) {
-        if (fd->vars[idx].scope_level == fd->scope_level) {
-          goto redef_lex_error;
-        } else if (fd->vars[idx].var_kind == JS_VAR_CATCH
-                   && (fd->vars[idx].scope_level + 2) == fd->scope_level) {
-          goto redef_lex_error;
-        }
-      } else {
-        if (fd->scope_level == fd->body_scope) {
-        redef_lex_error:
-          return js_parse_error (s,
-                                 "invalid redefinition of lexical identifier");
-        }
-      }
-    }
-    if (var_def_type != JS_VAR_DEF_FUNCTION_DECL
-        && var_def_type != JS_VAR_DEF_NEW_FUNCTION_DECL
-        && fd->scope_level == fd->body_scope
-        && find_arg (ctx, fd, name) >= 0) {
-      /* lexical variable redefines a parameter name */
-      return js_parse_error (s, "invalid redefinition of parameter name");
-    }
-
-    if (find_var_in_child_scope (ctx, fd, name, fd->scope_level) >= 0) {
-      return js_parse_error (s, "invalid redefinition of a variable");
-    }
-
-    if (fd->is_global_var) {
-      JSGlobalVar *hf;
-      hf = find_global_var (fd, name);
-      if (hf && is_child_scope (ctx, fd, hf->scope_level, fd->scope_level)) {
-        return js_parse_error (s, "invalid redefinition of global identifier");
-      }
-    }
-
-    /* Global object is immutable - always use local variables */
-    {
-      JSVarKindEnum var_kind;
-      if (var_def_type == JS_VAR_DEF_FUNCTION_DECL)
-        var_kind = JS_VAR_FUNCTION_DECL;
-      else if (var_def_type == JS_VAR_DEF_NEW_FUNCTION_DECL)
-        var_kind = JS_VAR_NEW_FUNCTION_DECL;
-      else
-        var_kind = JS_VAR_NORMAL;
-      idx = add_scope_var (ctx, fd, name, var_kind);
-      if (idx >= 0) {
-        vd = &fd->vars[idx];
-        vd->is_lexical = 1;
-        vd->is_const = (var_def_type == JS_VAR_DEF_CONST);
-      }
-    }
-    break;
-
-  case JS_VAR_DEF_CATCH:
-    idx = add_scope_var (ctx, fd, name, JS_VAR_CATCH);
-    break;
-
-  case JS_VAR_DEF_VAR:
-    if (find_lexical_decl (ctx, fd, name, fd->scope_first, FALSE) >= 0) {
-      /* error to redefine a var that inside a lexical scope */
-      return js_parse_error (s, "invalid redefinition of lexical identifier");
-    }
-    if (fd->is_global_var) {
-      JSGlobalVar *hf;
-      hf = find_global_var (fd, name);
-      hf = add_global_var (s->ctx, fd, name);
-      if (!hf) return -1;
-      idx = GLOBAL_VAR_OFFSET;
-    } else {
-      /* if the variable already exists, don't add it again  */
-      idx = find_var (ctx, fd, name);
-      if (idx >= 0) break;
-      idx = add_var (ctx, fd, name);
-      if (idx >= 0) { fd->vars[idx].scope_next = fd->scope_level; }
-    }
-    break;
-  default:
-    abort ();
-  }
-  return idx;
-}
-
-static __exception int js_parse_expr (JSParseState *s);
-static __exception int js_parse_function_decl (JSParseState *s,
-                                               JSParseFunctionEnum func_type,
-                                               JSValue func_name,
-                                               const uint8_t *ptr);
-static __exception int js_parse_function_decl2 (JSParseState *s,
-                                                JSParseFunctionEnum func_type,
-                                                JSValue func_name,
-                                                const uint8_t *ptr,
-                                                JSFunctionDef **pfd);
-static __exception int js_parse_assign_expr2 (JSParseState *s,
-                                              int parse_flags);
-static __exception int js_parse_assign_expr (JSParseState *s);
-static __exception int js_parse_unary (JSParseState *s, int parse_flags);
-static void push_break_entry (JSFunctionDef *fd, BlockEnv *be, JSValue label_name, int label_break, int label_cont, int drop_count);
-static void pop_break_entry (JSFunctionDef *fd);
-
-static __exception int js_parse_template (JSParseState *s) {
-  JSContext *ctx = s->ctx;
-  PPretext *fmt = ppretext_init (64);
-  JSToken cooked;
-  int expr_count = 0;
-
-  if (!fmt) return -1;
-
-  while (s->token.val == TOK_TEMPLATE) {
-    const uint8_t *p = s->token.ptr + 1;
-
-    /* re-parse the string with escape sequences and throw a
-       syntax error if it contains invalid sequences */
-    s->token.u.str.str = JS_NULL;
-    if (js_parse_string (s, '`', TRUE, p, &cooked, &p)) {
-      ppretext_free (fmt);
-      return -1;
-    }
-
-    /* Append cooked string to format string */
-    fmt = ppretext_append_jsvalue (fmt, cooked.u.str.str);
-    if (!fmt) return -1;
-
-    /* Check for end of template */
-    if (s->token.u.str.sep == '`') break;
-
-    /* Append placeholder {N} */
-    fmt = ppretext_putc (fmt, '{');
-    if (!fmt) return -1;
-    fmt = ppretext_append_int (fmt, expr_count);
-    if (!fmt) return -1;
-    fmt = ppretext_putc (fmt, '}');
-    if (!fmt) return -1;
-
-    /* Parse expression */
-    if (next_token (s)) { ppretext_free (fmt); return -1; }
-    if (js_parse_expr (s)) { ppretext_free (fmt); return -1; }
-    expr_count++;
-
-    if (s->token.val != '}') {
-      ppretext_free (fmt);
-      return js_parse_error (s, "expected '}' after template expression");
-    }
-
-    free_token (s, &s->token);
-    s->got_lf = FALSE;
-    if (js_parse_template_part (s, s->buf_ptr)) {
-      ppretext_free (fmt);
-      return -1;
-    }
-  }
-
-  /* Finalize format string */
-  JSValue format_str = ppretext_end (ctx, fmt);
-  if (JS_IsException (format_str)) return -1;
-
-  int idx = cpool_add (s, format_str);
-  if (idx < 0) return -1;
-
-  if (expr_count == 0) {
-    /* Simple template - just push the string */
-    emit_op (s, OP_push_const);
-    emit_u32 (s, idx);
-  } else {
-    /* Template with expressions - emit u16 first for stack size computation */
-    emit_op (s, OP_format_template);
-    emit_u16 (s, expr_count);
-    emit_u32 (s, idx);
-  }
-
-  return next_token (s);
-}
-
-#define PROP_TYPE_IDENT 0
-#define PROP_TYPE_VAR 1
-
-static BOOL token_is_ident (int tok) {
-  /* Accept keywords and reserved words as property names */
-  return (tok == TOK_IDENT
-          || (tok >= TOK_FIRST_KEYWORD && tok <= TOK_LAST_KEYWORD));
-}
-
-/* if the property is an expression, name = JS_NULL */
-static int __exception js_parse_property_name (JSParseState *s, JSValue *pname, BOOL allow_method, BOOL allow_var) {
-  BOOL is_non_reserved_ident;
-  JSValue name;
-  int prop_type;
-
-  prop_type = PROP_TYPE_IDENT;
-  if (token_is_ident (s->token.val)) {
-    /* variable can only be a non-reserved identifier */
-    is_non_reserved_ident
-      = (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved);
-    /* keywords and reserved words have a valid JSValue key */
-    name = s->token.u.ident.str;
-    if (next_token (s)) goto fail1;
-    if (is_non_reserved_ident && prop_type == PROP_TYPE_IDENT && allow_var) {
-      if (!(s->token.val == ':' || (s->token.val == '(' && allow_method))) {
-        prop_type = PROP_TYPE_VAR;
-      }
-    }
-  } else if (s->token.val == TOK_STRING) {
-    /* String literal as property name - already interned from parsing */
-    name = s->token.u.str.str;
-    if (next_token (s)) goto fail1;
-  } else if (s->token.val == TOK_NUMBER) {
-    /* Numeric property name - convert to string key */
-    JSValue val = s->token.u.num.val;
-    JSValue str = JS_ToString (s->ctx, val);
-    if (JS_IsException (str)) goto fail;
-    name = str;
-    if (next_token (s)) goto fail1;
-  } else if (s->token.val == '[') {
-    if (next_token (s)) goto fail;
-    if (js_parse_expr (s)) goto fail;
-    if (js_parse_expect (s, ']')) goto fail;
-    name = JS_NULL;
-  } else {
-    goto invalid_prop;
-  }
-  if (prop_type != PROP_TYPE_IDENT && prop_type != PROP_TYPE_VAR
-      && s->token.val != '(') {
-  invalid_prop:
-    js_parse_error (s, "invalid property name");
-    goto fail;
-  }
-  *pname = name;
-  return prop_type;
-fail1:
-fail:
-  *pname = JS_NULL;
-  return -1;
-}
-
-typedef struct JSParsePos {
-  BOOL got_lf;
-  const uint8_t *ptr;
-} JSParsePos;
-
-static int js_parse_get_pos (JSParseState *s, JSParsePos *sp) {
-  sp->ptr = s->token.ptr;
-  sp->got_lf = s->got_lf;
-  return 0;
-}
-
-static __exception int js_parse_seek_token (JSParseState *s,
-                                            const JSParsePos *sp) {
-  s->buf_ptr = sp->ptr;
-  s->got_lf = sp->got_lf;
-  return next_token (s);
-}
-
-/* return TRUE if a regexp literal is allowed after this token */
-static BOOL is_regexp_allowed (int tok) {
-  switch (tok) {
-  case TOK_NUMBER:
-  case TOK_STRING:
-  case TOK_REGEXP:
-  case TOK_DEC:
-  case TOK_INC:
-  case TOK_NULL:
-  case TOK_FALSE:
-  case TOK_TRUE:
-  case TOK_THIS:
-  case ')':
-  case ']':
-  case '}': /* XXX: regexp may occur after */
-  case TOK_IDENT:
-    return FALSE;
-  default:
-    return TRUE;
-  }
-}
-
-#define SKIP_HAS_SEMI (1 << 0)
-#define SKIP_HAS_ASSIGNMENT (1 << 1)
-
-static BOOL has_lf_in_range (const uint8_t *p1, const uint8_t *p2) {
-  const uint8_t *tmp;
-  if (p1 > p2) {
-    tmp = p1;
-    p1 = p2;
-    p2 = tmp;
-  }
-  return (memchr (p1, '\n', p2 - p1) != NULL);
-}
-
-/* XXX: improve speed with early bailout */
-/* XXX: no longer works if regexps are present. Could use previous
-   regexp parsing heuristics to handle most cases */
-static int js_parse_skip_parens_token (JSParseState *s, int *pbits, BOOL no_line_terminator) {
-  char state[256];
-  size_t level = 0;
-  JSParsePos pos;
-  int last_tok, tok = TOK_EOF;
-  int c, tok_len, bits = 0;
-  const uint8_t *last_token_ptr;
-
-  /* protect from underflow */
-  state[level++] = 0;
-
-  js_parse_get_pos (s, &pos);
-  last_tok = 0;
-  for (;;) {
-    switch (s->token.val) {
-    case '(':
-    case '[':
-    case '{':
-      if (level >= sizeof (state)) goto done;
-      state[level++] = s->token.val;
-      break;
-    case ')':
-      if (state[--level] != '(') goto done;
-      break;
-    case ']':
-      if (state[--level] != '[') goto done;
-      break;
-    case '}':
-      c = state[--level];
-      if (c == '`') {
-        /* continue the parsing of the template */
-        free_token (s, &s->token);
-        /* Resume TOK_TEMPLATE parsing (s->token.line_num and
-         * s->token.ptr are OK) */
-        s->got_lf = FALSE;
-        if (js_parse_template_part (s, s->buf_ptr)) goto done;
-        goto handle_template;
-      } else if (c != '{') {
-        goto done;
-      }
-      break;
-    case TOK_TEMPLATE:
-    handle_template:
-      if (s->token.u.str.sep != '`') {
-        /* '${' inside the template : closing '}' and continue
-           parsing the template */
-        if (level >= sizeof (state)) goto done;
-        state[level++] = '`';
-      }
-      break;
-    case TOK_EOF:
-      goto done;
-    case ';':
-      if (level == 2) { bits |= SKIP_HAS_SEMI; }
-      break;
-    case '=':
-      bits |= SKIP_HAS_ASSIGNMENT;
-      break;
-
-    case TOK_DIV_ASSIGN:
-      tok_len = 2;
-      goto parse_regexp;
-    case '/':
-      tok_len = 1;
-    parse_regexp:
-      if (is_regexp_allowed (last_tok)) {
-        s->buf_ptr -= tok_len;
-        if (js_parse_regexp (s)) {
-          /* XXX: should clear the exception */
-          goto done;
-        }
-      }
-      break;
-    }
-    /* last_tok is only used to recognize regexps */
-    if (s->token.val == TOK_IDENT
-        && (token_is_pseudo_keyword (s, JS_KEY_of)
-            || token_is_pseudo_keyword (s, JS_KEY_yield))) {
-      last_tok = TOK_OF;
-    } else {
-      last_tok = s->token.val;
-    }
-    last_token_ptr = s->token.ptr;
-    if (next_token (s)) {
-      /* XXX: should clear the exception generated by next_token() */
-      break;
-    }
-    if (level <= 1) {
-      tok = s->token.val;
-      if (token_is_pseudo_keyword (s, JS_KEY_of)) tok = TOK_OF;
-      if (no_line_terminator && has_lf_in_range (last_token_ptr, s->token.ptr))
-        tok = '\n';
-      break;
-    }
-  }
-done:
-  if (pbits) { *pbits = bits; }
-  if (js_parse_seek_token (s, &pos)) return -1;
-  return tok;
-}
-
-static void set_object_name (JSParseState *s, JSValue name) {
-  JSFunctionDef *fd = s->cur_func;
-  int opcode;
-
-  opcode = get_prev_opcode (fd);
-  if (opcode == OP_set_name) {
-    /* XXX: should free key after OP_set_name? */
-    fd->byte_code.size = fd->last_opcode_pos;
-    fd->last_opcode_pos = -1;
-    emit_op (s, OP_set_name);
-    emit_key (s, name);
-  } else if (opcode == OP_set_class_name) {
-    int define_class_pos;
-    uint32_t cpool_idx;
-    define_class_pos = fd->last_opcode_pos + 1
-                       - get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1);
-    assert (fd->byte_code.buf[define_class_pos] == OP_define_class);
-    /* Update the cpool index in the bytecode to point to the new name */
-    cpool_idx = cpool_add (s, name);
-    put_u32 (fd->byte_code.buf + define_class_pos + 1, cpool_idx);
-    fd->last_opcode_pos = -1;
-  }
-}
-
-static void set_object_name_computed (JSParseState *s) {
-  JSFunctionDef *fd = s->cur_func;
-  int opcode;
-
-  opcode = get_prev_opcode (fd);
-  if (opcode == OP_set_name) {
-    /* XXX: should free atom after OP_set_name? */
-    fd->byte_code.size = fd->last_opcode_pos;
-    fd->last_opcode_pos = -1;
-    emit_op (s, OP_set_name_computed);
-  } else if (opcode == OP_set_class_name) {
-    int define_class_pos;
-    define_class_pos = fd->last_opcode_pos + 1
-                       - get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1);
-    assert (fd->byte_code.buf[define_class_pos] == OP_define_class);
-    fd->byte_code.buf[define_class_pos] = OP_define_class_computed;
-    fd->last_opcode_pos = -1;
-  }
-}
-
-static __exception int js_parse_object_literal (JSParseState *s) {
-  JSValue name = JS_NULL;
-  const uint8_t *start_ptr;
-  int prop_type;
-
-  if (next_token (s)) goto fail;
-  /* XXX: add an initial length that will be patched back */
-  emit_op (s, OP_object);
-
-  while (s->token.val != '}') {
-    /* specific case for getter/setter */
-    start_ptr = s->token.ptr;
-
-    prop_type = js_parse_property_name (s, &name, TRUE, TRUE);
-    if (prop_type < 0) goto fail;
-
-    if (prop_type == PROP_TYPE_VAR) {
-      /* shortcut for x: x */
-      emit_op (s, OP_scope_get_var);
-      emit_key (s, name);
-      emit_u16 (s, s->cur_func->scope_level);
-      emit_op (s, OP_define_field);
-      emit_prop_key (s, name);
-    } else if (s->token.val == '(') {
-      JSParseFunctionEnum func_type;
-      int op_flags;
-
-      func_type = JS_PARSE_FUNC_METHOD;
-      if (js_parse_function_decl (s, func_type, JS_NULL, start_ptr)) goto fail;
-      if (JS_IsNull (name)) {
-        emit_op (s, OP_define_method_computed);
-      } else {
-        emit_op (s, OP_define_method);
-        emit_key (s, name);
-      }
-
-      op_flags = OP_DEFINE_METHOD_METHOD;
-      emit_u8 (s, op_flags | OP_DEFINE_METHOD_ENUMERABLE);
-    } else {
-      if (JS_IsNull (name)) {
-        /* must be done before evaluating expr */
-        emit_op (s, OP_to_propkey);
-      }
-      if (js_parse_expect (s, ':')) goto fail;
-      if (js_parse_assign_expr (s)) goto fail;
-      if (JS_IsNull (name)) {
-        set_object_name_computed (s);
-        emit_op (s, OP_define_array_el);
-        emit_op (s, OP_drop);
-      } else {
-        set_object_name (s, name);
-        emit_op (s, OP_define_field);
-        emit_prop_key (s, name);
-      }
-    }
-    name = JS_NULL;
-    if (s->token.val != ',') break;
-    if (next_token (s)) goto fail;
-  }
-  if (js_parse_expect (s, '}')) goto fail;
-  return 0;
-fail:
-  return -1;
-}
-
-/* allow the 'in' binary operator */
-#define PF_IN_ACCEPTED (1 << 0)
-/* allow function calls parsing in js_parse_postfix_expr() */
-#define PF_POSTFIX_CALL (1 << 1)
-/* allow the exponentiation operator in js_parse_unary() */
-#define PF_POW_ALLOWED (1 << 2)
-/* forbid the exponentiation operator in js_parse_unary() */
-#define PF_POW_FORBIDDEN (1 << 3)
-
-static __exception int js_parse_postfix_expr (JSParseState *s,
-                                              int parse_flags);
-
-static JSFunctionDef *
-js_new_function_def (JSContext *ctx, JSFunctionDef *parent, BOOL is_func_expr, const char *filename, const uint8_t *source_ptr, GetLineColCache *get_line_col_cache);
-static void emit_return (JSParseState *s, BOOL hasval);
-
-static __exception int js_parse_left_hand_side_expr (JSParseState *s) {
-  return js_parse_postfix_expr (s, PF_POSTFIX_CALL);
-}
-
-#define ARRAY_LITERAL_MAX 1024
-
-static __exception int js_parse_array_literal (JSParseState *s) {
-  uint32_t idx = 0;
-
-  if (next_token (s)) return -1;
-
-  while (s->token.val != ']' && idx < ARRAY_LITERAL_MAX) {
-    if (s->token.val == ',')
-      return js_parse_error (s, "array holes not allowed");
-
-    if (js_parse_assign_expr (s)) return -1;
-    idx++;
-
-    if (s->token.val == ',') {
-      if (next_token (s)) return -1;
-    } else if (s->token.val != ']') {
-      return js_parse_error (s, "expected ',' or ']'");
-    }
-  }
-
-  if (s->token.val != ']') return js_parse_error (s, "array literal too long");
-
-  emit_op (s, OP_array_from);
-  emit_u16 (s, idx);
-  return js_parse_expect (s, ']');
-}
-
-static __exception int get_lvalue (JSParseState *s, int *popcode, int *pscope, JSValue *pname, int *plabel, int *pdepth, BOOL keep, int tok) {
-  JSFunctionDef *fd;
-  int opcode, scope, label, depth;
-  JSValue name;
-
-  /* we check the last opcode to get the lvalue type */
-  fd = s->cur_func;
-  scope = 0;
-  name = JS_NULL;
-  label = -1;
-  depth = 0;
-  switch (opcode = get_prev_opcode (fd)) {
-  case OP_scope_get_var: {
-    /* Read cpool index and get key from cpool */
-    uint32_t idx = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1);
-    scope = get_u16 (fd->byte_code.buf + fd->last_opcode_pos + 5);
-    name = fd->cpool[idx];
-    if (js_key_equal_str (name, "eval")) {
-      return js_parse_error (s, "invalid lvalue in strict mode");
-    }
-    if (js_key_equal_str (name, "this")
-        || js_key_equal_str (name, "new.target")) {
-      goto invalid_lvalue;
-    }
-    /* Variable lvalue: depth=0, no reference objects on stack */
-    depth = 0;
-    break;
-  }
-  case OP_get_field: {
-    /* Read cpool index and get property name from cpool */
-    uint32_t idx = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1);
-    name = fd->cpool[idx];
-    depth = 1;
-    break;
-  }
-  case OP_get_array_el:
-    depth = 2;
-    break;
-  default:
-  invalid_lvalue:
-    if (tok == TOK_FOR) {
-      return js_parse_error (s, "invalid for in/of left hand-side");
-    } else if (tok == TOK_INC || tok == TOK_DEC) {
-      return js_parse_error (s, "invalid increment/decrement operand");
-    } else if (tok == '[' || tok == '{') {
-      return js_parse_error (s, "invalid destructuring target");
-    } else {
-      return js_parse_error (s, "invalid assignment left-hand side");
-    }
-  }
-  /* remove the last opcode */
-  fd->byte_code.size = fd->last_opcode_pos;
-  fd->last_opcode_pos = -1;
-
-  if (keep) {
-    /* get the value but keep the object/fields on the stack */
-    switch (opcode) {
-    case OP_scope_get_var:
-      /* For variable lvalues, just re-emit the get to have the value on stack.
-         No reference objects needed - put_lvalue will emit scope_put_var directly. */
-      emit_op (s, OP_scope_get_var);
-      emit_key (s, name);
-      emit_u16 (s, scope);
-      break;
-    case OP_get_field:
-      emit_op (s, OP_get_field2);
-      emit_prop_key (s, name);
-      break;
-    case OP_get_array_el:
-      emit_op (s, OP_get_array_el3);
-      break;
-    default:
-      abort ();
-    }
-  }
-  /* For variable lvalues without keep, nothing needs to be emitted.
-     put_lvalue will handle the store with just the value on stack. */
-
-  *popcode = opcode;
-  *pscope = scope;
-  /* name is set for OP_get_field, OP_scope_get_var, and JS_NULL for array_el */
-  *pname = name;
-  *plabel = label;
-  if (pdepth) *pdepth = depth;
-  return 0;
-}
-
-typedef enum {
-  PUT_LVALUE_NOKEEP,        /* [depth] v -> */
-  PUT_LVALUE_NOKEEP_DEPTH,  /* [depth] v -> , keep depth (currently
-                               just disable optimizations) */
-  PUT_LVALUE_KEEP_TOP,      /* [depth] v -> v */
-  PUT_LVALUE_KEEP_SECOND,   /* [depth] v0 v -> v0 */
-  PUT_LVALUE_NOKEEP_BOTTOM, /* v [depth] -> */
-} PutLValueEnum;
-
-/* name has a live reference. 'is_let' is only used with opcode =
-   OP_scope_get_var for variable lvalues (no reference objects on stack). */
-static void put_lvalue (JSParseState *s, int opcode, int scope, JSValue name, int label, PutLValueEnum special, BOOL is_let) {
-  switch (opcode) {
-  case OP_scope_get_var:
-    /* depth = 0 for variable lvalues - no reference objects on stack */
-    switch (special) {
-    case PUT_LVALUE_NOKEEP:
-    case PUT_LVALUE_NOKEEP_DEPTH:
-      /* val -> (store, nothing left) */
-      break;
-    case PUT_LVALUE_KEEP_TOP:
-      /* val -> val (dup before store) */
-      emit_op (s, OP_dup);
-      break;
-    case PUT_LVALUE_KEEP_SECOND:
-      /* v0 v -> v0 (store v, keep v0) - for postfix ++/-- */
-      /* stack: old_val new_val, store new_val, result is old_val */
-      break;
-    case PUT_LVALUE_NOKEEP_BOTTOM:
-      /* val -> (same as NOKEEP for depth=0) */
-      break;
-    default:
-      abort ();
-    }
-    break;
-  case OP_get_field:
-    /* depth = 1 */
-    switch (special) {
-    case PUT_LVALUE_NOKEEP:
-    case PUT_LVALUE_NOKEEP_DEPTH:
-      break;
-    case PUT_LVALUE_KEEP_TOP:
-      emit_op (s, OP_insert2); /* obj v -> v obj v */
-      break;
-    case PUT_LVALUE_KEEP_SECOND:
-      emit_op (s, OP_perm3); /* obj v0 v -> v0 obj v */
-      break;
-    case PUT_LVALUE_NOKEEP_BOTTOM:
-      emit_op (s, OP_swap);
-      break;
-    default:
-      abort ();
-    }
-    break;
-  case OP_get_array_el:
-    /* depth = 2 */
-    switch (special) {
-    case PUT_LVALUE_NOKEEP:
-      emit_op (s, OP_nop); /* will trigger optimization */
-      break;
-    case PUT_LVALUE_NOKEEP_DEPTH:
-      break;
-    case PUT_LVALUE_KEEP_TOP:
-      emit_op (s, OP_insert3); /* obj prop v -> v obj prop v */
-      break;
-    case PUT_LVALUE_KEEP_SECOND:
-      emit_op (s, OP_perm4); /* obj prop v0 v -> v0 obj prop v */
-      break;
-    case PUT_LVALUE_NOKEEP_BOTTOM:
-      emit_op (s, OP_rot3l);
-      break;
-    default:
-      abort ();
-    }
-    break;
-  default:
-    break;
-  }
-
-  switch (opcode) {
-  case OP_scope_get_var: /* val -> */
-    emit_op (s, is_let ? OP_scope_put_var_init : OP_scope_put_var);
-    emit_key (s, name); /* emit cpool index */
-    emit_u16 (s, scope);
-    break;
-  case OP_get_field:
-    emit_op (s, OP_put_field);
-    emit_prop_key (s, name); /* name has refcount */
-    break;
-  case OP_get_array_el:
-    emit_op (s, OP_put_array_el);
-    break;
-  default:
-    abort ();
-  }
-}
-
-static __exception int js_parse_expr_paren (JSParseState *s) {
-  if (js_parse_expect (s, '(')) return -1;
-  if (js_parse_expr (s)) return -1;
-  if (js_parse_expect (s, ')')) return -1;
-  return 0;
-}
-
-static int js_unsupported_keyword (JSParseState *s, JSValue key) {
-  char buf[KEY_GET_STR_BUF_SIZE];
-  return js_parse_error (s, "unsupported keyword: %s", JS_KeyGetStr (s->ctx, buf, sizeof (buf), key));
-}
-
-static __exception int js_define_var (JSParseState *s, JSValue name, int tok) {
-  JSFunctionDef *fd = s->cur_func;
-  JSVarDefEnum var_def_type;
-
-  if (js_key_equal (name, JS_KEY_eval)) {
-    return js_parse_error (s, "invalid variable name in strict mode");
-  }
-  if (js_key_equal (name, JS_KEY_let) && tok == TOK_DEF) {
-    return js_parse_error (s, "invalid lexical variable name");
-  }
-  switch (tok) {
-  case TOK_DEF:
-    var_def_type = JS_VAR_DEF_CONST;
-    break;
-  case TOK_VAR:
-    var_def_type = JS_VAR_DEF_LET;
-    break;
-  case TOK_DISRUPTION:
-    var_def_type = JS_VAR_DEF_CATCH;
-    break;
-  default:
-    abort ();
-  }
-  if (define_var (s, fd, name, var_def_type) < 0) return -1;
-  return 0;
-}
-
-static int js_parse_check_duplicate_parameter (JSParseState *s, JSValue name) {
-  /* Check for duplicate parameter names */
-  JSFunctionDef *fd = s->cur_func;
-  int i;
-  for (i = 0; i < fd->arg_count; i++) {
-    if (js_key_equal (fd->args[i].var_name, name)) goto duplicate;
-  }
-  for (i = 0; i < fd->var_count; i++) {
-    if (js_key_equal (fd->vars[i].var_name, name)) goto duplicate;
-  }
-  return 0;
-
-duplicate:
-  return js_parse_error (
-    s, "duplicate parameter names not allowed in this context");
-}
-
-static JSValue js_parse_destructuring_var (JSParseState *s, int tok, int is_arg) {
-  JSValue name;
-
-  if (!(s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved)
-      || js_key_equal (s->token.u.ident.str, JS_KEY_eval)) {
-    js_parse_error (s, "invalid destructuring target");
-    return JS_NULL;
-  }
-  name = s->token.u.ident.str;
-  if (is_arg && js_parse_check_duplicate_parameter (s, name)) goto fail;
-  if (next_token (s)) goto fail;
-
-  return name;
-fail:
-  return JS_NULL;
-}
-
-/* Return -1 if error, 0 if no initializer, 1 if an initializer is
-   present at the top level. */
-static int js_parse_destructuring_element (JSParseState *s, int tok, int is_arg, int hasval, BOOL allow_initializer, BOOL export_flag) {
-  int label_parse, label_assign, label_done, label_lvalue, depth_lvalue;
-  int start_addr, assign_addr;
-  JSValue prop_name, var_name;
-  int opcode, scope, tok1, skip_bits;
-  BOOL has_initializer;
-
-  label_parse = new_label (s);
-  label_assign = new_label (s);
-
-  start_addr = s->cur_func->byte_code.size;
-  if (hasval) {
-    /* consume value from the stack */
-    emit_op (s, OP_dup);
-    emit_op (s, OP_null);
-    emit_op (s, OP_strict_eq);
-    emit_goto (s, OP_if_true, label_parse);
-    emit_label (s, label_assign);
-  } else {
-    emit_goto (s, OP_goto, label_parse);
-    emit_label (s, label_assign);
-    /* leave value on the stack */
-    emit_op (s, OP_dup);
-  }
-  assign_addr = s->cur_func->byte_code.size;
-  if (s->token.val == '{') {
-    if (next_token (s)) return -1;
-    /* XXX: throw an exception if the value cannot be converted to an object */
-    while (s->token.val != '}') {
-      int prop_type;
-      prop_type = js_parse_property_name (s, &prop_name, FALSE, TRUE);
-      if (prop_type < 0) return -1;
-      var_name = JS_NULL;
-      if (prop_type == PROP_TYPE_IDENT) {
-        if (next_token (s)) goto prop_error;
-        if ((s->token.val == '[' || s->token.val == '{')
-            && ((tok1 = js_parse_skip_parens_token (s, &skip_bits, FALSE))
-                  == ','
-                || tok1 == '=' || tok1 == '}')) {
-          if (JS_IsNull (prop_name)) {
-            /* computed property name on stack */
-            /* get the computed property from the source object */
-            emit_op (s, OP_get_array_el2);
-          } else {
-            /* named property */
-            /* get the named property from the source object */
-            emit_op (s, OP_get_field2);
-            emit_prop_key (s, prop_name);
-          }
-          if (js_parse_destructuring_element (s, tok, is_arg, TRUE, TRUE, export_flag)
-              < 0)
-            return -1;
-          if (s->token.val == '}') break;
-          /* accept a trailing comma before the '}' */
-          if (js_parse_expect (s, ',')) return -1;
-          continue;
-        }
-        if (JS_IsNull (prop_name)) {
-          emit_op (s, OP_to_propkey);
-          /* source prop -- source source prop */
-          emit_op (s, OP_dup1);
-        } else {
-          /* source -- source source */
-          emit_op (s, OP_dup);
-        }
-        if (tok) {
-          var_name = js_parse_destructuring_var (s, tok, is_arg);
-          if (JS_IsNull (var_name)) goto prop_error;
-          /* no need to make a reference for let/const */
-          opcode = OP_scope_get_var;
-          scope = s->cur_func->scope_level;
-          label_lvalue = -1;
-          depth_lvalue = 0;
-        } else {
-          if (js_parse_left_hand_side_expr (s)) goto prop_error;
-        lvalue1:
-          if (get_lvalue (s, &opcode, &scope, &var_name, &label_lvalue, &depth_lvalue, FALSE, '{'))
-            goto prop_error;
-          /* swap ref and lvalue object if any */
-          if (JS_IsNull (prop_name)) {
-            switch (depth_lvalue) {
-            case 1:
-              /* source prop x -> x source prop */
-              emit_op (s, OP_rot3r);
-              break;
-            case 2:
-              /* source prop x y -> x y source prop */
-              emit_op (s, OP_swap2); /* t p2 s p1 */
-              break;
-            case 3:
-              /* source prop x y z -> x y z source prop */
-              emit_op (s, OP_rot5l);
-              emit_op (s, OP_rot5l);
-              break;
-            }
-          } else {
-            switch (depth_lvalue) {
-            case 1:
-              /* source x -> x source */
-              emit_op (s, OP_swap);
-              break;
-            case 2:
-              /* source x y -> x y source */
-              emit_op (s, OP_rot3l);
-              break;
-            case 3:
-              /* source x y z -> x y z source */
-              emit_op (s, OP_rot4l);
-              break;
-            }
-          }
-        }
-        if (JS_IsNull (prop_name)) {
-          /* computed property name on stack */
-          /* XXX: should have OP_get_array_el2x with depth */
-          /* source prop -- val */
-          emit_op (s, OP_get_array_el);
-        } else {
-          /* named property */
-          /* XXX: should have OP_get_field2x with depth */
-          /* source -- val */
-          emit_op (s, OP_get_field);
-          emit_prop_key (s, prop_name);
-        }
-      } else {
-        /* prop_type = PROP_TYPE_VAR, cannot be a computed property */
-        if (is_arg && js_parse_check_duplicate_parameter (s, prop_name))
-          goto prop_error;
-        if (js_key_equal_str (prop_name, "eval")) {
-          js_parse_error (s, "invalid destructuring target");
-          goto prop_error;
-        }
-        if (!tok) {
-          /* generate reference */
-          /* source -- source source */
-          emit_op (s, OP_dup);
-          emit_op (s, OP_scope_get_var);
-          emit_key (s, prop_name);
-          emit_u16 (s, s->cur_func->scope_level);
-          goto lvalue1;
-        } else {
-          /* no need to make a reference for let/const */
-          var_name = prop_name;
-          opcode = OP_scope_get_var;
-          scope = s->cur_func->scope_level;
-          label_lvalue = -1;
-          depth_lvalue = 0;
-
-          /* source -- source val */
-          emit_op (s, OP_get_field2);
-          emit_prop_key (s, prop_name);
-        }
-      }
-      if (tok) {
-        if (js_define_var (s, var_name, tok)) goto var_error;
-        scope = s->cur_func->scope_level; /* XXX: check */
-      }
-      if (s->token.val == '=') { /* handle optional default value */
-        int label_hasval;
-        emit_op (s, OP_dup);
-        emit_op (s, OP_null);
-        emit_op (s, OP_strict_eq);
-        label_hasval = emit_goto (s, OP_if_false, -1);
-        if (next_token (s)) goto var_error;
-        emit_op (s, OP_drop);
-        if (js_parse_assign_expr (s)) goto var_error;
-        if (opcode == OP_scope_get_var)
-          set_object_name (s, var_name);
-        emit_label (s, label_hasval);
-      }
-      /* store value into lvalue object */
-      put_lvalue (s, opcode, scope, var_name, label_lvalue, PUT_LVALUE_NOKEEP_DEPTH, (tok == TOK_DEF || tok == TOK_VAR));
-      if (s->token.val == '}') break;
-      /* accept a trailing comma before the '}' */
-      if (js_parse_expect (s, ',')) return -1;
-    }
-    /* drop the source object */
-    emit_op (s, OP_drop);
-    if (next_token (s)) return -1;
-  } else if (s->token.val == '[') {
-    return js_parse_error (s, "array destructuring is not supported");
-  } else {
-    return js_parse_error (s, "invalid assignment syntax");
-  }
-  if (s->token.val == '=' && allow_initializer) {
-    label_done = emit_goto (s, OP_goto, -1);
-    if (next_token (s)) return -1;
-    emit_label (s, label_parse);
-    if (hasval) emit_op (s, OP_drop);
-    if (js_parse_assign_expr (s)) return -1;
-    emit_goto (s, OP_goto, label_assign);
-    emit_label (s, label_done);
-    has_initializer = TRUE;
-  } else {
-    /* normally hasval is true except if
-       js_parse_skip_parens_token() was wrong in the parsing */
-    //        assert(hasval);
-    if (!hasval) {
-      js_parse_error (s, "too complicated destructuring expression");
-      return -1;
-    }
-    /* remove test and decrement label ref count */
-    memset (s->cur_func->byte_code.buf + start_addr, OP_nop, assign_addr - start_addr);
-    s->cur_func->label_slots[label_parse].ref_count--;
-    has_initializer = FALSE;
-  }
-  return has_initializer;
-
-prop_error:
-var_error:
-  return -1;
-}
-
-static void optional_chain_test (JSParseState *s,
-                                 int *poptional_chaining_label,
-                                 int drop_count) {
-  int label_next, i;
-  if (*poptional_chaining_label < 0) *poptional_chaining_label = new_label (s);
-  /* XXX: could be more efficient with a specific opcode */
-  emit_op (s, OP_dup);
-  emit_op (s, OP_is_null);
-  label_next = emit_goto (s, OP_if_false, -1);
-  for (i = 0; i < drop_count; i++)
-    emit_op (s, OP_drop);
-  emit_op (s, OP_null);
-  emit_goto (s, OP_goto, *poptional_chaining_label);
-  emit_label (s, label_next);
-}
-
-/* allowed parse_flags: PF_POSTFIX_CALL */
-static __exception int js_parse_postfix_expr (JSParseState *s,
-                                              int parse_flags) {
-  int optional_chaining_label;
-  BOOL accept_lparen = (parse_flags & PF_POSTFIX_CALL) != 0;
-  const uint8_t *op_token_ptr;
-
-  switch (s->token.val) {
-  case TOK_NUMBER: {
-    JSValue val;
-    val = s->token.u.num.val;
-
-    if (JS_VALUE_GET_TAG (val) == JS_TAG_INT) {
-      emit_op (s, OP_push_i32);
-      emit_u32 (s, JS_VALUE_GET_INT (val));
-    } else {
-      if (emit_push_const (s, val) < 0) return -1;
-    }
-  }
-    if (next_token (s)) return -1;
-    break;
-  case TOK_TEMPLATE:
-    if (js_parse_template (s)) return -1;
-    break;
-  case TOK_STRING:
-    if (emit_push_const (s, s->token.u.str.str)) return -1;
-    if (next_token (s)) return -1;
-    break;
-
-  case TOK_DIV_ASSIGN:
-    s->buf_ptr -= 2;
-    goto parse_regexp;
-  case '/':
-    s->buf_ptr--;
-  parse_regexp: {
-    JSValue str;
-    int ret;
-    if (!s->ctx->compile_regexp)
-      return js_parse_error (s, "RegExp are not supported");
-    /* the previous token is '/' or '/=', so no need to free */
-    if (js_parse_regexp (s)) return -1;
-    ret = emit_push_const (s, s->token.u.regexp.body);
-    str = s->ctx->compile_regexp (s->ctx, s->token.u.regexp.body, s->token.u.regexp.flags);
-    if (JS_IsException (str)) {
-      /* add the line number info */
-      int line_num, col_num;
-      line_num
-        = get_line_col (&col_num, s->buf_start, s->token.ptr - s->buf_start);
-      build_backtrace (s->ctx, s->ctx->current_exception, s->filename, line_num + 1, col_num + 1, 0);
-      return -1;
-    }
-    ret = emit_push_const (s, str);
-    if (ret) return -1;
-    /* we use a specific opcode to be sure the correct
-       function is called (otherwise the bytecode would have
-       to be verified by the RegExp constructor) */
-    emit_op (s, OP_regexp);
-    if (next_token (s)) return -1;
-  } break;
-  case '(':
-    if (js_parse_expr_paren (s)) return -1;
-    break;
-  case TOK_FUNCTION:
-    if (js_parse_function_decl (s, JS_PARSE_FUNC_EXPR, JS_NULL, s->token.ptr))
-      return -1;
-    break;
-  case TOK_NULL:
-    if (next_token (s)) return -1;
-    emit_op (s, OP_null);
-    break;
-  case TOK_THIS:
-    if (next_token (s)) return -1;
-    emit_op (s, OP_scope_get_var);
-    emit_key (s, JS_KEY_this);
-    emit_u16 (s, 0);
-    break;
-  case TOK_FALSE:
-    if (next_token (s)) return -1;
-    emit_op (s, OP_push_false);
-    break;
-  case TOK_TRUE:
-    if (next_token (s)) return -1;
-    emit_op (s, OP_push_true);
-    break;
-  case TOK_IDENT: {
-    JSValue name;
-    const uint8_t *source_ptr;
-    if (s->token.u.ident.is_reserved) {
-      return js_parse_error_reserved_identifier (s);
-    }
-    source_ptr = s->token.ptr;
-    name = s->token.u.ident.str;
-    if (next_token (s)) {
-      return -1;
-    }
-    emit_source_pos (s, source_ptr);
-    emit_op (s, OP_scope_get_var);
-    emit_key (s, name);
-    emit_u16 (s, s->cur_func->scope_level);
-  } break;
-  case '{':
-  case '[':
-    if (s->token.val == '{') {
-      if (js_parse_object_literal (s)) return -1;
-    } else {
-      if (js_parse_array_literal (s)) return -1;
-    }
-    break;
-  default:
-    return js_parse_error (s, "unexpected token in expression: '%.*s'", (int)(s->buf_ptr - s->token.ptr), s->token.ptr);
-  }
-
-  optional_chaining_label = -1;
-  for (;;) {
-    JSFunctionDef *fd = s->cur_func;
-    BOOL has_optional_chain = FALSE;
-
-    if (s->token.val == '(' && accept_lparen) {
-      int opcode, arg_count, drop_count;
-
-      /* function call */
-    parse_func_call:
-      op_token_ptr = s->token.ptr;
-      if (next_token (s)) return -1;
-
-      switch (opcode = get_prev_opcode (fd)) {
-      case OP_get_field:
-        /* keep the object on the stack */
-        fd->byte_code.buf[fd->last_opcode_pos] = OP_get_field2;
-        drop_count = 2;
-        break;
-      case OP_get_field_opt_chain: {
-        int opt_chain_label, next_label;
-        opt_chain_label
-          = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1 + 4 + 1);
-        /* keep the object on the stack */
-        fd->byte_code.buf[fd->last_opcode_pos] = OP_get_field2;
-        fd->byte_code.size = fd->last_opcode_pos + 1 + 4;
-        next_label = emit_goto (s, OP_goto, -1);
-        emit_label (s, opt_chain_label);
-        /* need an additional undefined value for the
-           case where the optional field does not
-           exists */
-        emit_op (s, OP_null);
-        emit_label (s, next_label);
-        drop_count = 2;
-        opcode = OP_get_field;
-      } break;
-      case OP_get_array_el:
-        /* keep the object on the stack */
-        fd->byte_code.buf[fd->last_opcode_pos] = OP_get_array_el2;
-        drop_count = 2;
-        break;
-      case OP_get_array_el_opt_chain: {
-        int opt_chain_label, next_label;
-        opt_chain_label
-          = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1 + 1);
-        /* keep the object on the stack */
-        fd->byte_code.buf[fd->last_opcode_pos] = OP_get_array_el2;
-        fd->byte_code.size = fd->last_opcode_pos + 1;
-        next_label = emit_goto (s, OP_goto, -1);
-        emit_label (s, opt_chain_label);
-        /* need an additional undefined value for the
-           case where the optional field does not
-           exists */
-        emit_op (s, OP_null);
-        emit_label (s, next_label);
-        drop_count = 2;
-        opcode = OP_get_array_el;
-      } break;
-      case OP_scope_get_var: {
-        /* verify if function name resolves to a simple
-           get_loc/get_arg: a function call inside a `with`
-           statement can resolve to a method call of the
-           `with` context object
-         */
-        drop_count = 1;
-      } break;
-      default:
-        opcode = OP_invalid;
-        drop_count = 1;
-        break;
-      }
-      if (has_optional_chain) {
-        optional_chain_test (s, &optional_chaining_label, drop_count);
-      }
-
-      /* parse arguments */
-      arg_count = 0;
-      while (s->token.val != ')') {
-        if (arg_count >= 65535) {
-          return js_parse_error (s, "Too many call arguments");
-        }
-        if (js_parse_assign_expr (s)) return -1;
-        arg_count++;
-        if (s->token.val == ')') break;
-        /* accept a trailing comma before the ')' */
-        if (js_parse_expect (s, ',')) return -1;
-      }
-      if (next_token (s)) return -1;
-    emit_func_call: {
-      emit_source_pos (s, op_token_ptr);
-      switch (opcode) {
-      case OP_get_field:
-      case OP_get_array_el:
-        emit_op (s, OP_call_method);
-        emit_u16 (s, arg_count);
-        break;
-      default:
-        emit_op (s, OP_call);
-        emit_u16 (s, arg_count);
-        break;
-      }
-    }
-    } else if (s->token.val == '.') {
-      op_token_ptr = s->token.ptr;
-      if (next_token (s)) return -1;
-    parse_property:
-      emit_source_pos (s, op_token_ptr);
-      if (!token_is_ident (s->token.val)) {
-        return js_parse_error (s, "expecting field name");
-      }
-      if (has_optional_chain) {
-        optional_chain_test (s, &optional_chaining_label, 1);
-      }
-      emit_op (s, OP_get_field);
-      emit_prop_key (s, s->token.u.ident.str);
-      if (next_token (s)) return -1;
-    } else if (s->token.val == '[') {
-      op_token_ptr = s->token.ptr;
-    parse_array_access:
-      if (has_optional_chain) {
-        optional_chain_test (s, &optional_chaining_label, 1);
-      }
-      if (next_token (s)) return -1;
-      if (js_parse_expr (s)) return -1;
-      if (js_parse_expect (s, ']')) return -1;
-      emit_source_pos (s, op_token_ptr);
-      emit_op (s, OP_get_array_el);
-    } else {
-      break;
-    }
-  }
-  if (optional_chaining_label >= 0) {
-    JSFunctionDef *fd = s->cur_func;
-    int opcode;
-    emit_label_raw (s, optional_chaining_label);
-    /* modify the last opcode so that it is an indicator of an
-       optional chain */
-    opcode = get_prev_opcode (fd);
-    if (opcode == OP_get_field || opcode == OP_get_array_el) {
-      if (opcode == OP_get_field)
-        opcode = OP_get_field_opt_chain;
-      else
-        opcode = OP_get_array_el_opt_chain;
-      fd->byte_code.buf[fd->last_opcode_pos] = opcode;
-    } else {
-      fd->last_opcode_pos = -1;
-    }
-  }
-  return 0;
-}
-
-static __exception int js_parse_delete (JSParseState *s) {
-  JSFunctionDef *fd = s->cur_func;
-  int opcode;
-
-  if (next_token (s)) return -1;
-  if (js_parse_unary (s, PF_POW_FORBIDDEN)) return -1;
-  switch (opcode = get_prev_opcode (fd)) {
-  case OP_get_field:
-  case OP_get_field_opt_chain: {
-    JSValue val;
-    int ret, opt_chain_label, next_label;
-    if (opcode == OP_get_field_opt_chain) {
-      opt_chain_label
-        = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1 + 4 + 1);
-    } else {
-      opt_chain_label = -1;
-    }
-    {
-      /* Read cpool index and get property name from cpool */
-      uint32_t idx = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1);
-      val = fd->cpool[idx];
-    }
-    fd->byte_code.size = fd->last_opcode_pos;
-    ret = emit_push_const (s, val);
-    if (ret) return ret;
-    emit_op (s, OP_delete);
-    if (opt_chain_label >= 0) {
-      next_label = emit_goto (s, OP_goto, -1);
-      emit_label (s, opt_chain_label);
-      /* if the optional chain is not taken, return 'true' */
-      emit_op (s, OP_drop);
-      emit_op (s, OP_push_true);
-      emit_label (s, next_label);
-    }
-    fd->last_opcode_pos = -1;
-  } break;
-  case OP_get_array_el:
-    fd->byte_code.size = fd->last_opcode_pos;
-    fd->last_opcode_pos = -1;
-    emit_op (s, OP_delete);
-    break;
-  case OP_get_array_el_opt_chain: {
-    int opt_chain_label, next_label;
-    opt_chain_label
-      = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1 + 1);
-    fd->byte_code.size = fd->last_opcode_pos;
-    emit_op (s, OP_delete);
-    next_label = emit_goto (s, OP_goto, -1);
-    emit_label (s, opt_chain_label);
-    /* if the optional chain is not taken, return 'true' */
-    emit_op (s, OP_drop);
-    emit_op (s, OP_push_true);
-    emit_label (s, next_label);
-    fd->last_opcode_pos = -1;
-  } break;
-  case OP_scope_get_var: {
-    /* 'delete this': this is not a reference */
-    uint32_t idx = get_u32 (fd->byte_code.buf + fd->last_opcode_pos + 1);
-    JSValue name = fd->cpool[idx];
-    if (js_key_equal (name, JS_KEY_this)
-        || js_key_equal_str (name, "new.target"))
-      goto ret_true;
-
-    return js_parse_error (s,
-                           "cannot delete a direct reference in strict mode");
-  } break;
-  default:
-  ret_true:
-    emit_op (s, OP_drop);
-    emit_op (s, OP_push_true);
-    break;
-  }
-  return 0;
-}
-
-/* allowed parse_flags: PF_POW_ALLOWED, PF_POW_FORBIDDEN */
-static __exception int js_parse_unary (JSParseState *s, int parse_flags) {
-  int op;
-  const uint8_t *op_token_ptr;
-
-  switch (s->token.val) {
-  case '+':
-  case '-':
-  case '!':
-  case '~':
-    op_token_ptr = s->token.ptr;
-    op = s->token.val;
-    if (next_token (s)) return -1;
-    if (js_parse_unary (s, PF_POW_FORBIDDEN)) return -1;
-    switch (op) {
-    case '-':
-      emit_source_pos (s, op_token_ptr);
-      emit_op (s, OP_neg);
-      break;
-    case '+':
-      emit_source_pos (s, op_token_ptr);
-      emit_op (s, OP_plus);
-      break;
-    case '!':
-      emit_op (s, OP_lnot);
-      break;
-    case '~':
-      emit_source_pos (s, op_token_ptr);
-      emit_op (s, OP_not);
-      break;
-    default:
-      abort ();
-    }
-    parse_flags = 0;
-    break;
-  case TOK_DEC:
-  case TOK_INC: {
-    int opcode, op, scope, label;
-    JSValue name;
-    op = s->token.val;
-    op_token_ptr = s->token.ptr;
-    if (next_token (s)) return -1;
-    if (js_parse_unary (s, 0)) return -1;
-    if (get_lvalue (s, &opcode, &scope, &name, &label, NULL, TRUE, op))
-      return -1;
-    emit_source_pos (s, op_token_ptr);
-    emit_op (s, OP_dec + op - TOK_DEC);
-    put_lvalue (s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP, FALSE);
-  } break;
-  case TOK_DELETE:
-    if (js_parse_delete (s)) return -1;
-    parse_flags = 0;
-    break;
-  default:
-    if (js_parse_postfix_expr (s, PF_POSTFIX_CALL)) return -1;
-    if (!s->got_lf && (s->token.val == TOK_DEC || s->token.val == TOK_INC)) {
-      int opcode, op, scope, label;
-      JSValue name;
-      op = s->token.val;
-      op_token_ptr = s->token.ptr;
-      if (get_lvalue (s, &opcode, &scope, &name, &label, NULL, TRUE, op))
-        return -1;
-      emit_source_pos (s, op_token_ptr);
-      emit_op (s, OP_post_dec + op - TOK_DEC);
-      put_lvalue (s, opcode, scope, name, label, PUT_LVALUE_KEEP_SECOND, FALSE);
-      if (next_token (s)) return -1;
-    }
-    break;
-  }
-  if (parse_flags & (PF_POW_ALLOWED | PF_POW_FORBIDDEN)) {
-    if (s->token.val == TOK_POW) {
-      /* Strict ES7 exponentiation syntax rules: To solve
-         conficting semantics between different implementations
-         regarding the precedence of prefix operators and the
-         postifx exponential, ES7 specifies that -2**2 is a
-         syntax error. */
-      if (parse_flags & PF_POW_FORBIDDEN) {
-        JS_ThrowSyntaxError (s->ctx, "unparenthesized unary expression can't "
-                                     "appear on the left-hand side of '**'");
-        return -1;
-      }
-      op_token_ptr = s->token.ptr;
-      if (next_token (s)) return -1;
-      if (js_parse_unary (s, PF_POW_ALLOWED)) return -1;
-      emit_source_pos (s, op_token_ptr);
-      emit_op (s, OP_pow);
-    }
-  }
-  return 0;
-}
-
-/* allowed parse_flags: PF_IN_ACCEPTED */
-static __exception int js_parse_expr_binary (JSParseState *s, int level, int parse_flags) {
-  int op, opcode;
-  const uint8_t *op_token_ptr;
-
-  if (level == 0) {
-    return js_parse_unary (s, PF_POW_ALLOWED);
-  } else {
-    if (js_parse_expr_binary (s, level - 1, parse_flags)) return -1;
-  }
-  for (;;) {
-    op = s->token.val;
-    op_token_ptr = s->token.ptr;
-    switch (level) {
-    case 1:
-      switch (op) {
-      case '*':
-        opcode = OP_mul;
-        break;
-      case '/':
-        opcode = OP_div;
-        break;
-      case '%':
-        opcode = OP_mod;
-        break;
-      default:
-        return 0;
-      }
-      break;
-    case 2:
-      switch (op) {
-      case '+':
-        opcode = OP_add;
-        break;
-      case '-':
-        opcode = OP_sub;
-        break;
-      default:
-        return 0;
-      }
-      break;
-    case 3:
-      switch (op) {
-      case TOK_SHL:
-        opcode = OP_shl;
-        break;
-      case TOK_SAR:
-        opcode = OP_sar;
-        break;
-      case TOK_SHR:
-        opcode = OP_shr;
-        break;
-      default:
-        return 0;
-      }
-      break;
-    case 4:
-      switch (op) {
-      case '<':
-        opcode = OP_lt;
-        break;
-      case '>':
-        opcode = OP_gt;
-        break;
-      case TOK_LTE:
-        opcode = OP_lte;
-        break;
-      case TOK_GTE:
-        opcode = OP_gte;
-        break;
-      case TOK_IN:
-        if (parse_flags & PF_IN_ACCEPTED) {
-          opcode = OP_in;
-        } else {
-          return 0;
-        }
-        break;
-      default:
-        return 0;
-      }
-      break;
-    case 5:
-      switch (op) {
-      case TOK_STRICT_EQ:
-        opcode = OP_strict_eq;
-        break;
-      case TOK_STRICT_NEQ:
-        opcode = OP_strict_neq;
-        break;
-      default:
-        return 0;
-      }
-      break;
-    case 6:
-      switch (op) {
-      case '&':
-        opcode = OP_and;
-        break;
-      default:
-        return 0;
-      }
-      break;
-    case 7:
-      switch (op) {
-      case '^':
-        opcode = OP_xor;
-        break;
-      default:
-        return 0;
-      }
-      break;
-    case 8:
-      switch (op) {
-      case '|':
-        opcode = OP_or;
-        break;
-      default:
-        return 0;
-      }
-      break;
-    default:
-      abort ();
-    }
-    if (next_token (s)) return -1;
-    if (js_parse_expr_binary (s, level - 1, parse_flags)) return -1;
-    emit_source_pos (s, op_token_ptr);
-    emit_op (s, opcode);
-  }
-  return 0;
-}
-
-/* allowed parse_flags: PF_IN_ACCEPTED */
-static __exception int js_parse_logical_and_or (JSParseState *s, int op, int parse_flags) {
-  int label1;
-
-  if (op == TOK_LAND) {
-    if (js_parse_expr_binary (s, 8, parse_flags)) return -1;
-  } else {
-    if (js_parse_logical_and_or (s, TOK_LAND, parse_flags)) return -1;
-  }
-  if (s->token.val == op) {
-    label1 = new_label (s);
-
-    for (;;) {
-      if (next_token (s)) return -1;
-      emit_op (s, OP_dup);
-      emit_goto (s, op == TOK_LAND ? OP_if_false : OP_if_true, label1);
-      emit_op (s, OP_drop);
-
-      if (op == TOK_LAND) {
-        if (js_parse_expr_binary (s, 8, parse_flags)) return -1;
-      } else {
-        if (js_parse_logical_and_or (s, TOK_LAND, parse_flags)) return -1;
-      }
-      if (s->token.val != op) {
-        break;
-      }
-    }
-
-    emit_label (s, label1);
-  }
-  return 0;
-}
-
-static __exception int js_parse_coalesce_expr (JSParseState *s,
-                                               int parse_flags) {
-  return js_parse_logical_and_or (s, TOK_LOR, parse_flags);
-}
-
-/* allowed parse_flags: PF_IN_ACCEPTED */
-static __exception int js_parse_cond_expr (JSParseState *s, int parse_flags) {
-  int label1, label2;
-
-  if (js_parse_coalesce_expr (s, parse_flags)) return -1;
-  if (s->token.val == '?') {
-    if (next_token (s)) return -1;
-    label1 = emit_goto (s, OP_if_false, -1);
-
-    if (js_parse_assign_expr (s)) return -1;
-    if (js_parse_expect (s, ':')) return -1;
-
-    label2 = emit_goto (s, OP_goto, -1);
-
-    emit_label (s, label1);
-
-    if (js_parse_assign_expr2 (s, parse_flags & PF_IN_ACCEPTED)) return -1;
-
-    emit_label (s, label2);
-  }
-  return 0;
-}
-
-/* allowed parse_flags: PF_IN_ACCEPTED */
-static __exception int js_parse_assign_expr2 (JSParseState *s,
-                                              int parse_flags) {
-  int opcode, op, scope, skip_bits;
-  JSValue name0 = JS_NULL;
-  JSValue name;
-
-  if (s->token.val == '('
-      && js_parse_skip_parens_token (s, NULL, TRUE) == TOK_ARROW) {
-    return js_parse_function_decl (s, JS_PARSE_FUNC_ARROW, JS_NULL, s->token.ptr);
-  } else if (s->token.val == TOK_IDENT && peek_token (s, TRUE) == TOK_ARROW) {
-    return js_parse_function_decl (s, JS_PARSE_FUNC_ARROW, JS_NULL, s->token.ptr);
-  } else if ((s->token.val == '{' || s->token.val == '[')
-             && js_parse_skip_parens_token (s, &skip_bits, FALSE) == '=') {
-    if (js_parse_destructuring_element (s, 0, 0, FALSE, TRUE, FALSE) < 0)
-      return -1;
-    return 0;
-  }
-  if (s->token.val == TOK_IDENT) {
-    /* name0 is used to check for OP_set_name pattern, not duplicated */
-    name0 = s->token.u.ident.str;
-  }
-  if (js_parse_cond_expr (s, parse_flags)) return -1;
-
-  op = s->token.val;
-  if (op == '=' || (op >= TOK_MUL_ASSIGN && op <= TOK_POW_ASSIGN)) {
-    int label;
-    const uint8_t *op_token_ptr;
-    op_token_ptr = s->token.ptr;
-    if (next_token (s)) return -1;
-    if (get_lvalue (s, &opcode, &scope, &name, &label, NULL, (op != '='), op)
-        < 0)
-      return -1;
-
-    if (js_parse_assign_expr2 (s, parse_flags)) {
-      return -1;
-    }
-
-    if (op == '=') {
-      if (opcode == OP_scope_get_var && js_key_equal (name, name0)) {
-        set_object_name (s, name);
-      }
-    } else {
-      static const uint8_t assign_opcodes[] = {
-        OP_mul,
-        OP_div,
-        OP_mod,
-        OP_add,
-        OP_sub,
-        OP_shl,
-        OP_sar,
-        OP_shr,
-        OP_and,
-        OP_xor,
-        OP_or,
-        OP_pow,
-      };
-      op = assign_opcodes[op - TOK_MUL_ASSIGN];
-      emit_source_pos (s, op_token_ptr);
-      emit_op (s, op);
-    }
-    put_lvalue (s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP, FALSE);
-  } else if (op >= TOK_LAND_ASSIGN && op <= TOK_LOR_ASSIGN) {
-    int label, label1, depth_lvalue, label2;
-
-    if (next_token (s)) return -1;
-    if (get_lvalue (s, &opcode, &scope, &name, &label, &depth_lvalue, TRUE, op)
-        < 0)
-      return -1;
-
-    emit_op (s, OP_dup);
-    label1
-      = emit_goto (s, op == TOK_LOR_ASSIGN ? OP_if_true : OP_if_false, -1);
-    emit_op (s, OP_drop);
-
-    if (js_parse_assign_expr2 (s, parse_flags)) {
-      return -1;
-    }
-
-    if (opcode == OP_scope_get_var && js_key_equal (name, name0)) {
-      set_object_name (s, name);
-    }
-
-    /* For depth=0 (variable lvalues), dup to keep result on stack after put.
-       For depth>=1, insert to put value below reference objects. */
-    switch (depth_lvalue) {
-    case 0:
-      emit_op (s, OP_dup);
-      break;
-    case 1:
-      emit_op (s, OP_insert2);
-      break;
-    case 2:
-      emit_op (s, OP_insert3);
-      break;
-    case 3:
-      emit_op (s, OP_insert4);
-      break;
-    default:
-      abort ();
-    }
-
-    put_lvalue (s, opcode, scope, name, label, PUT_LVALUE_NOKEEP_DEPTH, FALSE);
-    label2 = emit_goto (s, OP_goto, -1);
-
-    emit_label (s, label1);
-
-    /* remove the lvalue stack entries (none for depth=0 variables) */
-    while (depth_lvalue != 0) {
-      emit_op (s, OP_nip);
-      depth_lvalue--;
-    }
-
-    emit_label (s, label2);
-  }
-  return 0;
-}
-
-static __exception int js_parse_assign_expr (JSParseState *s) {
-  return js_parse_assign_expr2 (s, PF_IN_ACCEPTED);
-}
-
-/* allowed parse_flags: PF_IN_ACCEPTED */
-static __exception int js_parse_expr2 (JSParseState *s, int parse_flags) {
-  BOOL comma = FALSE;
-  for (;;) {
-    if (js_parse_assign_expr2 (s, parse_flags)) return -1;
-    if (comma) {
-      /* prevent get_lvalue from using the last expression
-         as an lvalue. This also prevents the conversion of
-         of get_var to get_ref for method lookup in function
-         call inside `with` statement.
-       */
-      s->cur_func->last_opcode_pos = -1;
-    }
-    if (s->token.val != ',') break;
-    comma = TRUE;
-    if (next_token (s)) return -1;
-    emit_op (s, OP_drop);
-  }
-  return 0;
-}
-
-static __exception int js_parse_expr (JSParseState *s) {
-  return js_parse_expr2 (s, PF_IN_ACCEPTED);
-}
-
-static void push_break_entry (JSFunctionDef *fd, BlockEnv *be, JSValue label_name, int label_break, int label_cont, int drop_count) {
-  be->prev = fd->top_break;
-  fd->top_break = be;
-  be->label_name = label_name;
-  be->label_break = label_break;
-  be->label_cont = label_cont;
-  be->drop_count = drop_count;
-  be->label_finally = -1;
-  be->scope_level = fd->scope_level;
-  be->is_regular_stmt = FALSE;
-}
-
-static void pop_break_entry (JSFunctionDef *fd) {
-  BlockEnv *be;
-  be = fd->top_break;
-  fd->top_break = be->prev;
-}
-
-static __exception int emit_break (JSParseState *s, JSValue name, int is_cont) {
-  BlockEnv *top;
-  int i, scope_level;
-
-  scope_level = s->cur_func->scope_level;
-  top = s->cur_func->top_break;
-  while (top != NULL) {
-    close_scopes (s, scope_level, top->scope_level);
-    scope_level = top->scope_level;
-    if (is_cont && top->label_cont != -1
-        && (JS_IsNull (name) || js_key_equal (top->label_name, name))) {
-      /* continue stays inside the same block */
-      emit_goto (s, OP_goto, top->label_cont);
-      return 0;
-    }
-    if (!is_cont && top->label_break != -1
-        && ((JS_IsNull (name) && !top->is_regular_stmt)
-            || js_key_equal (top->label_name, name))) {
-      emit_goto (s, OP_goto, top->label_break);
-      return 0;
-    }
-    for (i = 0; i < top->drop_count; i++)
-      emit_op (s, OP_drop);
-    if (top->label_finally != -1) {
-      /* must push dummy value to keep same stack depth */
-      emit_op (s, OP_null);
-      emit_goto (s, OP_gosub, top->label_finally);
-      emit_op (s, OP_drop);
-    }
-    top = top->prev;
-  }
-  if (JS_IsNull (name)) {
-    if (is_cont)
-      return js_parse_error (s, "continue must be inside loop");
-    else
-      return js_parse_error (s, "break must be inside loop or switch");
-  } else {
-    return js_parse_error (s, "break/continue label not found");
-  }
-}
-
-/* execute the finally blocks before return */
-static void emit_return (JSParseState *s, BOOL hasval) {
-  BlockEnv *top;
-
-  top = s->cur_func->top_break;
-  while (top != NULL) {
-    if (top->label_finally != -1) {
-      if (!hasval) {
-        emit_op (s, OP_null);
-        hasval = TRUE;
-      }
-      /* Remove the stack elements up to and including the catch
-         offset. When 'yield' is used in an expression we have
-         no easy way to count them, so we use this specific
-         instruction instead. */
-      emit_op (s, OP_nip_catch);
-      /* execute the "finally" block */
-      emit_goto (s, OP_gosub, top->label_finally);
-    }
-    top = top->prev;
-  }
-
-  emit_op (s, hasval ? OP_return : OP_return_undef);
-}
-
-#define DECL_MASK_FUNC (1 << 0) /* allow normal function declaration */
-/* ored with DECL_MASK_FUNC if function declarations are allowed with a label
- */
-#define DECL_MASK_FUNC_WITH_LABEL (1 << 1)
-#define DECL_MASK_OTHER (1 << 2) /* all other declarations */
-#define DECL_MASK_ALL \
-  (DECL_MASK_FUNC | DECL_MASK_FUNC_WITH_LABEL | DECL_MASK_OTHER)
-
-static __exception int js_parse_statement_or_decl (JSParseState *s,
-                                                   int decl_mask);
-
-static __exception int js_parse_statement (JSParseState *s) {
-  return js_parse_statement_or_decl (s, 0);
-}
-
-static __exception int js_parse_block (JSParseState *s) {
-  if (js_parse_expect (s, '{')) return -1;
-  if (s->token.val != '}') {
-    push_scope (s);
-    for (;;) {
-      if (js_parse_statement_or_decl (s, DECL_MASK_ALL)) return -1;
-      if (s->token.val == '}') break;
-    }
-    pop_scope (s);
-  }
-  if (next_token (s)) return -1;
-  return 0;
-}
-
-/* allowed parse_flags: PF_IN_ACCEPTED */
-static __exception int js_parse_var (JSParseState *s, int parse_flags, int tok, BOOL export_flag) {
-  JSFunctionDef *fd = s->cur_func;
-  JSValue name = JS_NULL;
-
-  for (;;) {
-    if (s->token.val == TOK_IDENT) {
-      if (s->token.u.ident.is_reserved) {
-        return js_parse_error_reserved_identifier (s);
-      }
-      name = s->token.u.ident.str;
-      if (js_key_equal (name, JS_KEY_let) && tok == TOK_DEF) {
-        js_parse_error (s, "'let' is not a valid lexical identifier");
-        goto var_error;
-      }
-      if (next_token (s)) goto var_error;
-      if (js_define_var (s, name, tok)) goto var_error;
-
-      if (s->token.val == '=') {
-        if (next_token (s)) goto var_error;
-
-        if (js_parse_assign_expr2 (s, parse_flags)) goto var_error;
-        set_object_name (s, name);
-        emit_op (s, (tok == TOK_DEF || tok == TOK_VAR) ? OP_scope_put_var_init : OP_scope_put_var);
-        emit_key (s, name);
-        emit_u16 (s, fd->scope_level);
-      } else {
-        if (tok == TOK_DEF) {
-          js_parse_error (s, "missing initializer for const variable");
-          goto var_error;
-        }
-        if (tok == TOK_VAR) {
-          /* initialize lexical variable upon entering its scope */
-          emit_op (s, OP_null);
-          emit_op (s, OP_scope_put_var_init);
-          emit_key (s, name);
-          emit_u16 (s, fd->scope_level);
-        }
-      }
-    } else {
-      int skip_bits;
-      if ((s->token.val == '[' || s->token.val == '{')
-          && js_parse_skip_parens_token (s, &skip_bits, FALSE) == '=') {
-        emit_op (s, OP_null);
-        if (js_parse_destructuring_element (s, tok, 0, TRUE, TRUE, export_flag)
-            < 0)
-          return -1;
-      } else {
-        return js_parse_error (s, "variable name expected");
-      }
-    }
-    if (s->token.val != ',') break;
-    if (next_token (s)) return -1;
-  }
-  return 0;
-
-var_error:
-  return -1;
-}
-
-/* test if the current token is a label. Use simplistic look-ahead scanner */
-static BOOL is_label (JSParseState *s) {
-  return (s->token.val == TOK_IDENT && !s->token.u.ident.is_reserved
-          && peek_token (s, FALSE) == ':');
-}
-
-/* for-in and for-of loops are not supported */
-static __exception int js_parse_for_in_of (JSParseState *s, int label_name) {
-  return js_parse_error (s, "'for in' and 'for of' loops are not supported");
-}
-
-static __exception int js_parse_statement_or_decl (JSParseState *s,
-                                                   int decl_mask) {
-  JSValue label_name;
-  int tok;
-
-  /* specific label handling */
-  /* XXX: support multiple labels on loop statements */
-  label_name = JS_NULL;
-  if (is_label (s)) {
-    BlockEnv *be;
-
-    label_name = s->token.u.ident.str;
-
-    for (be = s->cur_func->top_break; be; be = be->prev) {
-      if (js_key_equal (be->label_name, label_name)) {
-        js_parse_error (s, "duplicate label name");
-        goto fail;
-      }
-    }
-
-    if (next_token (s)) goto fail;
-    if (js_parse_expect (s, ':')) goto fail;
-    if (s->token.val != TOK_FOR && s->token.val != TOK_DO
-        && s->token.val != TOK_WHILE) {
-      /* labelled regular statement */
-      int label_break, mask;
-      BlockEnv break_entry;
-
-      label_break = new_label (s);
-      push_break_entry (s->cur_func, &break_entry, label_name, label_break, -1, 0);
-      break_entry.is_regular_stmt = TRUE;
-      mask = 0;
-      if (js_parse_statement_or_decl (s, mask)) goto fail;
-      emit_label (s, label_break);
-      pop_break_entry (s->cur_func);
-      goto done;
-    }
-  }
-
-  switch (tok = s->token.val) {
-  case '{':
-    if (js_parse_block (s)) goto fail;
-    break;
-  case TOK_RETURN: {
-    const uint8_t *op_token_ptr;
-    op_token_ptr = s->token.ptr;
-    if (next_token (s)) goto fail;
-    if (s->token.val != ';' && s->token.val != '}' && !s->got_lf) {
-      if (js_parse_expr (s)) goto fail;
-      emit_source_pos (s, op_token_ptr);
-      emit_return (s, TRUE);
-    } else {
-      emit_source_pos (s, op_token_ptr);
-      emit_return (s, FALSE);
-    }
-    if (js_parse_expect_semi (s)) goto fail;
-  } break;
-  case TOK_DISRUPT: {
-    if (next_token (s)) goto fail;
-    emit_op (s, OP_null);
-    emit_op (s, OP_throw);
-    if (js_parse_expect_semi (s)) goto fail;
-  } break;
-  case TOK_DEF:
-    if (!(decl_mask & DECL_MASK_OTHER)) {
-      js_parse_error (
-        s, "lexical declarations can't appear in single-statement context");
-      goto fail;
-    }
-    /* fall thru */
-  case TOK_VAR:
-    if (!(decl_mask & DECL_MASK_OTHER)) {
-      js_parse_error (
-        s, "lexical declarations can't appear in single-statement context");
-      goto fail;
-    }
-    if (next_token (s)) goto fail;
-    if (js_parse_var (s, TRUE, tok, FALSE)) goto fail;
-    if (js_parse_expect_semi (s)) goto fail;
-    break;
-  case TOK_IF: {
-    int label1, label2, mask;
-    if (next_token (s)) goto fail;
-    /* create a new scope for `let f;if(1) function f(){}` */
-    push_scope (s);
-    if (js_parse_expr_paren (s)) goto fail;
-    label1 = emit_goto (s, OP_if_false, -1);
-    mask = 0;
-
-    if (js_parse_statement_or_decl (s, mask)) goto fail;
-
-    if (s->token.val == TOK_ELSE) {
-      label2 = emit_goto (s, OP_goto, -1);
-      if (next_token (s)) goto fail;
-
-      emit_label (s, label1);
-      if (js_parse_statement_or_decl (s, mask)) goto fail;
-
-      label1 = label2;
-    }
-    emit_label (s, label1);
-    pop_scope (s);
-  } break;
-  case TOK_WHILE: {
-    int label_cont, label_break;
-    BlockEnv break_entry;
-
-    label_cont = new_label (s);
-    label_break = new_label (s);
-
-    push_break_entry (s->cur_func, &break_entry, label_name, label_break, label_cont, 0);
-
-    if (next_token (s)) goto fail;
-
-    emit_label (s, label_cont);
-    if (js_parse_expr_paren (s)) goto fail;
-    emit_goto (s, OP_if_false, label_break);
-
-    if (js_parse_statement (s)) goto fail;
-    emit_goto (s, OP_goto, label_cont);
-
-    emit_label (s, label_break);
-
-    pop_break_entry (s->cur_func);
-  } break;
-  case TOK_DO: {
-    int label_cont, label_break, label1;
-    BlockEnv break_entry;
-
-    label_cont = new_label (s);
-    label_break = new_label (s);
-    label1 = new_label (s);
-
-    push_break_entry (s->cur_func, &break_entry, label_name, label_break, label_cont, 0);
-
-    if (next_token (s)) goto fail;
-
-    emit_label (s, label1);
-
-    if (js_parse_statement (s)) goto fail;
-
-    emit_label (s, label_cont);
-    if (js_parse_expect (s, TOK_WHILE)) goto fail;
-    if (js_parse_expr_paren (s)) goto fail;
-    /* Insert semicolon if missing */
-    if (s->token.val == ';') {
-      if (next_token (s)) goto fail;
-    }
-    emit_goto (s, OP_if_true, label1);
-
-    emit_label (s, label_break);
-
-    pop_break_entry (s->cur_func);
-  } break;
-  case TOK_FOR: {
-    int label_cont, label_break, label_body, label_test;
-    int pos_cont, pos_body, block_scope_level;
-    BlockEnv break_entry;
-    int tok, bits;
-
-    if (next_token (s)) goto fail;
-
-    bits = 0;
-    if (s->token.val == '(') { js_parse_skip_parens_token (s, &bits, FALSE); }
-    if (js_parse_expect (s, '(')) goto fail;
-
-    if (!(bits & SKIP_HAS_SEMI)) {
-      /* parse for/in or for/of */
-      if (js_parse_for_in_of (s, label_name)) goto fail;
-      break;
-    }
-    block_scope_level = s->cur_func->scope_level;
-
-    /* create scope for the lexical variables declared in the initial,
-       test and increment expressions */
-    push_scope (s);
-    /* initial expression */
-    tok = s->token.val;
-    if (tok != ';') {
-      if (tok == TOK_VAR || tok == TOK_DEF) {
-        if (next_token (s)) goto fail;
-        if (js_parse_var (s, FALSE, tok, FALSE)) goto fail;
-      } else {
-        if (js_parse_expr2 (s, FALSE)) goto fail;
-        emit_op (s, OP_drop);
-      }
-
-      /* close the closures before the first iteration */
-      close_scopes (s, s->cur_func->scope_level, block_scope_level);
-    }
-    if (js_parse_expect (s, ';')) goto fail;
-
-    label_test = new_label (s);
-    label_cont = new_label (s);
-    label_body = new_label (s);
-    label_break = new_label (s);
-
-    push_break_entry (s->cur_func, &break_entry, label_name, label_break, label_cont, 0);
-
-    /* test expression */
-    if (s->token.val == ';') {
-      /* no test expression */
-      label_test = label_body;
-    } else {
-      emit_label (s, label_test);
-      if (js_parse_expr (s)) goto fail;
-      emit_goto (s, OP_if_false, label_break);
-    }
-    if (js_parse_expect (s, ';')) goto fail;
-
-    if (s->token.val == ')') {
-      /* no end expression */
-      break_entry.label_cont = label_cont = label_test;
-      pos_cont = 0; /* avoid warning */
-    } else {
-      /* skip the end expression */
-      emit_goto (s, OP_goto, label_body);
-
-      pos_cont = s->cur_func->byte_code.size;
-      emit_label (s, label_cont);
-      if (js_parse_expr (s)) goto fail;
-      emit_op (s, OP_drop);
-      if (label_test != label_body) emit_goto (s, OP_goto, label_test);
-    }
-    if (js_parse_expect (s, ')')) goto fail;
-
-    pos_body = s->cur_func->byte_code.size;
-    emit_label (s, label_body);
-    if (js_parse_statement (s)) goto fail;
-
-    /* close the closures before the next iteration */
-    /* XXX: check continue case */
-    close_scopes (s, s->cur_func->scope_level, block_scope_level);
-
-    if (OPTIMIZE && label_test != label_body && label_cont != label_test) {
-      /* move the increment code here */
-      DynBuf *bc = &s->cur_func->byte_code;
-      int chunk_size = pos_body - pos_cont;
-      int offset = bc->size - pos_cont;
-      int i;
-      dbuf_realloc (bc, bc->size + chunk_size);
-      dbuf_put (bc, bc->buf + pos_cont, chunk_size);
-      memset (bc->buf + pos_cont, OP_nop, chunk_size);
-      /* increment part ends with a goto */
-      s->cur_func->last_opcode_pos = bc->size - 5;
-      /* relocate labels */
-      for (i = label_cont; i < s->cur_func->label_count; i++) {
-        LabelSlot *ls = &s->cur_func->label_slots[i];
-        if (ls->pos >= pos_cont && ls->pos < pos_body) ls->pos += offset;
-      }
-    } else {
-      emit_goto (s, OP_goto, label_cont);
-    }
-
-    emit_label (s, label_break);
-
-    pop_break_entry (s->cur_func);
-    pop_scope (s);
-  } break;
-  case TOK_BREAK:
-  case TOK_CONTINUE: {
-    int is_cont = s->token.val - TOK_BREAK;
-    JSValue label;
-
-    if (next_token (s)) goto fail;
-    if (!s->got_lf && s->token.val == TOK_IDENT
-        && !s->token.u.ident.is_reserved)
-      label = s->token.u.ident.str;
-    else
-      label = JS_NULL;
-    if (emit_break (s, label, is_cont)) goto fail;
-    if (!JS_IsNull (label)) {
-      if (next_token (s)) goto fail;
-    }
-    if (js_parse_expect_semi (s)) goto fail;
-  } break;
-  case ';':
-    /* empty statement */
-    if (next_token (s)) goto fail;
-    break;
-  case TOK_FUNCTION:
-    /* ES6 Annex B.3.2 and B.3.3 semantics */
-    if (!(decl_mask & DECL_MASK_FUNC)) goto func_decl_error;
-    if (!(decl_mask & DECL_MASK_OTHER) && peek_token (s, FALSE) == '*')
-      goto func_decl_error;
-    goto parse_func_var;
-  case TOK_IDENT:
-    if (s->token.u.ident.is_reserved) {
-      js_parse_error_reserved_identifier (s);
-      goto fail;
-    }
-    /* let keyword is no longer supported */
-    if (token_is_pseudo_keyword (s, JS_KEY_async)
-        && peek_token (s, TRUE) == TOK_FUNCTION) {
-      if (!(decl_mask & DECL_MASK_OTHER)) {
-      func_decl_error:
-        js_parse_error (
-          s, "function declarations can't appear in single-statement context");
-        goto fail;
-      }
-    parse_func_var:
-      if (js_parse_function_decl (s, JS_PARSE_FUNC_VAR, JS_NULL, s->token.ptr))
-        goto fail;
-      break;
-    }
-    goto hasexpr;
-
-  case TOK_DEBUGGER:
-    /* currently no debugger, so just skip the keyword */
-    if (next_token (s)) goto fail;
-    if (js_parse_expect_semi (s)) goto fail;
-    break;
-
-  case TOK_ENUM:
-  case TOK_EXPORT:
-    js_unsupported_keyword (s, s->token.u.ident.str);
-    goto fail;
-
-  default:
-  hasexpr:
-    emit_source_pos (s, s->token.ptr);
-    if (js_parse_expr (s)) goto fail;
-    emit_op (s, OP_drop); /* drop the result */
-    if (js_parse_expect_semi (s)) goto fail;
-    break;
-  }
-done:
-  return 0;
-fail:
-  return -1;
-}
-
-static int add_closure_var (JSContext *ctx, JSFunctionDef *s, BOOL is_local, BOOL is_arg, int var_idx, JSValue var_name, BOOL is_const, BOOL is_lexical, JSVarKindEnum var_kind);
-
-static __exception int js_parse_source_element (JSParseState *s) {
-  if (s->token.val == TOK_FUNCTION
-      || (token_is_pseudo_keyword (s, JS_KEY_async)
-          && peek_token (s, TRUE) == TOK_FUNCTION)) {
-    if (js_parse_function_decl (s, JS_PARSE_FUNC_STATEMENT, JS_NULL, s->token.ptr))
-      return -1;
-  } else {
-    if (js_parse_statement_or_decl (s, DECL_MASK_ALL)) return -1;
-  }
-  return 0;
-}
-
-static JSFunctionDef *
-js_new_function_def (JSContext *ctx, JSFunctionDef *parent, BOOL is_func_expr, const char *filename, const uint8_t *source_ptr, GetLineColCache *get_line_col_cache) {
-  JSFunctionDef *fd;
-
-  fd = pjs_mallocz (sizeof (*fd));
-  if (!fd) return NULL;
-
-  fd->ctx = ctx;
-  init_list_head (&fd->child_list);
-
-  /* insert in parent list */
-  fd->parent = parent;
-  fd->parent_cpool_idx = -1;
-  if (parent) {
-    list_add_tail (&fd->link, &parent->child_list);
-    fd->js_mode = parent->js_mode;
-    fd->parent_scope_level = parent->scope_level;
-  }
-  fd->strip_debug = ((ctx->rt->strip_flags & JS_STRIP_DEBUG) != 0);
-  fd->strip_source
-    = ((ctx->rt->strip_flags & (JS_STRIP_DEBUG | JS_STRIP_SOURCE)) != 0);
-
-  fd->is_func_expr = is_func_expr;
-  js_dbuf_init (ctx, &fd->byte_code);
-  fd->last_opcode_pos = -1;
-  fd->func_name = JS_NULL;
-  fd->var_object_idx = -1;
-  fd->arg_var_object_idx = -1;
-  fd->func_var_idx = -1;
-  fd->this_var_idx = -1;
-  fd->this_active_func_var_idx = -1;
-
-  /* XXX: should distinguish arg, var and var object and body scopes */
-  fd->scopes = fd->def_scope_array;
-  fd->scope_size = countof (fd->def_scope_array);
-  fd->scope_count = 1;
-  fd->scopes[0].first = -1;
-  fd->scopes[0].parent = -1;
-  fd->scope_level = 0; /* 0: var/arg scope */
-  fd->scope_first = -1;
-  fd->body_scope = -1;
-
-  fd->filename = js_key_new (ctx, filename);
-  fd->source_pos = source_ptr - get_line_col_cache->buf_start;
-  fd->get_line_col_cache = get_line_col_cache;
-
-  js_dbuf_init (ctx, &fd->pc2line);
-  // fd->pc2line_last_line_num = line_num;
-  // fd->pc2line_last_pc = 0;
-  fd->last_opcode_source_ptr = source_ptr;
-  return fd;
-}
-
-static void free_bytecode_atoms (JSRuntime *rt, const uint8_t *bc_buf, int bc_len, BOOL use_short_opcodes) {
-  int pos, len, op;
-  const JSOpCode *oi;
-
-  pos = 0;
-  while (pos < bc_len) {
-    op = bc_buf[pos];
-    if (use_short_opcodes)
-      oi = &short_opcode_info (op);
-    else
-      oi = &opcode_info[op];
-
-    len = oi->size;
-    switch (oi->fmt) {
-    case OP_FMT_key:
-    case OP_FMT_key_u8:
-    case OP_FMT_key_u16:
-    case OP_FMT_key_label_u16:
-      /* Key operand is now a cpool index; cpool values freed separately */
-      break;
-    default:
-      break;
-    }
-    pos += len;
-  }
-}
-
-static void js_free_function_def (JSContext *ctx, JSFunctionDef *fd) {
-  int i;
-  struct list_head *el, *el1;
-
-  /* free the child functions */
-  list_for_each_safe (el, el1, &fd->child_list) {
-    JSFunctionDef *fd1;
-    fd1 = list_entry (el, JSFunctionDef, link);
-    js_free_function_def (ctx, fd1);
-  }
-
-  free_bytecode_atoms (ctx->rt, fd->byte_code.buf, fd->byte_code.size, fd->use_short_opcodes);
-  dbuf_free (&fd->byte_code);
-  pjs_free (fd->jump_slots);
-  pjs_free (fd->label_slots);
-  pjs_free (fd->line_number_slots);
-
-  for (i = 0; i < fd->cpool_count; i++) {
-  }
-  pjs_free (fd->cpool);
-
-
-  for (i = 0; i < fd->var_count; i++) {
-  }
-  pjs_free (fd->vars);
-  for (i = 0; i < fd->arg_count; i++) {
-  }
-  pjs_free (fd->args);
-
-  for (i = 0; i < fd->global_var_count; i++) {
-  }
-  pjs_free (fd->global_vars);
-
-  for (i = 0; i < fd->closure_var_count; i++) {
-    JSClosureVar *cv = &fd->closure_var[i];
-    (void)cv;
-  }
-  pjs_free (fd->closure_var);
-
-  if (fd->scopes != fd->def_scope_array) pjs_free (fd->scopes);
-
-  dbuf_free (&fd->pc2line);
-
-  pjs_free (fd->source);
-
-  if (fd->parent) {
-    /* remove in parent list */
-    list_del (&fd->link);
-  }
-  pjs_free (fd);
-}
-
-#ifdef DUMP_BYTECODE
-static const char *skip_lines (const char *p, int n) {
-  while (n-- > 0 && *p) {
-    while (*p && *p++ != '\n')
-      continue;
-  }
-  return p;
-}
-
-static void print_lines (const char *source, int line, int line1) {
-  const char *s = source;
-  const char *p = skip_lines (s, line);
-  if (*p) {
-    while (line++ < line1) {
-      p = skip_lines (s = p, 1);
-      printf (";; %.*s", (int)(p - s), s);
-      if (!*p) {
-        if (p[-1] != '\n') printf ("\n");
-        break;
-      }
-    }
-  }
-}
-
-static void dump_byte_code (JSContext *ctx, int pass, const uint8_t *tab, int len, const JSVarDef *args, int arg_count, const JSVarDef *vars, int var_count, const JSClosureVar *closure_var, int closure_var_count, const JSValue *cpool, uint32_t cpool_count, const char *source, const LabelSlot *label_slots, JSFunctionBytecode *b) {
-  const JSOpCode *oi;
-  int pos, pos_next, op, size, idx, addr, line, line1, in_source, line_num;
-  uint8_t *bits = js_mallocz (ctx, len * sizeof (*bits));
-  BOOL use_short_opcodes = (b != NULL);
-
-  if (b) {
-    int col_num;
-    line_num = find_line_num (ctx, b, -1, &col_num);
-  }
-
-  /* scan for jump targets */
-  for (pos = 0; pos < len; pos = pos_next) {
-    op = tab[pos];
-    if (use_short_opcodes)
-      oi = &short_opcode_info (op);
-    else
-      oi = &opcode_info[op];
-    pos_next = pos + oi->size;
-    if (op < OP_COUNT) {
-      switch (oi->fmt) {
-#if SHORT_OPCODES
-      case OP_FMT_label8:
-        pos++;
-        addr = (int8_t)tab[pos];
-        goto has_addr;
-      case OP_FMT_label16:
-        pos++;
-        addr = (int16_t)get_u16 (tab + pos);
-        goto has_addr;
-#endif
-      case OP_FMT_key_label_u16:
-        pos += 4;
-        /* fall thru */
-      case OP_FMT_label:
-      case OP_FMT_label_u16:
-        pos++;
-        addr = get_u32 (tab + pos);
-        goto has_addr;
-      has_addr:
-        if (pass == 1) addr = label_slots[addr].pos;
-        if (pass == 2) addr = label_slots[addr].pos2;
-        if (pass == 3) addr += pos;
-        if (addr >= 0 && addr < len) bits[addr] |= 1;
-        break;
-      }
-    }
-  }
-  in_source = 0;
-  if (source) {
-    /* Always print first line: needed if single line */
-    print_lines (source, 0, 1);
-    in_source = 1;
-  }
-  line1 = line = 1;
-  pos = 0;
-  while (pos < len) {
-    op = tab[pos];
-    if (source && b) {
-      int col_num;
-      if (b) {
-        line1 = find_line_num (ctx, b, pos, &col_num) - line_num + 1;
-      } else if (op == OP_line_num) {
-        /* XXX: no longer works */
-        line1 = get_u32 (tab + pos + 1) - line_num + 1;
-      }
-      if (line1 > line) {
-        if (!in_source) printf ("\n");
-        in_source = 1;
-        print_lines (source, line, line1);
-        line = line1;
-        // bits[pos] |= 2;
-      }
-    }
-    if (in_source) printf ("\n");
-    in_source = 0;
-    if (op >= OP_COUNT) {
-      printf ("invalid opcode (0x%02x)\n", op);
-      pos++;
-      continue;
-    }
-    if (use_short_opcodes)
-      oi = &short_opcode_info (op);
-    else
-      oi = &opcode_info[op];
-    size = oi->size;
-    if (pos + size > len) {
-      printf ("truncated opcode (0x%02x)\n", op);
-      break;
-    }
-#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 16)
-    {
-      int i, x, x0;
-      x = x0 = printf ("%5d ", pos);
-      for (i = 0; i < size; i++) {
-        if (i == 6) { printf ("\n%*s", x = x0, ""); }
-        x += printf (" %02X", tab[pos + i]);
-      }
-      printf ("%*s", x0 + 20 - x, "");
-    }
-#endif
-    if (bits[pos]) {
-      printf ("%5d:  ", pos);
-    } else {
-      printf ("        ");
-    }
-    printf ("%s", oi->name);
-    pos++;
-    switch (oi->fmt) {
-    case OP_FMT_none_int:
-      printf (" %d", op - OP_push_0);
-      break;
-    case OP_FMT_npopx:
-      printf (" %d", op - OP_call0);
-      break;
-    case OP_FMT_u8:
-      printf (" %u", get_u8 (tab + pos));
-      break;
-    case OP_FMT_i8:
-      printf (" %d", get_i8 (tab + pos));
-      break;
-    case OP_FMT_u16:
-    case OP_FMT_npop:
-      printf (" %u", get_u16 (tab + pos));
-      break;
-    case OP_FMT_npop_u16:
-      printf (" %u,%u", get_u16 (tab + pos), get_u16 (tab + pos + 2));
-      break;
-    case OP_FMT_i16:
-      printf (" %d", get_i16 (tab + pos));
-      break;
-    case OP_FMT_i32:
-      printf (" %d", get_i32 (tab + pos));
-      break;
-    case OP_FMT_u32:
-      printf (" %u", get_u32 (tab + pos));
-      break;
-#if SHORT_OPCODES
-    case OP_FMT_label8:
-      addr = get_i8 (tab + pos);
-      goto has_addr1;
-    case OP_FMT_label16:
-      addr = get_i16 (tab + pos);
-      goto has_addr1;
-#endif
-    case OP_FMT_label:
-      addr = get_u32 (tab + pos);
-      goto has_addr1;
-    has_addr1:
-      if (pass == 1) printf (" %u:%u", addr, label_slots[addr].pos);
-      if (pass == 2) printf (" %u:%u", addr, label_slots[addr].pos2);
-      if (pass == 3) printf (" %u", addr + pos);
-      break;
-    case OP_FMT_label_u16:
-      addr = get_u32 (tab + pos);
-      if (pass == 1) printf (" %u:%u", addr, label_slots[addr].pos);
-      if (pass == 2) printf (" %u:%u", addr, label_slots[addr].pos2);
-      if (pass == 3) printf (" %u", addr + pos);
-      printf (",%u", get_u16 (tab + pos + 4));
-      break;
-#if SHORT_OPCODES
-    case OP_FMT_const8:
-      idx = get_u8 (tab + pos);
-      goto has_pool_idx;
-#endif
-    case OP_FMT_const:
-      idx = get_u32 (tab + pos);
-      goto has_pool_idx;
-    has_pool_idx:
-      printf (" %u: ", idx);
-      if (idx < cpool_count) {
-        JS_PrintValue (ctx, js_dump_value_write, stdout, cpool[idx], NULL);
-      }
-      break;
-    case OP_FMT_key:
-      printf (" ");
-      print_atom (ctx, get_u32 (tab + pos));
-      break;
-    case OP_FMT_key: {
-      /* Key operand is a cpool index; print the cpool value */
-      uint32_t key_idx = get_u32 (tab + pos);
-      printf (" %u: ", key_idx);
-      if (key_idx < cpool_count) {
-        JS_PrintValue (ctx, js_dump_value_write, stdout, cpool[key_idx], NULL);
-      }
-    } break;
-    case OP_FMT_key_u8:
-      printf (" ");
-      print_atom (ctx, get_u32 (tab + pos));
-      printf (",%d", get_u8 (tab + pos + 4));
-      break;
-    case OP_FMT_key_u16:
-      printf (" ");
-      print_atom (ctx, get_u32 (tab + pos));
-      printf (",%d", get_u16 (tab + pos + 4));
-      break;
-    case OP_FMT_key_label_u16:
-      printf (" ");
-      print_atom (ctx, get_u32 (tab + pos));
-      addr = get_u32 (tab + pos + 4);
-      if (pass == 1) printf (",%u:%u", addr, label_slots[addr].pos);
-      if (pass == 2) printf (",%u:%u", addr, label_slots[addr].pos2);
-      if (pass == 3) printf (",%u", addr + pos + 4);
-      printf (",%u", get_u16 (tab + pos + 8));
-      break;
-    case OP_FMT_none_loc:
-      idx = (op - OP_get_loc0) % 4;
-      goto has_loc;
-    case OP_FMT_loc8:
-      idx = get_u8 (tab + pos);
-      goto has_loc;
-    case OP_FMT_loc:
-      idx = get_u16 (tab + pos);
-    has_loc:
-      printf (" %d: ", idx);
-      if (idx < var_count) { print_atom (ctx, vars[idx].var_name); }
-      break;
-    case OP_FMT_none_arg:
-      idx = (op - OP_get_arg0) % 4;
-      goto has_arg;
-    case OP_FMT_arg:
-      idx = get_u16 (tab + pos);
-    has_arg:
-      printf (" %d: ", idx);
-      if (idx < arg_count) { print_atom (ctx, args[idx].var_name); }
-      break;
-    default:
-      break;
-    }
-    printf ("\n");
-    pos += oi->size - 1;
-  }
-  if (source) {
-    if (!in_source) printf ("\n");
-    print_lines (source, line, INT32_MAX);
-  }
-  js_free (ctx, bits);
-}
-
-static __maybe_unused void dump_pc2line (JSContext *ctx, const uint8_t *buf, int len) {
-  const uint8_t *p_end, *p;
-  int pc, v, line_num, col_num, ret;
-  unsigned int op;
-  uint32_t val;
-
-  if (len <= 0) return;
-
-  printf ("%5s %5s %5s\n", "PC", "LINE", "COL");
-
-  p = buf;
-  p_end = buf + len;
-
-  /* get the function line and column numbers */
-  ret = get_leb128 (&val, p, p_end);
-  if (ret < 0) goto fail;
-  p += ret;
-  line_num = val + 1;
-
-  ret = get_leb128 (&val, p, p_end);
-  if (ret < 0) goto fail;
-  p += ret;
-  col_num = val + 1;
-
-  printf ("%5s %5d %5d\n", "-", line_num, col_num);
-
-  pc = 0;
-  while (p < p_end) {
-    op = *p++;
-    if (op == 0) {
-      ret = get_leb128 (&val, p, p_end);
-      if (ret < 0) goto fail;
-      pc += val;
-      p += ret;
-      ret = get_sleb128 (&v, p, p_end);
-      if (ret < 0) goto fail;
-      p += ret;
-      line_num += v;
-    } else {
-      op -= PC2LINE_OP_FIRST;
-      pc += (op / PC2LINE_RANGE);
-      line_num += (op % PC2LINE_RANGE) + PC2LINE_BASE;
-    }
-    ret = get_sleb128 (&v, p, p_end);
-    if (ret < 0) goto fail;
-    p += ret;
-    col_num += v;
-
-    printf ("%5d %5d %5d\n", pc, line_num, col_num);
-  }
-fail:;
-}
-
-static __maybe_unused void js_dump_function_bytecode (JSContext *ctx,
-                                                      JSFunctionBytecode *b) {
-  int i;
-  char atom_buf[KEY_GET_STR_BUF_SIZE];
-  const char *str;
-
-  if (b->has_debug && !JS_IsNull (b->debug.filename)) {
-    int line_num, col_num;
-    str = JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), b->debug.filename);
-    line_num = find_line_num (ctx, b, -1, &col_num);
-    printf ("%s:%d:%d: ", str, line_num, col_num);
-  }
-
-  str = JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), b->func_name);
-  printf ("function: %s%s\n", "", str);
-  if (b->js_mode) {
-    printf ("  mode:");
-    printf (" strict");
-    printf ("\n");
-  }
-  if (b->arg_count && b->vardefs) {
-    printf ("  args:");
-    for (i = 0; i < b->arg_count; i++) {
-      printf (" %s", JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), b->vardefs[i].var_name));
-    }
-    printf ("\n");
-  }
-  if (b->var_count && b->vardefs) {
-    printf ("  locals:\n");
-    for (i = 0; i < b->var_count; i++) {
-      JSVarDef *vd = &b->vardefs[b->arg_count + i];
-      printf ("%5d: %s %s", i, vd->var_kind == JS_VAR_CATCH ? "catch" : (vd->var_kind == JS_VAR_FUNCTION_DECL || vd->var_kind == JS_VAR_NEW_FUNCTION_DECL) ? "function"
-                                                                      : vd->is_const                                                                       ? "const"
-                                                                      : vd->is_lexical                                                                     ? "let"
-                                                                                                                                                           : "var",
-              JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), vd->var_name));
-      if (vd->scope_level)
-        printf (" [level:%d next:%d]", vd->scope_level, vd->scope_next);
-      printf ("\n");
-    }
-  }
-  if (b->closure_var_count) {
-    printf ("  closure vars:\n");
-    for (i = 0; i < b->closure_var_count; i++) {
-      JSClosureVar *cv = &b->closure_var[i];
-      printf ("%5d: %s %s:%s%d %s\n", i, JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), cv->var_name), cv->is_local ? "local" : "parent", cv->is_arg ? "arg" : "loc", cv->var_idx, cv->is_const ? "const" : cv->is_lexical ? "let"
-                                                                                                                                                                                                                            : "var");
-    }
-  }
-  printf ("  stack_size: %d\n", b->stack_size);
-  printf ("  opcodes:\n");
-  dump_byte_code (ctx, 3, b->byte_code_buf, b->byte_code_len, b->vardefs, b->arg_count, b->vardefs ? b->vardefs + b->arg_count : NULL, b->var_count, b->closure_var, b->closure_var_count, b->cpool, b->cpool_count, b->has_debug ? b->debug.source : NULL, NULL, b);
-#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 32)
-  if (b->has_debug)
-    dump_pc2line (ctx, b->debug.pc2line_buf, b->debug.pc2line_len);
-#endif
-  printf ("\n");
-}
-#endif
-
-static int add_closure_var (JSContext *ctx, JSFunctionDef *s, BOOL is_local, BOOL is_arg, int var_idx, JSValue var_name, BOOL is_const, BOOL is_lexical, JSVarKindEnum var_kind) {
-  JSClosureVar *cv;
-
-  /* the closure variable indexes are currently stored on 16 bits */
-  if (s->closure_var_count >= JS_MAX_LOCAL_VARS) {
-    JS_ThrowInternalError (ctx, "too many closure variables");
-    return -1;
-  }
-
-  if (pjs_resize_array ((void **)&s->closure_var, sizeof (s->closure_var[0]), &s->closure_var_size, s->closure_var_count + 1))
-    return -1;
-  cv = &s->closure_var[s->closure_var_count++];
-  cv->is_local = is_local;
-  cv->is_arg = is_arg;
-  cv->is_const = is_const;
-  cv->is_lexical = is_lexical;
-  cv->var_kind = var_kind;
-  cv->var_idx = var_idx;
-  cv->var_name = var_name;
-  return s->closure_var_count - 1;
-}
-
-/* 'fd' must be a parent of 's'. Create in 's' a closure referencing a
-   local variable (is_local = TRUE) or a closure (is_local = FALSE) in
-   'fd' */
-static int get_closure_var2 (JSContext *ctx, JSFunctionDef *s, JSFunctionDef *fd, BOOL is_local, BOOL is_arg, int var_idx, JSValue var_name, BOOL is_const, BOOL is_lexical, JSVarKindEnum var_kind) {
-  int i;
-
-  if (fd != s->parent) {
-    var_idx = get_closure_var2 (ctx, s->parent, fd, is_local, is_arg, var_idx, var_name, is_const, is_lexical, var_kind);
-    if (var_idx < 0) return -1;
-    is_local = FALSE;
-  }
-  for (i = 0; i < s->closure_var_count; i++) {
-    JSClosureVar *cv = &s->closure_var[i];
-    if (cv->var_idx == var_idx && cv->is_arg == is_arg
-        && cv->is_local == is_local)
-      return i;
-  }
-  return add_closure_var (ctx, s, is_local, is_arg, var_idx, var_name, is_const, is_lexical, var_kind);
-}
-
-static int get_closure_var (JSContext *ctx, JSFunctionDef *s, JSFunctionDef *fd, BOOL is_arg, int var_idx, JSValue var_name, BOOL is_const, BOOL is_lexical, JSVarKindEnum var_kind) {
-  return get_closure_var2 (ctx, s, fd, TRUE, is_arg, var_idx, var_name, is_const, is_lexical, var_kind);
-}
-
-/* Compute closure depth and slot for OP_get_up/OP_set_up opcodes.
-   Follows the closure_var chain to find the actual variable location.
-   Returns depth (1 = immediate parent) and slot (index in JSFrame.slots).
-   Returns -1 on error. */
-static int compute_closure_depth_slot(JSFunctionDef *s, int closure_idx, int *out_slot) {
-  int depth = 1;
-  JSClosureVar *cv = &s->closure_var[closure_idx];
-  JSFunctionDef *fd = s->parent;
-
-  /* Follow chain until we find the actual local variable */
-  while (!cv->is_local) {
-    if (!fd || !fd->parent) return -1;  /* Invalid chain */
-    cv = &fd->closure_var[cv->var_idx];
-    fd = fd->parent;
-    depth++;
-  }
-
-  /* Now cv->var_idx is the index in fd's variables/arguments.
-     Compute slot in JSFrame.slots layout: [args..., vars...] */
-  if (cv->is_arg) {
-    *out_slot = cv->var_idx;
-  } else {
-    *out_slot = fd->arg_count + cv->var_idx;
-  }
-  return depth;
-}
-
-static int add_var_this (JSContext *ctx, JSFunctionDef *fd) {
-  return add_var (ctx, fd, JS_KEY_this);
-}
-
-static int resolve_pseudo_var (JSContext *ctx, JSFunctionDef *s, JSValue var_name) {
-  int var_idx;
-
-  if (!s->has_this_binding) return -1;
-
-  if (js_key_equal (var_name, JS_KEY_this)) {
-    /* 'this' pseudo variable */
-    if (s->this_var_idx < 0) s->this_var_idx = add_var_this (ctx, s);
-    var_idx = s->this_var_idx;
-  } else if (js_key_equal (var_name, js_key_new (ctx, "this_active_func"))) {
-    /* 'this.active_func' pseudo variable */
-    if (s->this_active_func_var_idx < 0)
-      s->this_active_func_var_idx = add_var (ctx, s, var_name);
-    var_idx = s->this_active_func_var_idx;
-  } else if (js_key_equal (var_name, js_key_new (ctx, "new_target"))) {
-    /* 'new.target' not supported - constructors removed */
-    var_idx = -1;
-  } else {
-    var_idx = -1;
-  }
-  return var_idx;
-}
-
-/* test if 'var_name' is in the variable object on the stack. If is it
-   the case, handle it and jump to 'label_done' */
-static void var_object_test (JSContext *ctx, JSFunctionDef *s, JSValue var_name, int op, DynBuf *bc, int *plabel_done, BOOL is_with) {
-  int cpool_idx = fd_cpool_add (ctx, s, var_name);
-  dbuf_putc (bc, op);
-  dbuf_put_u32 (bc, cpool_idx);
-}
-
-/* return the position of the next opcode */
-static int resolve_scope_var (JSContext *ctx, JSFunctionDef *s, JSValue var_name, int scope_level, int op, DynBuf *bc, uint8_t *bc_buf, LabelSlot *ls, int pos_next) {
-  int idx, var_idx, is_put;
-  int label_done;
-  JSFunctionDef *fd;
-  JSVarDef *vd;
-  BOOL is_pseudo_var, is_arg_scope;
-
-  label_done = -1;
-
-  /* XXX: could be simpler to use a specific function to
-     resolve the pseudo variables */
-  is_pseudo_var = (js_key_equal_str (var_name, "home_object")
-                   || js_key_equal_str (var_name, "this_active_func")
-                   || js_key_equal_str (var_name, "new_target")
-                   || js_key_equal (var_name, JS_KEY_this));
-
-  /* resolve local scoped variables */
-  var_idx = -1;
-  for (idx = s->scopes[scope_level].first; idx >= 0;) {
-    vd = &s->vars[idx];
-    if (js_key_equal (vd->var_name, var_name)) {
-      if (op == OP_scope_put_var) {
-        if (vd->is_const) {
-          int cpool_idx = fd_cpool_add (ctx, s, var_name);
-          dbuf_putc (bc, OP_throw_error);
-          dbuf_put_u32 (bc, cpool_idx);
-          dbuf_putc (bc, JS_THROW_VAR_RO);
-          goto done;
-        }
-      }
-      var_idx = idx;
-      break;
-    }
-    idx = vd->scope_next;
-  }
-  is_arg_scope = (idx == ARG_SCOPE_END);
-  if (var_idx < 0) {
-    /* argument scope: variables are not visible but pseudo
-       variables are visible */
-    if (!is_arg_scope) { var_idx = find_var (ctx, s, var_name); }
-
-    if (var_idx < 0 && is_pseudo_var)
-      var_idx = resolve_pseudo_var (ctx, s, var_name);
-
-    if (var_idx < 0 && s->is_func_expr
-        && js_key_equal (var_name, s->func_name)) {
-      /* add a new variable with the function name */
-      var_idx = add_func_var (ctx, s, var_name);
-    }
-  }
-  if (var_idx >= 0) {
-    if (op == OP_scope_put_var
-        && !(var_idx & ARGUMENT_VAR_OFFSET) && s->vars[var_idx].is_const) {
-      /* only happens when assigning a function expression name
-         in strict mode */
-      int cpool_idx = fd_cpool_add (ctx, s, var_name);
-      dbuf_putc (bc, OP_throw_error);
-      dbuf_put_u32 (bc, cpool_idx);
-      dbuf_putc (bc, JS_THROW_VAR_RO);
-      goto done;
-    }
-    /* OP_scope_put_var_init is only used to initialize a
-       lexical variable, so it is never used in a with or var object. It
-       can be used with a closure (module global variable case). */
-    switch (op) {
-    case OP_scope_get_var_checkthis:
-    case OP_scope_get_var_undef:
-    case OP_scope_get_var:
-    case OP_scope_put_var:
-    case OP_scope_put_var_init:
-      is_put = (op == OP_scope_put_var || op == OP_scope_put_var_init);
-      if (var_idx & ARGUMENT_VAR_OFFSET) {
-        dbuf_putc (bc, OP_get_arg + is_put);
-        dbuf_put_u16 (bc, var_idx - ARGUMENT_VAR_OFFSET);
-      } else {
-        if (is_put) {
-          if (s->vars[var_idx].is_lexical) {
-            if (op == OP_scope_put_var_init) {
-              /* 'this' can only be initialized once */
-              if (js_key_equal (var_name, JS_KEY_this))
-                dbuf_putc (bc, OP_put_loc_check_init);
-              else
-                dbuf_putc (bc, OP_put_loc);
-            } else {
-              dbuf_putc (bc, OP_put_loc_check);
-            }
-          } else {
-            dbuf_putc (bc, OP_put_loc);
-          }
-        } else {
-          if (s->vars[var_idx].is_lexical) {
-            if (op == OP_scope_get_var_checkthis) {
-              /* only used for 'this' return in derived class constructors */
-              dbuf_putc (bc, OP_get_loc_checkthis);
-            } else {
-              dbuf_putc (bc, OP_get_loc_check);
-            }
-          } else {
-            dbuf_putc (bc, OP_get_loc);
-          }
-        }
-        dbuf_put_u16 (bc, var_idx);
-      }
-      break;
-    case OP_scope_delete_var:
-      dbuf_putc (bc, OP_push_false);
-      break;
-    }
-    goto done;
-  }
-  /* check eval object */
-  if (!is_arg_scope && s->var_object_idx >= 0 && !is_pseudo_var) {
-    dbuf_putc (bc, OP_get_loc);
-    dbuf_put_u16 (bc, s->var_object_idx);
-    var_object_test (ctx, s, var_name, op, bc, &label_done, 0);
-  }
-  /* check eval object in argument scope */
-  if (s->arg_var_object_idx >= 0 && !is_pseudo_var) {
-    dbuf_putc (bc, OP_get_loc);
-    dbuf_put_u16 (bc, s->arg_var_object_idx);
-    var_object_test (ctx, s, var_name, op, bc, &label_done, 0);
-  }
-
-  /* check parent scopes */
-  for (fd = s; fd->parent;) {
-    scope_level = fd->parent_scope_level;
-    fd = fd->parent;
-    for (idx = fd->scopes[scope_level].first; idx >= 0;) {
-      vd = &fd->vars[idx];
-      if (js_key_equal (vd->var_name, var_name)) {
-        if (op == OP_scope_put_var) {
-          if (vd->is_const) {
-            int cpool_idx = fd_cpool_add (ctx, s, var_name);
-            dbuf_putc (bc, OP_throw_error);
-            dbuf_put_u32 (bc, cpool_idx);
-            dbuf_putc (bc, JS_THROW_VAR_RO);
-            goto done;
-          }
-        }
-        var_idx = idx;
-        break;
-      }
-      idx = vd->scope_next;
-    }
-    is_arg_scope = (idx == ARG_SCOPE_END);
-    if (var_idx >= 0) break;
-
-    if (!is_arg_scope) {
-      var_idx = find_var (ctx, fd, var_name);
-      if (var_idx >= 0) break;
-    }
-    if (is_pseudo_var) {
-      var_idx = resolve_pseudo_var (ctx, fd, var_name);
-      if (var_idx >= 0) break;
-    }
-    if (fd->is_func_expr && js_key_equal (fd->func_name, var_name)) {
-      /* add a new variable with the function name */
-      var_idx = add_func_var (ctx, fd, var_name);
-      break;
-    }
-
-    /* check eval object */
-    if (!is_arg_scope && fd->var_object_idx >= 0 && !is_pseudo_var) {
-      int slot, depth;
-      vd = &fd->vars[fd->var_object_idx];
-      vd->is_captured = 1;
-      idx = get_closure_var (ctx, s, fd, FALSE, fd->var_object_idx, vd->var_name, FALSE, FALSE, JS_VAR_NORMAL);
-      depth = compute_closure_depth_slot(s, idx, &slot);
-      dbuf_putc (bc, OP_get_up);
-      dbuf_putc (bc, (uint8_t)depth);
-      dbuf_put_u16 (bc, (uint16_t)slot);
-      var_object_test (ctx, s, var_name, op, bc, &label_done, 0);
-    }
-
-    /* check eval object in argument scope */
-    if (fd->arg_var_object_idx >= 0 && !is_pseudo_var) {
-      int slot, depth;
-      vd = &fd->vars[fd->arg_var_object_idx];
-      vd->is_captured = 1;
-      idx = get_closure_var (ctx, s, fd, FALSE, fd->arg_var_object_idx, vd->var_name, FALSE, FALSE, JS_VAR_NORMAL);
-      depth = compute_closure_depth_slot(s, idx, &slot);
-      dbuf_putc (bc, OP_get_up);
-      dbuf_putc (bc, (uint8_t)depth);
-      dbuf_put_u16 (bc, (uint16_t)slot);
-      var_object_test (ctx, s, var_name, op, bc, &label_done, 0);
-    }
-  }
-
-  if (var_idx >= 0) {
-    /* find the corresponding closure variable */
-    if (var_idx & ARGUMENT_VAR_OFFSET) {
-      fd->args[var_idx - ARGUMENT_VAR_OFFSET].is_captured = 1;
-      idx = get_closure_var (ctx, s, fd, TRUE, var_idx - ARGUMENT_VAR_OFFSET, var_name, FALSE, FALSE, JS_VAR_NORMAL);
-    } else {
-      fd->vars[var_idx].is_captured = 1;
-      idx = get_closure_var (
-        ctx, s, fd, FALSE, var_idx, var_name, fd->vars[var_idx].is_const, fd->vars[var_idx].is_lexical, fd->vars[var_idx].var_kind);
-    }
-    if (idx >= 0) {
-    has_idx:
-      if (op == OP_scope_put_var && s->closure_var[idx].is_const) {
-        int cpool_idx = fd_cpool_add (ctx, s, var_name);
-        dbuf_putc (bc, OP_throw_error);
-        dbuf_put_u32 (bc, cpool_idx);
-        dbuf_putc (bc, JS_THROW_VAR_RO);
-        goto done;
-      }
-      switch (op) {
-      case OP_scope_get_var_undef:
-      case OP_scope_get_var:
-      case OP_scope_put_var:
-      case OP_scope_put_var_init:
-        is_put = (op == OP_scope_put_var || op == OP_scope_put_var_init);
-        {
-          /* Use OP_get_up/OP_set_up with (depth, slot) encoding */
-          int slot;
-          int depth = compute_closure_depth_slot(s, idx, &slot);
-          assert(depth > 0 && depth <= 255 && slot <= 65535);
-          if (is_put) {
-            dbuf_putc(bc, OP_set_up);
-          } else {
-            dbuf_putc(bc, OP_get_up);
-          }
-          dbuf_putc(bc, (uint8_t)depth);
-          dbuf_put_u16(bc, (uint16_t)slot);
-        }
-        break;
-      case OP_scope_delete_var:
-        dbuf_putc (bc, OP_push_false);
-        break;
-      }
-      goto done;
-    }
-  }
-
-  /* global variable access */
-  {
-    int cpool_idx = fd_cpool_add (ctx, s, var_name);
-
-    switch (op) {
-    case OP_scope_get_var_undef:
-    case OP_scope_get_var:
-    case OP_scope_put_var:
-      dbuf_putc (bc, OP_get_var_undef + (op - OP_scope_get_var_undef));
-      dbuf_put_u32 (bc, cpool_idx);
-      break;
-    case OP_scope_put_var_init:
-      dbuf_putc (bc, OP_put_var_init);
-      dbuf_put_u32 (bc, cpool_idx);
-      break;
-    case OP_scope_delete_var:
-      dbuf_putc (bc, OP_delete_var);
-      dbuf_put_u32 (bc, cpool_idx);
-      break;
-    }
-  }
-done:
-  if (label_done >= 0) {
-    dbuf_putc (bc, OP_label);
-    dbuf_put_u32 (bc, label_done);
-    s->label_slots[label_done].pos2 = bc->size;
-  }
-  return pos_next;
-}
-
-typedef struct CodeContext {
-  const uint8_t *bc_buf; /* code buffer */
-  int bc_len;            /* length of the code buffer */
-  int pos;               /* position past the matched code pattern */
-  int line_num;          /* last visited OP_line_num parameter or -1 */
-  int op;
-  int idx;
-  int label;
-  int val;
-} CodeContext;
-
-#define M2(op1, op2) ((op1) | ((op2) << 8))
-#define M3(op1, op2, op3) ((op1) | ((op2) << 8) | ((op3) << 16))
-#define M4(op1, op2, op3, op4) \
-  ((op1) | ((op2) << 8) | ((op3) << 16) | ((op4) << 24))
-
-static BOOL code_match (CodeContext *s, int pos, ...) {
-  const uint8_t *tab = s->bc_buf;
-  int op, len, op1, line_num, pos_next;
-  va_list ap;
-  BOOL ret = FALSE;
-
-  line_num = -1;
-  va_start (ap, pos);
-
-  for (;;) {
-    op1 = va_arg (ap, int);
-    if (op1 == -1) {
-      s->pos = pos;
-      s->line_num = line_num;
-      ret = TRUE;
-      break;
-    }
-    for (;;) {
-      if (pos >= s->bc_len) goto done;
-      op = tab[pos];
-      len = opcode_info[op].size;
-      pos_next = pos + len;
-      if (pos_next > s->bc_len) goto done;
-      if (op == OP_line_num) {
-        line_num = get_u32 (tab + pos + 1);
-        pos = pos_next;
-      } else {
-        break;
-      }
-    }
-    if (op != op1) {
-      if (op1 == (uint8_t)op1 || !op) break;
-      if (op != (uint8_t)op1 && op != (uint8_t)(op1 >> 8)
-          && op != (uint8_t)(op1 >> 16) && op != (uint8_t)(op1 >> 24)) {
-        break;
-      }
-      s->op = op;
-    }
-
-    pos++;
-    switch (opcode_info[op].fmt) {
-    case OP_FMT_loc8:
-    case OP_FMT_u8: {
-      int idx = tab[pos];
-      int arg = va_arg (ap, int);
-      if (arg == -1) {
-        s->idx = idx;
-      } else {
-        if (arg != idx) goto done;
-      }
-      break;
-    }
-    case OP_FMT_u16:
-    case OP_FMT_npop:
-    case OP_FMT_loc:
-    case OP_FMT_arg: {
-      int idx = get_u16 (tab + pos);
-      int arg = va_arg (ap, int);
-      if (arg == -1) {
-        s->idx = idx;
-      } else {
-        if (arg != idx) goto done;
-      }
-      break;
-    }
-    case OP_FMT_i32:
-    case OP_FMT_u32:
-    case OP_FMT_label:
-    case OP_FMT_const: {
-      s->label = get_u32 (tab + pos);
-      break;
-    }
-    case OP_FMT_label_u16: {
-      s->label = get_u32 (tab + pos);
-      s->val = get_u16 (tab + pos + 4);
-      break;
-    }
-    case OP_FMT_key: {
-      /* Store cpool index in the label field */
-      s->label = get_u32 (tab + pos);
-      break;
-    }
-    case OP_FMT_key_u8: {
-      s->label = get_u32 (tab + pos);
-      s->val = get_u8 (tab + pos + 4);
-      break;
-    }
-    case OP_FMT_key_u16: {
-      s->label = get_u32 (tab + pos);
-      s->val = get_u16 (tab + pos + 4);
-      break;
-    }
-    case OP_FMT_key_label_u16: {
-      s->label = get_u32 (tab + pos);
-      s->label = get_u32 (tab + pos + 4);
-      s->val = get_u16 (tab + pos + 8);
-      break;
-    }
-    default:
-      break;
-    }
-    pos = pos_next;
-  }
-done:
-  va_end (ap);
-  return ret;
-}
-
-static void instantiate_hoisted_definitions (JSContext *ctx, JSFunctionDef *s, DynBuf *bc) {
-  int i, idx;
-
-  /* add the hoisted functions in arguments and local variables */
-  for (i = 0; i < s->arg_count; i++) {
-    JSVarDef *vd = &s->args[i];
-    if (vd->func_pool_idx >= 0) {
-      dbuf_putc (bc, OP_fclosure);
-      dbuf_put_u32 (bc, vd->func_pool_idx);
-      dbuf_putc (bc, OP_put_arg);
-      dbuf_put_u16 (bc, i);
-    }
-  }
-  for (i = 0; i < s->var_count; i++) {
-    JSVarDef *vd = &s->vars[i];
-    if (vd->scope_level == 0 && vd->func_pool_idx >= 0) {
-      dbuf_putc (bc, OP_fclosure);
-      dbuf_put_u32 (bc, vd->func_pool_idx);
-      dbuf_putc (bc, OP_put_loc);
-      dbuf_put_u16 (bc, i);
-    }
-  }
-
-  /* add the global variables (only happens if s->is_global_var is
-     true) */
-  for (i = 0; i < s->global_var_count; i++) {
-    JSGlobalVar *hf = &s->global_vars[i];
-    int has_closure = 0;
-    BOOL force_init = hf->force_init;
-    /* we are in an eval, so the closure contains all the
-       enclosing variables */
-    /* If the outer function has a variable environment,
-       create a property for the variable there */
-    for (idx = 0; idx < s->closure_var_count; idx++) {
-      JSClosureVar *cv = &s->closure_var[idx];
-      if (js_key_equal (cv->var_name, hf->var_name)) {
-        has_closure = 2;
-        force_init = FALSE;
-        break;
-      }
-      if (js_key_equal_str (cv->var_name, "_var_")
-          || js_key_equal_str (cv->var_name, "_arg_var_")) {
-        int slot, depth = compute_closure_depth_slot(s, idx, &slot);
-        dbuf_putc (bc, OP_get_up);
-        dbuf_putc (bc, (uint8_t)depth);
-        dbuf_put_u16 (bc, (uint16_t)slot);
-        has_closure = 1;
-        force_init = TRUE;
-        break;
-      }
-    }
-    if (!has_closure) {
-      int flags;
-
-      flags = 0;
-      if (hf->cpool_idx >= 0 && !hf->is_lexical) {
-        /* global function definitions need a specific handling */
-        dbuf_putc (bc, OP_fclosure);
-        dbuf_put_u32 (bc, hf->cpool_idx);
-
-        {
-          int key_idx = fd_cpool_add (ctx, s, hf->var_name);
-          dbuf_putc (bc, OP_define_func);
-          dbuf_put_u32 (bc, key_idx);
-          dbuf_putc (bc, flags);
-        }
-
-        goto done_global_var;
-      } else {
-        if (hf->is_lexical) { flags |= DEFINE_GLOBAL_LEX_VAR; }
-        int key_idx = fd_cpool_add (ctx, s, hf->var_name);
-        dbuf_putc (bc, OP_define_var);
-        dbuf_put_u32 (bc, key_idx);
-        dbuf_putc (bc, flags);
-      }
-    }
-    if (hf->cpool_idx >= 0 || force_init) {
-      if (hf->cpool_idx >= 0) {
-        dbuf_putc (bc, OP_fclosure);
-        dbuf_put_u32 (bc, hf->cpool_idx);
-        if (js_key_equal_str (hf->var_name, "_default_")) {
-          /* set default export function name */
-          int name_idx = fd_cpool_add (ctx, s, JS_KEY_default);
-          dbuf_putc (bc, OP_set_name);
-          dbuf_put_u32 (bc, name_idx);
-        }
-      } else {
-        dbuf_putc (bc, OP_null);
-      }
-      if (has_closure == 2) {
-        int slot, depth = compute_closure_depth_slot(s, idx, &slot);
-        dbuf_putc (bc, OP_set_up);
-        dbuf_putc (bc, (uint8_t)depth);
-        dbuf_put_u16 (bc, (uint16_t)slot);
-      } else if (has_closure == 1) {
-        int key_idx = fd_cpool_add (ctx, s, hf->var_name);
-        dbuf_putc (bc, OP_define_field);
-        dbuf_put_u32 (bc, key_idx);
-        dbuf_putc (bc, OP_drop);
-      } else {
-        /* XXX: Check if variable is writable and enumerable */
-        int key_idx = fd_cpool_add (ctx, s, hf->var_name);
-        dbuf_putc (bc, OP_put_var);
-        dbuf_put_u32 (bc, key_idx);
-      }
-    }
-  done_global_var:;
-  }
-
-  js_free (ctx, s->global_vars);
-  s->global_vars = NULL;
-  s->global_var_count = 0;
-  s->global_var_size = 0;
-}
-
-static int skip_dead_code (JSFunctionDef *s, const uint8_t *bc_buf, int bc_len, int pos, int *linep) {
-  int op, len, label;
-
-  for (; pos < bc_len; pos += len) {
-    op = bc_buf[pos];
-    len = opcode_info[op].size;
-    if (op == OP_line_num) {
-      *linep = get_u32 (bc_buf + pos + 1);
-    } else if (op == OP_label) {
-      label = get_u32 (bc_buf + pos + 1);
-      if (update_label (s, label, 0) > 0) break;
-      assert (s->label_slots[label].first_reloc == NULL);
-    } else {
-      /* XXX: output a warning for unreachable code? */
-      switch (opcode_info[op].fmt) {
-      case OP_FMT_label:
-      case OP_FMT_label_u16:
-        label = get_u32 (bc_buf + pos + 1);
-        update_label (s, label, -1);
-        break;
-      case OP_FMT_key_label_u16:
-        label = get_u32 (bc_buf + pos + 5);
-        update_label (s, label, -1);
-        /* fall thru */
-      case OP_FMT_key:
-      case OP_FMT_key_u8:
-      case OP_FMT_key_u16:
-        /* Key operand is a cpool index; cpool values freed separately */
-        break;
-      default:
-        break;
-      }
-    }
-  }
-  return pos;
-}
-
-static int get_label_pos (JSFunctionDef *s, int label) {
-  int i, pos;
-  for (i = 0; i < 20; i++) {
-    pos = s->label_slots[label].pos;
-    for (;;) {
-      switch (s->byte_code.buf[pos]) {
-      case OP_line_num:
-      case OP_label:
-        pos += 5;
-        continue;
-      case OP_goto:
-        label = get_u32 (s->byte_code.buf + pos + 1);
-        break;
-      default:
-        return pos;
-      }
-      break;
-    }
-  }
-  return pos;
-}
-
-/* convert global variable accesses to local variables or closure
-   variables when necessary */
-static __exception int resolve_variables (JSContext *ctx, JSFunctionDef *s) {
-  int pos, pos_next, bc_len, op, len, i, idx, line_num;
-  uint8_t *bc_buf;
-  JSValue var_name;
-  int cpool_idx;
-  DynBuf bc_out;
-  CodeContext cc;
-  int scope;
-
-  cc.bc_buf = bc_buf = s->byte_code.buf;
-  cc.bc_len = bc_len = s->byte_code.size;
-  js_dbuf_init (ctx, &bc_out);
-
-  /* first pass for runtime checks (must be done before the
-     variables are created) */
-  for (i = 0; i < s->global_var_count; i++) {
-    JSGlobalVar *hf = &s->global_vars[i];
-    int flags;
-
-    /* check if global variable (XXX: simplify) */
-    for (idx = 0; idx < s->closure_var_count; idx++) {
-      JSClosureVar *cv = &s->closure_var[idx];
-      if (js_key_equal (cv->var_name, hf->var_name)) {
-        goto next;
-      }
-      if (js_key_equal_str (cv->var_name, "<var>")
-          || js_key_equal_str (cv->var_name, "<arg_var>"))
-        goto next;
-    }
-
-    {
-      int key_idx = fd_cpool_add (ctx, s, hf->var_name);
-      dbuf_putc (&bc_out, OP_check_define_var);
-      dbuf_put_u32 (&bc_out, key_idx);
-    }
-    flags = 0;
-    if (hf->is_lexical) flags |= DEFINE_GLOBAL_LEX_VAR;
-    if (hf->cpool_idx >= 0) flags |= DEFINE_GLOBAL_FUNC_VAR;
-    dbuf_putc (&bc_out, flags);
-  next:;
-  }
-
-  line_num = 0; /* avoid warning */
-  for (pos = 0; pos < bc_len; pos = pos_next) {
-    op = bc_buf[pos];
-    len = opcode_info[op].size;
-    pos_next = pos + len;
-    switch (op) {
-    case OP_line_num:
-      line_num = get_u32 (bc_buf + pos + 1);
-      s->line_number_size++;
-      goto no_change;
-
-    case OP_scope_get_var_checkthis:
-    case OP_scope_get_var_undef:
-    case OP_scope_get_var:
-    case OP_scope_put_var:
-    case OP_scope_delete_var:
-    case OP_scope_put_var_init:
-      cpool_idx = get_u32 (bc_buf + pos + 1);
-      var_name = s->cpool[cpool_idx];
-      scope = get_u16 (bc_buf + pos + 5);
-      pos_next = resolve_scope_var (ctx, s, var_name, scope, op, &bc_out, NULL, NULL, pos_next);
-      break;
-    case OP_gosub:
-      s->jump_size++;
-      if (OPTIMIZE) {
-        /* remove calls to empty finalizers  */
-        int label;
-        LabelSlot *ls;
-
-        label = get_u32 (bc_buf + pos + 1);
-        assert (label >= 0 && label < s->label_count);
-        ls = &s->label_slots[label];
-        if (code_match (&cc, ls->pos, OP_ret, -1)) {
-          ls->ref_count--;
-          break;
-        }
-      }
-      goto no_change;
-    case OP_drop:
-      if (0) {
-        /* remove drops before return_undef */
-        /* do not perform this optimization in pass2 because
-           it breaks patterns recognised in resolve_labels */
-        int pos1 = pos_next;
-        int line1 = line_num;
-        while (code_match (&cc, pos1, OP_drop, -1)) {
-          if (cc.line_num >= 0) line1 = cc.line_num;
-          pos1 = cc.pos;
-        }
-        if (code_match (&cc, pos1, OP_return_undef, -1)) {
-          pos_next = pos1;
-          if (line1 != -1 && line1 != line_num) {
-            line_num = line1;
-            s->line_number_size++;
-            dbuf_putc (&bc_out, OP_line_num);
-            dbuf_put_u32 (&bc_out, line_num);
-          }
-          break;
-        }
-      }
-      goto no_change;
-    case OP_insert3:
-      if (OPTIMIZE) {
-        /* Transformation: insert3 put_array_el drop -> put_array_el */
-        if (code_match (&cc, pos_next, OP_put_array_el, OP_drop, -1)) {
-          dbuf_putc (&bc_out, cc.op);
-          pos_next = cc.pos;
-          if (cc.line_num != -1 && cc.line_num != line_num) {
-            line_num = cc.line_num;
-            s->line_number_size++;
-            dbuf_putc (&bc_out, OP_line_num);
-            dbuf_put_u32 (&bc_out, line_num);
-          }
-          break;
-        }
-      }
-      goto no_change;
-
-    case OP_goto:
-      s->jump_size++;
-      /* fall thru */
-    case OP_tail_call:
-    case OP_tail_call_method:
-    case OP_return:
-    case OP_return_undef:
-    case OP_throw:
-    case OP_throw_error:
-    case OP_ret:
-      if (OPTIMIZE) {
-        /* remove dead code */
-        int line = -1;
-        dbuf_put (&bc_out, bc_buf + pos, len);
-        pos = skip_dead_code (s, bc_buf, bc_len, pos + len, &line);
-        pos_next = pos;
-        if (pos < bc_len && line >= 0 && line_num != line) {
-          line_num = line;
-          s->line_number_size++;
-          dbuf_putc (&bc_out, OP_line_num);
-          dbuf_put_u32 (&bc_out, line_num);
-        }
-        break;
-      }
-      goto no_change;
-
-    case OP_label: {
-      int label;
-      LabelSlot *ls;
-
-      label = get_u32 (bc_buf + pos + 1);
-      assert (label >= 0 && label < s->label_count);
-      ls = &s->label_slots[label];
-      ls->pos2 = bc_out.size + opcode_info[op].size;
-    }
-      goto no_change;
-
-    case OP_enter_scope: {
-      int scope_idx, scope = get_u16 (bc_buf + pos + 1);
-
-      if (scope == s->body_scope) {
-        instantiate_hoisted_definitions (ctx, s, &bc_out);
-      }
-
-      for (scope_idx = s->scopes[scope].first; scope_idx >= 0;) {
-        JSVarDef *vd = &s->vars[scope_idx];
-        if (vd->scope_level != scope) break;
-
-        if (vd->var_kind == JS_VAR_FUNCTION_DECL
-            || vd->var_kind == JS_VAR_NEW_FUNCTION_DECL) {
-          /* Initialize lexical variable upon entering scope */
-          dbuf_putc (&bc_out, OP_fclosure);
-          dbuf_put_u32 (&bc_out, vd->func_pool_idx);
-          dbuf_putc (&bc_out, OP_put_loc);
-          dbuf_put_u16 (&bc_out, scope_idx);
-        } else {
-          /* XXX: should check if variable can be used
-             before initialization */
-          dbuf_putc (&bc_out, OP_set_loc_uninitialized);
-          dbuf_put_u16 (&bc_out, scope_idx);
-        }
-
-        scope_idx = vd->scope_next;
-      }
-    } break;
-
-    case OP_leave_scope:
-      /* With outer_frame model, captured variables don't need closing */
-      break;
-
-    case OP_set_name: {
-      /* remove dummy set_name opcodes */
-      int name_idx = get_u32 (bc_buf + pos + 1);
-      if (JS_IsNull (s->cpool[name_idx])) break;
-    }
-      goto no_change;
-
-    case OP_if_false:
-    case OP_if_true:
-    case OP_catch:
-      s->jump_size++;
-      goto no_change;
-
-    case OP_dup:
-      if (OPTIMIZE) {
-        /* Transformation: dup if_false(l1) drop, l1: if_false(l2) ->
-         * if_false(l2) */
-        /* Transformation: dup if_true(l1) drop, l1: if_true(l2) -> if_true(l2)
-         */
-        if (code_match (&cc, pos_next, M2 (OP_if_false, OP_if_true), OP_drop, -1)) {
-          int lab0, lab1, op1, pos1, line1, pos2;
-          lab0 = lab1 = cc.label;
-          assert (lab1 >= 0 && lab1 < s->label_count);
-          op1 = cc.op;
-          pos1 = cc.pos;
-          line1 = cc.line_num;
-          while (code_match (&cc, (pos2 = get_label_pos (s, lab1)), OP_dup, op1, OP_drop, -1)) {
-            lab1 = cc.label;
-          }
-          if (code_match (&cc, pos2, op1, -1)) {
-            s->jump_size++;
-            update_label (s, lab0, -1);
-            update_label (s, cc.label, +1);
-            dbuf_putc (&bc_out, op1);
-            dbuf_put_u32 (&bc_out, cc.label);
-            pos_next = pos1;
-            if (line1 != -1 && line1 != line_num) {
-              line_num = line1;
-              s->line_number_size++;
-              dbuf_putc (&bc_out, OP_line_num);
-              dbuf_put_u32 (&bc_out, line_num);
-            }
-            break;
-          }
-        }
-      }
-      goto no_change;
-
-    case OP_nop:
-      /* remove erased code */
-      break;
-    case OP_set_class_name:
-      /* only used during parsing */
-      break;
-
-    case OP_get_field_opt_chain: /* equivalent to OP_get_field */
-    {
-      int key_idx = get_u32 (bc_buf + pos + 1);
-      dbuf_putc (&bc_out, OP_get_field);
-      dbuf_put_u32 (&bc_out, key_idx);
-    } break;
-    case OP_get_array_el_opt_chain: /* equivalent to OP_get_array_el */
-      dbuf_putc (&bc_out, OP_get_array_el);
-      break;
-
-    default:
-    no_change:
-      dbuf_put (&bc_out, bc_buf + pos, len);
-      break;
-    }
-  }
-
-  /* set the new byte code */
-  dbuf_free (&s->byte_code);
-  s->byte_code = bc_out;
-  if (dbuf_error (&s->byte_code)) {
-    JS_ThrowOutOfMemory (ctx);
-    return -1;
-  }
-  return 0;
-}
-
-/* the pc2line table gives a source position for each PC value */
-static void add_pc2line_info (JSFunctionDef *s, uint32_t pc, uint32_t source_pos) {
-  if (s->line_number_slots != NULL
-      && s->line_number_count < s->line_number_size
-      && pc >= s->line_number_last_pc && source_pos != s->line_number_last) {
-    s->line_number_slots[s->line_number_count].pc = pc;
-    s->line_number_slots[s->line_number_count].source_pos = source_pos;
-    s->line_number_count++;
-    s->line_number_last_pc = pc;
-    s->line_number_last = source_pos;
-  }
-}
-
-/* XXX: could use a more compact storage */
-/* XXX: get_line_col_cached() is slow. For more predictable
-   performance, line/cols could be stored every N source
-   bytes. Alternatively, get_line_col_cached() could be issued in
-   emit_source_pos() so that the deltas are more likely to be
-   small. */
-static void compute_pc2line_info (JSFunctionDef *s) {
-  if (!s->strip_debug) {
-    int last_line_num, last_col_num;
-    uint32_t last_pc = 0;
-    int i, line_num, col_num;
-    const uint8_t *buf_start = s->get_line_col_cache->buf_start;
-    js_dbuf_init (s->ctx, &s->pc2line);
-
-    last_line_num = get_line_col_cached (s->get_line_col_cache, &last_col_num, buf_start + s->source_pos);
-    dbuf_put_leb128 (&s->pc2line, last_line_num); /* line number minus 1 */
-    dbuf_put_leb128 (&s->pc2line, last_col_num);  /* column number minus 1 */
-
-    for (i = 0; i < s->line_number_count; i++) {
-      uint32_t pc = s->line_number_slots[i].pc;
-      uint32_t source_pos = s->line_number_slots[i].source_pos;
-      int diff_pc, diff_line, diff_col;
-
-      if (source_pos == -1) continue;
-      diff_pc = pc - last_pc;
-      if (diff_pc < 0) continue;
-
-      line_num = get_line_col_cached (s->get_line_col_cache, &col_num, buf_start + source_pos);
-      diff_line = line_num - last_line_num;
-      diff_col = col_num - last_col_num;
-      if (diff_line == 0 && diff_col == 0) continue;
-
-      if (diff_line >= PC2LINE_BASE && diff_line < PC2LINE_BASE + PC2LINE_RANGE
-          && diff_pc <= PC2LINE_DIFF_PC_MAX) {
-        dbuf_putc (&s->pc2line, (diff_line - PC2LINE_BASE) + diff_pc * PC2LINE_RANGE + PC2LINE_OP_FIRST);
-      } else {
-        /* longer encoding */
-        dbuf_putc (&s->pc2line, 0);
-        dbuf_put_leb128 (&s->pc2line, diff_pc);
-        dbuf_put_sleb128 (&s->pc2line, diff_line);
-      }
-      dbuf_put_sleb128 (&s->pc2line, diff_col);
-
-      last_pc = pc;
-      last_line_num = line_num;
-      last_col_num = col_num;
-    }
-  }
-}
-
-static RelocEntry *add_reloc (JSContext *ctx, LabelSlot *ls, uint32_t addr, int size) {
-  RelocEntry *re;
-  (void)ctx;
-  re = pjs_malloc (sizeof (*re));
-  if (!re) return NULL;
-  re->addr = addr;
-  re->size = size;
-  re->next = ls->first_reloc;
-  ls->first_reloc = re;
-  return re;
-}
-
-static BOOL code_has_label (CodeContext *s, int pos, int label) {
-  while (pos < s->bc_len) {
-    int op = s->bc_buf[pos];
-    if (op == OP_line_num) {
-      pos += 5;
-      continue;
-    }
-    if (op == OP_label) {
-      int lab = get_u32 (s->bc_buf + pos + 1);
-      if (lab == label) return TRUE;
-      pos += 5;
-      continue;
-    }
-    if (op == OP_goto) {
-      int lab = get_u32 (s->bc_buf + pos + 1);
-      if (lab == label) return TRUE;
-    }
-    break;
-  }
-  return FALSE;
-}
-
-/* return the target label, following the OP_goto jumps
-   the first opcode at destination is stored in *pop
- */
-static int find_jump_target (JSFunctionDef *s, int label0, int *pop, int *pline) {
-  int i, pos, op, label;
-
-  label = label0;
-  update_label (s, label, -1);
-  for (i = 0; i < 10; i++) {
-    assert (label >= 0 && label < s->label_count);
-    pos = s->label_slots[label].pos2;
-    for (;;) {
-      switch (op = s->byte_code.buf[pos]) {
-      case OP_line_num:
-        if (pline) *pline = get_u32 (s->byte_code.buf + pos + 1);
-        /* fall thru */
-      case OP_label:
-        pos += opcode_info[op].size;
-        continue;
-      case OP_goto:
-        label = get_u32 (s->byte_code.buf + pos + 1);
-        break;
-      case OP_drop:
-        /* ignore drop opcodes if followed by OP_return_undef */
-        while (s->byte_code.buf[++pos] == OP_drop)
-          continue;
-        if (s->byte_code.buf[pos] == OP_return_undef) op = OP_return_undef;
-        /* fall thru */
-      default:
-        goto done;
-      }
-      break;
-    }
-  }
-  /* cycle detected, could issue a warning */
-  /* XXX: the combination of find_jump_target() and skip_dead_code()
-     seems incorrect with cyclic labels. See for exemple:
-
-     for (;;) {
-     l:break l;
-     l:break l;
-     l:break l;
-     l:break l;
-     }
-
-     Avoiding changing the target is just a workaround and might not
-     suffice to completely fix the problem. */
-  label = label0;
-done:
-  *pop = op;
-  update_label (s, label, +1);
-  return label;
-}
-
-static void push_short_int (DynBuf *bc_out, int val) {
-#if SHORT_OPCODES
-  if (val >= -1 && val <= 7) {
-    dbuf_putc (bc_out, OP_push_0 + val);
-    return;
-  }
-  if (val == (int8_t)val) {
-    dbuf_putc (bc_out, OP_push_i8);
-    dbuf_putc (bc_out, val);
-    return;
-  }
-  if (val == (int16_t)val) {
-    dbuf_putc (bc_out, OP_push_i16);
-    dbuf_put_u16 (bc_out, val);
-    return;
-  }
-#endif
-  dbuf_putc (bc_out, OP_push_i32);
-  dbuf_put_u32 (bc_out, val);
-}
-
-static void put_short_code (DynBuf *bc_out, int op, int idx) {
-#if SHORT_OPCODES
-  if (idx < 4) {
-    switch (op) {
-    case OP_get_loc:
-      dbuf_putc (bc_out, OP_get_loc0 + idx);
-      return;
-    case OP_put_loc:
-      dbuf_putc (bc_out, OP_put_loc0 + idx);
-      return;
-    case OP_set_loc:
-      dbuf_putc (bc_out, OP_set_loc0 + idx);
-      return;
-    case OP_get_arg:
-      dbuf_putc (bc_out, OP_get_arg0 + idx);
-      return;
-    case OP_put_arg:
-      dbuf_putc (bc_out, OP_put_arg0 + idx);
-      return;
-    case OP_set_arg:
-      dbuf_putc (bc_out, OP_set_arg0 + idx);
-      return;
-    case OP_call:
-      dbuf_putc (bc_out, OP_call0 + idx);
-      return;
-    }
-  }
-  if (idx < 256) {
-    switch (op) {
-    case OP_get_loc:
-      dbuf_putc (bc_out, OP_get_loc8);
-      dbuf_putc (bc_out, idx);
-      return;
-    case OP_put_loc:
-      dbuf_putc (bc_out, OP_put_loc8);
-      dbuf_putc (bc_out, idx);
-      return;
-    case OP_set_loc:
-      dbuf_putc (bc_out, OP_set_loc8);
-      dbuf_putc (bc_out, idx);
-      return;
-    }
-  }
-#endif
-  dbuf_putc (bc_out, op);
-  dbuf_put_u16 (bc_out, idx);
-}
-
-/* peephole optimizations and resolve goto/labels */
-static __exception int resolve_labels (JSContext *ctx, JSFunctionDef *s) {
-  int pos, pos_next, bc_len, op, op1, len, i, line_num;
-  const uint8_t *bc_buf;
-  DynBuf bc_out;
-  LabelSlot *label_slots, *ls;
-  RelocEntry *re, *re_next;
-  CodeContext cc;
-  int label;
-#if SHORT_OPCODES
-  JumpSlot *jp;
-#endif
-
-  label_slots = s->label_slots;
-
-  line_num = s->source_pos;
-
-  cc.bc_buf = bc_buf = s->byte_code.buf;
-  cc.bc_len = bc_len = s->byte_code.size;
-  js_dbuf_init (ctx, &bc_out);
-
-#if SHORT_OPCODES
-  if (s->jump_size) {
-    s->jump_slots
-      = pjs_mallocz (sizeof (*s->jump_slots) * s->jump_size);
-    if (s->jump_slots == NULL) return -1;
-  }
-#endif
-  /* XXX: Should skip this phase if not generating SHORT_OPCODES */
-  if (s->line_number_size && !s->strip_debug) {
-    s->line_number_slots = pjs_mallocz (sizeof (*s->line_number_slots) * s->line_number_size);
-    if (s->line_number_slots == NULL) return -1;
-    s->line_number_last = s->source_pos;
-    s->line_number_last_pc = 0;
-  }
-
-  /* initialize the 'this.active_func' variable if needed */
-  if (s->this_active_func_var_idx >= 0) {
-    dbuf_putc (&bc_out, OP_special_object);
-    dbuf_putc (&bc_out, OP_SPECIAL_OBJECT_THIS_FUNC);
-    put_short_code (&bc_out, OP_put_loc, s->this_active_func_var_idx);
-  }
-  /* initialize the 'this' variable if needed */
-  if (s->this_var_idx >= 0) {
-    dbuf_putc (&bc_out, OP_push_this);
-    put_short_code (&bc_out, OP_put_loc, s->this_var_idx);
-  }
-  /* initialize a reference to the current function if needed */
-  if (s->func_var_idx >= 0) {
-    dbuf_putc (&bc_out, OP_special_object);
-    dbuf_putc (&bc_out, OP_SPECIAL_OBJECT_THIS_FUNC);
-    put_short_code (&bc_out, OP_put_loc, s->func_var_idx);
-  }
-  /* initialize the variable environment object if needed */
-  if (s->var_object_idx >= 0) {
-    dbuf_putc (&bc_out, OP_special_object);
-    dbuf_putc (&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
-    put_short_code (&bc_out, OP_put_loc, s->var_object_idx);
-  }
-  if (s->arg_var_object_idx >= 0) {
-    dbuf_putc (&bc_out, OP_special_object);
-    dbuf_putc (&bc_out, OP_SPECIAL_OBJECT_VAR_OBJECT);
-    put_short_code (&bc_out, OP_put_loc, s->arg_var_object_idx);
-  }
-
-  for (pos = 0; pos < bc_len; pos = pos_next) {
-    int val;
-    op = bc_buf[pos];
-    len = opcode_info[op].size;
-    pos_next = pos + len;
-    switch (op) {
-    case OP_line_num:
-      /* line number info (for debug). We put it in a separate
-         compressed table to reduce memory usage and get better
-         performance */
-      line_num = get_u32 (bc_buf + pos + 1);
-      break;
-
-    case OP_label: {
-      label = get_u32 (bc_buf + pos + 1);
-      assert (label >= 0 && label < s->label_count);
-      ls = &label_slots[label];
-      assert (ls->addr == -1);
-      ls->addr = bc_out.size;
-      /* resolve the relocation entries */
-      for (re = ls->first_reloc; re != NULL; re = re_next) {
-        int diff = ls->addr - re->addr;
-        re_next = re->next;
-        switch (re->size) {
-        case 4:
-          put_u32 (bc_out.buf + re->addr, diff);
-          break;
-        case 2:
-          assert (diff == (int16_t)diff);
-          put_u16 (bc_out.buf + re->addr, diff);
-          break;
-        case 1:
-          assert (diff == (int8_t)diff);
-          put_u8 (bc_out.buf + re->addr, diff);
-          break;
-        }
-        pjs_free (re);
-      }
-      ls->first_reloc = NULL;
-    } break;
-
-    case OP_call:
-    case OP_call_method: {
-      /* detect and transform tail calls */
-      int argc;
-      argc = get_u16 (bc_buf + pos + 1);
-      if (code_match (&cc, pos_next, OP_return, -1)) {
-        if (cc.line_num >= 0) line_num = cc.line_num;
-        add_pc2line_info (s, bc_out.size, line_num);
-        put_short_code (&bc_out, op + 1, argc);
-        pos_next = skip_dead_code (s, bc_buf, bc_len, cc.pos, &line_num);
-        break;
-      }
-      add_pc2line_info (s, bc_out.size, line_num);
-      put_short_code (&bc_out, op, argc);
-      break;
-    }
-      goto no_change;
-
-    case OP_return:
-    case OP_return_undef:
-    case OP_throw:
-    case OP_throw_error:
-      pos_next = skip_dead_code (s, bc_buf, bc_len, pos_next, &line_num);
-      goto no_change;
-
-    case OP_goto:
-      label = get_u32 (bc_buf + pos + 1);
-    has_goto:
-      if (OPTIMIZE) {
-        int line1 = -1;
-        /* Use custom matcher because multiple labels can follow */
-        label = find_jump_target (s, label, &op1, &line1);
-        if (code_has_label (&cc, pos_next, label)) {
-          /* jump to next instruction: remove jump */
-          update_label (s, label, -1);
-          break;
-        }
-        if (op1 == OP_return || op1 == OP_return_undef || op1 == OP_throw) {
-          /* jump to return/throw: remove jump, append return/throw */
-          /* updating the line number obfuscates assembly listing */
-          // if (line1 != -1) line_num = line1;
-          update_label (s, label, -1);
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, op1);
-          pos_next = skip_dead_code (s, bc_buf, bc_len, pos_next, &line_num);
-          break;
-        }
-        /* XXX: should duplicate single instructions followed by goto or return
-         */
-        /* For example, can match one of these followed by return:
-           push_i32 / push_const / push_atom_value / get_var /
-           undefined / null / push_false / push_true / get_ref_value /
-           get_loc / get_arg / get_var_ref
-         */
-      }
-      goto has_label;
-
-    case OP_gosub:
-      label = get_u32 (bc_buf + pos + 1);
-      if (0 && OPTIMIZE) {
-        label = find_jump_target (s, label, &op1, NULL);
-        if (op1 == OP_ret) {
-          update_label (s, label, -1);
-          /* empty finally clause: remove gosub */
-          break;
-        }
-      }
-      goto has_label;
-
-    case OP_catch:
-      label = get_u32 (bc_buf + pos + 1);
-      goto has_label;
-
-    case OP_if_true:
-    case OP_if_false:
-      label = get_u32 (bc_buf + pos + 1);
-      if (OPTIMIZE) {
-        label = find_jump_target (s, label, &op1, NULL);
-        /* transform if_false/if_true(l1) label(l1) -> drop label(l1) */
-        if (code_has_label (&cc, pos_next, label)) {
-          update_label (s, label, -1);
-          dbuf_putc (&bc_out, OP_drop);
-          break;
-        }
-        /* transform if_false(l1) goto(l2) label(l1) -> if_false(l2) label(l1)
-         */
-        if (code_match (&cc, pos_next, OP_goto, -1)) {
-          int pos1 = cc.pos;
-          int line1 = cc.line_num;
-          if (code_has_label (&cc, pos1, label)) {
-            if (line1 != -1) line_num = line1;
-            pos_next = pos1;
-            update_label (s, label, -1);
-            label = cc.label;
-            op ^= OP_if_true ^ OP_if_false;
-          }
-        }
-      }
-    has_label:
-      add_pc2line_info (s, bc_out.size, line_num);
-      if (op == OP_goto) {
-        pos_next = skip_dead_code (s, bc_buf, bc_len, pos_next, &line_num);
-      }
-      assert (label >= 0 && label < s->label_count);
-      ls = &label_slots[label];
-#if SHORT_OPCODES
-      jp = &s->jump_slots[s->jump_count++];
-      jp->op = op;
-      jp->size = 4;
-      jp->pos = bc_out.size + 1;
-      jp->label = label;
-
-      if (ls->addr == -1) {
-        int diff = ls->pos2 - pos - 1;
-        if (diff < 128
-            && (op == OP_if_false || op == OP_if_true || op == OP_goto)) {
-          jp->size = 1;
-          jp->op = OP_if_false8 + (op - OP_if_false);
-          dbuf_putc (&bc_out, OP_if_false8 + (op - OP_if_false));
-          dbuf_putc (&bc_out, 0);
-          if (!add_reloc (ctx, ls, bc_out.size - 1, 1)) goto fail;
-          break;
-        }
-        if (diff < 32768 && op == OP_goto) {
-          jp->size = 2;
-          jp->op = OP_goto16;
-          dbuf_putc (&bc_out, OP_goto16);
-          dbuf_put_u16 (&bc_out, 0);
-          if (!add_reloc (ctx, ls, bc_out.size - 2, 2)) goto fail;
-          break;
-        }
-      } else {
-        int diff = ls->addr - bc_out.size - 1;
-        if (diff == (int8_t)diff
-            && (op == OP_if_false || op == OP_if_true || op == OP_goto)) {
-          jp->size = 1;
-          jp->op = OP_if_false8 + (op - OP_if_false);
-          dbuf_putc (&bc_out, OP_if_false8 + (op - OP_if_false));
-          dbuf_putc (&bc_out, diff);
-          break;
-        }
-        if (diff == (int16_t)diff && op == OP_goto) {
-          jp->size = 2;
-          jp->op = OP_goto16;
-          dbuf_putc (&bc_out, OP_goto16);
-          dbuf_put_u16 (&bc_out, diff);
-          break;
-        }
-      }
-#endif
-      dbuf_putc (&bc_out, op);
-      dbuf_put_u32 (&bc_out, ls->addr - bc_out.size);
-      if (ls->addr == -1) {
-        /* unresolved yet: create a new relocation entry */
-        if (!add_reloc (ctx, ls, bc_out.size - 4, 4)) goto fail;
-      }
-      break;
-    case OP_drop:
-      if (OPTIMIZE) {
-        /* remove useless drops before return */
-        if (code_match (&cc, pos_next, OP_return_undef, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          break;
-        }
-      }
-      goto no_change;
-
-    case OP_null:
-      if (OPTIMIZE) {
-        /* 1) remove null; drop → (nothing) */
-        if (code_match (&cc, pos_next, OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          pos_next = cc.pos;
-          break;
-        }
-        /* 2) null; return → return_undef */
-        if (code_match (&cc, pos_next, OP_return, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, OP_return_undef);
-          pos_next = cc.pos;
-          break;
-        }
-        /* 3) null; if_false/if_true → goto or nop */
-        if (code_match (&cc, pos_next, M2 (OP_if_false, OP_if_true), -1)) {
-          val = 0;
-          goto has_constant_test;
-        }
-#if SHORT_OPCODES
-        /* 4a) null strict_eq → is_null */
-        if (code_match (&cc, pos_next, OP_strict_eq, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, OP_is_null);
-          pos_next = cc.pos;
-          break;
-        }
-        /* 4b) null strict_neq; if_false/if_true → is_null + flipped branch */
-        if (code_match (&cc, pos_next, OP_strict_neq, M2 (OP_if_false, OP_if_true), -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, OP_is_null);
-          pos_next = cc.pos;
-          label = cc.label;
-          op = cc.op ^ OP_if_false ^ OP_if_true;
-          goto has_label;
-        }
-#endif
-      }
-      /* didn’t match any of the above? fall straight into the
-         OP_push_false / OP_push_true constant‐test code: */
-    case OP_push_false:
-    case OP_push_true:
-      if (OPTIMIZE) {
-        val = (op == OP_push_true);
-        if (code_match (&cc, pos_next, M2 (OP_if_false, OP_if_true), -1)) {
-        has_constant_test:
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          if (val == (cc.op - OP_if_false)) {
-            /* e.g.  null if_false(L)  → goto L */
-            pos_next = cc.pos;
-            op = OP_goto;
-            label = cc.label;
-            goto has_goto;
-          } else {
-            /* e.g.  null if_true(L) → nop */
-            pos_next = cc.pos;
-            update_label (s, cc.label, -1);
-            break;
-          }
-        }
-      }
-      goto no_change;
-
-    case OP_push_i32:
-      if (OPTIMIZE) {
-        /* transform i32(val) neg -> i32(-val) */
-        val = get_i32 (bc_buf + pos + 1);
-        if ((val != INT32_MIN && val != 0)
-            && code_match (&cc, pos_next, OP_neg, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          if (code_match (&cc, cc.pos, OP_drop, -1)) {
-            if (cc.line_num >= 0) line_num = cc.line_num;
-          } else {
-            add_pc2line_info (s, bc_out.size, line_num);
-            push_short_int (&bc_out, -val);
-          }
-          pos_next = cc.pos;
-          break;
-        }
-        /* remove push/drop pairs generated by the parser */
-        if (code_match (&cc, pos_next, OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          pos_next = cc.pos;
-          break;
-        }
-        /* Optimize constant tests: `if (0)`, `if (1)`, `if (!0)`... */
-        if (code_match (&cc, pos_next, M2 (OP_if_false, OP_if_true), -1)) {
-          val = (val != 0);
-          goto has_constant_test;
-        }
-        add_pc2line_info (s, bc_out.size, line_num);
-        push_short_int (&bc_out, val);
-        break;
-      }
-      goto no_change;
-
-#if SHORT_OPCODES
-    case OP_push_const:
-    case OP_fclosure:
-      if (OPTIMIZE) {
-        int idx = get_u32 (bc_buf + pos + 1);
-        if (idx < 256) {
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, OP_push_const8 + op - OP_push_const);
-          dbuf_putc (&bc_out, idx);
-          break;
-        }
-      }
-      goto no_change;
-#endif
-    case OP_to_propkey:
-      if (OPTIMIZE) {
-        /* remove redundant to_propkey opcodes when storing simple data */
-        if (code_match (&cc, pos_next, M2 (OP_get_loc, OP_get_arg), -1, OP_put_array_el, -1)
-            || code_match (&cc, pos_next, M2 (OP_push_i32, OP_push_const), OP_put_array_el, -1)
-            || code_match (&cc, pos_next, M4 (OP_null, OP_null, OP_push_true, OP_push_false), OP_put_array_el, -1)) {
-          break;
-        }
-      }
-      goto no_change;
-    case OP_insert2:
-      if (OPTIMIZE) {
-        /* Transformation:
-           insert2 put_field(a) drop -> put_field(a)
-           insert2 put_var_strict(a) drop -> put_var_strict(a)
-        */
-        if (code_match (&cc, pos_next, M2 (OP_put_field, OP_put_var_strict), OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, cc.op);
-          dbuf_put_u32 (&bc_out, cc.label);
-          pos_next = cc.pos;
-          break;
-        }
-      }
-      goto no_change;
-
-    case OP_dup:
-      if (OPTIMIZE) {
-        /* Transformation: dup put_x(n) drop -> put_x(n) */
-        int op1, line2 = -1;
-        /* Transformation: dup put_x(n) -> set_x(n) */
-        if (code_match (&cc, pos_next, M2 (OP_put_loc, OP_put_arg), -1, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          op1 = cc.op + 1; /* put_x -> set_x */
-          pos_next = cc.pos;
-          if (code_match (&cc, cc.pos, OP_drop, -1)) {
-            if (cc.line_num >= 0) line_num = cc.line_num;
-            op1 -= 1; /* set_x drop -> put_x */
-            pos_next = cc.pos;
-            if (code_match (&cc, cc.pos, op1 - 1, cc.idx, -1)) {
-              line2 = cc.line_num; /* delay line number update */
-              op1 += 1;            /* put_x(n) get_x(n) -> set_x(n) */
-              pos_next = cc.pos;
-            }
-          }
-          add_pc2line_info (s, bc_out.size, line_num);
-          put_short_code (&bc_out, op1, cc.idx);
-          if (line2 >= 0) line_num = line2;
-          break;
-        }
-      }
-      goto no_change;
-
-    case OP_get_loc:
-      if (OPTIMIZE) {
-        /* transformation:
-           get_loc(n) post_dec put_loc(n) drop -> dec_loc(n)
-           get_loc(n) post_inc put_loc(n) drop -> inc_loc(n)
-           get_loc(n) dec dup put_loc(n) drop -> dec_loc(n)
-           get_loc(n) inc dup put_loc(n) drop -> inc_loc(n)
-         */
-        int idx;
-        idx = get_u16 (bc_buf + pos + 1);
-        if (idx >= 256) goto no_change;
-        if (code_match (&cc, pos_next, M2 (OP_post_dec, OP_post_inc), OP_put_loc, idx, OP_drop, -1)
-            || code_match (&cc, pos_next, M2 (OP_dec, OP_inc), OP_dup, OP_put_loc, idx, OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, (cc.op == OP_inc || cc.op == OP_post_inc) ? OP_inc_loc : OP_dec_loc);
-          dbuf_putc (&bc_out, idx);
-          pos_next = cc.pos;
-          break;
-        }
-        /* transformation:
-           get_loc(n) push_i32(x) add dup put_loc(n) drop -> push_i32(x)
-           add_loc(n)
-         */
-        if (code_match (&cc, pos_next, OP_push_i32, OP_add, OP_dup, OP_put_loc, idx, OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          push_short_int (&bc_out, cc.label);
-          dbuf_putc (&bc_out, OP_add_loc);
-          dbuf_putc (&bc_out, idx);
-          pos_next = cc.pos;
-          break;
-        }
-        /* transformation:
-           get_loc(n) get_loc(x) add dup put_loc(n) drop -> get_loc(x) add_loc(n)
-           get_loc(n) get_arg(x) add dup put_loc(n) drop -> get_arg(x) add_loc(n)
-         */
-        if (code_match (&cc, pos_next, M2 (OP_get_loc, OP_get_arg), -1, OP_add, OP_dup, OP_put_loc, idx, OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          put_short_code (&bc_out, cc.op, cc.idx);
-          dbuf_putc (&bc_out, OP_add_loc);
-          dbuf_putc (&bc_out, idx);
-          pos_next = cc.pos;
-          break;
-        }
-        add_pc2line_info (s, bc_out.size, line_num);
-        put_short_code (&bc_out, op, idx);
-        break;
-      }
-      goto no_change;
-#if SHORT_OPCODES
-    case OP_get_arg:
-      if (OPTIMIZE) {
-        int idx;
-        idx = get_u16 (bc_buf + pos + 1);
-        add_pc2line_info (s, bc_out.size, line_num);
-        put_short_code (&bc_out, op, idx);
-        break;
-      }
-      goto no_change;
-#endif
-    case OP_put_loc:
-    case OP_put_arg:
-      if (OPTIMIZE) {
-        /* transformation: put_x(n) get_x(n) -> set_x(n) */
-        int idx;
-        idx = get_u16 (bc_buf + pos + 1);
-        if (code_match (&cc, pos_next, op - 1, idx, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          put_short_code (&bc_out, op + 1, idx);
-          pos_next = cc.pos;
-          break;
-        }
-        add_pc2line_info (s, bc_out.size, line_num);
-        put_short_code (&bc_out, op, idx);
-        break;
-      }
-      goto no_change;
-
-    case OP_post_inc:
-    case OP_post_dec:
-      if (OPTIMIZE) {
-        /* transformation:
-           post_inc put_x drop -> inc put_x
-           post_inc perm3 put_field drop -> inc put_field
-           post_inc perm3 put_var_strict drop -> inc put_var_strict
-           post_inc perm4 put_array_el drop -> inc put_array_el
-         */
-        int op1, idx;
-        if (code_match (&cc, pos_next, M2 (OP_put_loc, OP_put_arg), -1, OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          op1 = cc.op;
-          idx = cc.idx;
-          pos_next = cc.pos;
-          if (code_match (&cc, cc.pos, op1 - 1, idx, -1)) {
-            if (cc.line_num >= 0) line_num = cc.line_num;
-            op1 += 1; /* put_x(n) get_x(n) -> set_x(n) */
-            pos_next = cc.pos;
-          }
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, OP_dec + (op - OP_post_dec));
-          put_short_code (&bc_out, op1, idx);
-          break;
-        }
-        if (code_match (&cc, pos_next, OP_perm3, M2 (OP_put_field, OP_put_var_strict), OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, OP_dec + (op - OP_post_dec));
-          dbuf_putc (&bc_out, cc.op);
-          dbuf_put_u32 (&bc_out, cc.label);
-          pos_next = cc.pos;
-          break;
-        }
-        if (code_match (&cc, pos_next, OP_perm4, OP_put_array_el, OP_drop, -1)) {
-          if (cc.line_num >= 0) line_num = cc.line_num;
-          add_pc2line_info (s, bc_out.size, line_num);
-          dbuf_putc (&bc_out, OP_dec + (op - OP_post_dec));
-          dbuf_putc (&bc_out, OP_put_array_el);
-          pos_next = cc.pos;
-          break;
-        }
-      }
-      goto no_change;
-
-    default:
-    no_change:
-      add_pc2line_info (s, bc_out.size, line_num);
-      dbuf_put (&bc_out, bc_buf + pos, len);
-      break;
-    }
-  }
-
-  /* check that there were no missing labels */
-  for (i = 0; i < s->label_count; i++) {
-    assert (label_slots[i].first_reloc == NULL);
-  }
-#if SHORT_OPCODES
-  if (OPTIMIZE) {
-    /* more jump optimizations */
-    int patch_offsets = 0;
-    for (i = 0, jp = s->jump_slots; i < s->jump_count; i++, jp++) {
-      LabelSlot *ls;
-      JumpSlot *jp1;
-      int j, pos, diff, delta;
-
-      delta = 3;
-      switch (op = jp->op) {
-      case OP_goto16:
-        delta = 1;
-        /* fall thru */
-      case OP_if_false:
-      case OP_if_true:
-      case OP_goto:
-        pos = jp->pos;
-        diff = s->label_slots[jp->label].addr - pos;
-        if (diff >= -128 && diff <= 127 + delta) {
-          // put_u8(bc_out.buf + pos, diff);
-          jp->size = 1;
-          if (op == OP_goto16) {
-            bc_out.buf[pos - 1] = jp->op = OP_goto8;
-          } else {
-            bc_out.buf[pos - 1] = jp->op = OP_if_false8 + (op - OP_if_false);
-          }
-          goto shrink;
-        } else if (diff == (int16_t)diff && op == OP_goto) {
-          // put_u16(bc_out.buf + pos, diff);
-          jp->size = 2;
-          delta = 2;
-          bc_out.buf[pos - 1] = jp->op = OP_goto16;
-        shrink:
-          /* XXX: should reduce complexity, using 2 finger copy scheme */
-          memmove (bc_out.buf + pos + jp->size,
-                   bc_out.buf + pos + jp->size + delta,
-                   bc_out.size - pos - jp->size - delta);
-          bc_out.size -= delta;
-          patch_offsets++;
-          for (j = 0, ls = s->label_slots; j < s->label_count; j++, ls++) {
-            if (ls->addr > pos) ls->addr -= delta;
-          }
-          for (j = i + 1, jp1 = jp + 1; j < s->jump_count; j++, jp1++) {
-            if (jp1->pos > pos) jp1->pos -= delta;
-          }
-          for (j = 0; j < s->line_number_count; j++) {
-            if (s->line_number_slots[j].pc > pos)
-              s->line_number_slots[j].pc -= delta;
-          }
-          continue;
-        }
-        break;
-      }
-    }
-    if (patch_offsets) {
-      JumpSlot *jp1;
-      int j;
-      for (j = 0, jp1 = s->jump_slots; j < s->jump_count; j++, jp1++) {
-        int diff1 = s->label_slots[jp1->label].addr - jp1->pos;
-        switch (jp1->size) {
-        case 1:
-          put_u8 (bc_out.buf + jp1->pos, diff1);
-          break;
-        case 2:
-          put_u16 (bc_out.buf + jp1->pos, diff1);
-          break;
-        case 4:
-          put_u32 (bc_out.buf + jp1->pos, diff1);
-          break;
-        }
-      }
-    }
-  }
-  pjs_free (s->jump_slots);
-  s->jump_slots = NULL;
-#endif
-  pjs_free (s->label_slots);
-  s->label_slots = NULL;
-  /* XXX: should delay until copying to runtime bytecode function */
-  compute_pc2line_info (s);
-  pjs_free (s->line_number_slots);
-  s->line_number_slots = NULL;
-  /* set the new byte code */
-  dbuf_free (&s->byte_code);
-  s->byte_code = bc_out;
-  s->use_short_opcodes = TRUE;
-  if (dbuf_error (&s->byte_code)) {
-    JS_ThrowOutOfMemory (ctx);
-    return -1;
-  }
-  return 0;
-fail:
-  /* XXX: not safe */
-  dbuf_free (&bc_out);
-  return -1;
-}
-
-/* compute the maximum stack size needed by the function */
-
-typedef struct StackSizeState {
-  int bc_len;
-  int stack_len_max;
-  uint16_t *stack_level_tab;
-  int32_t *catch_pos_tab;
-  int *pc_stack;
-  int pc_stack_len;
-  int pc_stack_size;
-} StackSizeState;
-
-/* 'op' is only used for error indication */
-static __exception int ss_check (JSContext *ctx, StackSizeState *s, int pos, int op, int stack_len, int catch_pos) {
-  if ((unsigned)pos >= s->bc_len) {
-    JS_ThrowInternalError (ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
-    return -1;
-  }
-  if (stack_len > s->stack_len_max) {
-    s->stack_len_max = stack_len;
-    if (s->stack_len_max > JS_STACK_SIZE_MAX) {
-      JS_ThrowInternalError (ctx, "stack overflow (op=%d, pc=%d)", op, pos);
-      return -1;
-    }
-  }
-  if (s->stack_level_tab[pos] != 0xffff) {
-    /* already explored: check that the stack size is consistent */
-    if (s->stack_level_tab[pos] != stack_len) {
-      JS_ThrowInternalError (ctx, "inconsistent stack size: %d %d (pc=%d)", s->stack_level_tab[pos], stack_len, pos);
-      return -1;
-    } else if (s->catch_pos_tab[pos] != catch_pos) {
-      JS_ThrowInternalError (ctx, "inconsistent catch position: %d %d (pc=%d)", s->catch_pos_tab[pos], catch_pos, pos);
-      return -1;
-    } else {
-      return 0;
-    }
-  }
-
-  /* mark as explored and store the stack size */
-  s->stack_level_tab[pos] = stack_len;
-  s->catch_pos_tab[pos] = catch_pos;
-
-  /* queue the new PC to explore */
-  if (pjs_resize_array ((void **)&s->pc_stack, sizeof (s->pc_stack[0]), &s->pc_stack_size, s->pc_stack_len + 1))
-    return -1;
-  s->pc_stack[s->pc_stack_len++] = pos;
-  return 0;
-}
-
-static __exception int compute_stack_size (JSContext *ctx, JSFunctionDef *fd, int *pstack_size) {
-  StackSizeState s_s, *s = &s_s;
-  int i, diff, n_pop, pos_next, stack_len, pos, op, catch_pos, catch_level;
-  const JSOpCode *oi;
-  const uint8_t *bc_buf;
-
-  bc_buf = fd->byte_code.buf;
-  s->bc_len = fd->byte_code.size;
-  /* bc_len > 0 */
-  s->stack_level_tab
-    = pjs_malloc (sizeof (s->stack_level_tab[0]) * s->bc_len);
-  if (!s->stack_level_tab) return -1;
-  for (i = 0; i < s->bc_len; i++)
-    s->stack_level_tab[i] = 0xffff;
-  s->pc_stack = NULL;
-  s->catch_pos_tab = pjs_malloc (sizeof (s->catch_pos_tab[0]) * s->bc_len);
-  if (!s->catch_pos_tab) goto fail;
-
-  s->stack_len_max = 0;
-  s->pc_stack_len = 0;
-  s->pc_stack_size = 0;
-
-  /* breadth-first graph exploration */
-  if (ss_check (ctx, s, 0, OP_invalid, 0, -1)) goto fail;
-
-  while (s->pc_stack_len > 0) {
-    pos = s->pc_stack[--s->pc_stack_len];
-    stack_len = s->stack_level_tab[pos];
-    catch_pos = s->catch_pos_tab[pos];
-    op = bc_buf[pos];
-    if (op == 0 || op >= OP_COUNT) {
-      JS_ThrowInternalError (ctx, "invalid opcode (op=%d, pc=%d)", op, pos);
-      goto fail;
-    }
-    oi = &short_opcode_info (op);
-#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 64)
-    printf ("%5d: %10s %5d %5d\n", pos, oi->name, stack_len, catch_pos);
-#endif
-    pos_next = pos + oi->size;
-    if (pos_next > s->bc_len) {
-      JS_ThrowInternalError (ctx, "bytecode buffer overflow (op=%d, pc=%d)", op, pos);
-      goto fail;
-    }
-    n_pop = oi->n_pop;
-    /* call pops a variable number of arguments */
-    if (oi->fmt == OP_FMT_npop || oi->fmt == OP_FMT_npop_u16) {
-      n_pop += get_u16 (bc_buf + pos + 1);
-    } else {
-#if SHORT_OPCODES
-      if (oi->fmt == OP_FMT_npopx) { n_pop += op - OP_call0; }
-#endif
-    }
-
-    if (stack_len < n_pop) {
-      JS_ThrowInternalError (ctx, "stack underflow (op=%d, pc=%d)", op, pos);
-      goto fail;
-    }
-    stack_len += oi->n_push - n_pop;
-    if (stack_len > s->stack_len_max) {
-      s->stack_len_max = stack_len;
-      if (s->stack_len_max > JS_STACK_SIZE_MAX) {
-        JS_ThrowInternalError (ctx, "stack overflow (op=%d, pc=%d)", op, pos);
-        goto fail;
-      }
-    }
-    switch (op) {
-    case OP_tail_call:
-    case OP_tail_call_method:
-    case OP_return:
-    case OP_return_undef:
-    case OP_throw:
-    case OP_throw_error:
-    case OP_ret:
-      goto done_insn;
-    case OP_goto:
-      diff = get_u32 (bc_buf + pos + 1);
-      pos_next = pos + 1 + diff;
-      break;
-#if SHORT_OPCODES
-    case OP_goto16:
-      diff = (int16_t)get_u16 (bc_buf + pos + 1);
-      pos_next = pos + 1 + diff;
-      break;
-    case OP_goto8:
-      diff = (int8_t)bc_buf[pos + 1];
-      pos_next = pos + 1 + diff;
-      break;
-    case OP_if_true8:
-    case OP_if_false8:
-      diff = (int8_t)bc_buf[pos + 1];
-      if (ss_check (ctx, s, pos + 1 + diff, op, stack_len, catch_pos))
-        goto fail;
-      break;
-#endif
-    case OP_if_true:
-    case OP_if_false:
-      diff = get_u32 (bc_buf + pos + 1);
-      if (ss_check (ctx, s, pos + 1 + diff, op, stack_len, catch_pos))
-        goto fail;
-      break;
-    case OP_gosub:
-      diff = get_u32 (bc_buf + pos + 1);
-      if (ss_check (ctx, s, pos + 1 + diff, op, stack_len + 1, catch_pos))
-        goto fail;
-      break;
-    case OP_catch:
-      diff = get_u32 (bc_buf + pos + 1);
-      if (ss_check (ctx, s, pos + 1 + diff, op, stack_len, catch_pos))
-        goto fail;
-      catch_pos = pos;
-      break;
-      /* we assume the catch offset entry is only removed with
-         some op codes */
-    case OP_drop:
-      catch_level = stack_len;
-      goto check_catch;
-    case OP_nip:
-      catch_level = stack_len - 1;
-      goto check_catch;
-    case OP_nip1:
-      catch_level = stack_len - 1;
-    check_catch:
-      if (catch_pos >= 0) {
-        int level;
-        level = s->stack_level_tab[catch_pos];
-        /* catch_level = stack_level before op_catch is executed ? */
-        if (catch_level == level) { catch_pos = s->catch_pos_tab[catch_pos]; }
-      }
-      break;
-    case OP_nip_catch:
-      if (catch_pos < 0) {
-        JS_ThrowInternalError (ctx, "nip_catch: no catch op (pc=%d)", pos);
-        goto fail;
-      }
-      stack_len = s->stack_level_tab[catch_pos];
-      stack_len++; /* no stack overflow is possible by construction */
-      catch_pos = s->catch_pos_tab[catch_pos];
-      break;
-    default:
-      break;
-    }
-    if (ss_check (ctx, s, pos_next, op, stack_len, catch_pos)) goto fail;
-  done_insn:;
-  }
-  pjs_free (s->pc_stack);
-  pjs_free (s->catch_pos_tab);
-  pjs_free (s->stack_level_tab);
-  *pstack_size = s->stack_len_max;
-  return 0;
-fail:
-  pjs_free (s->pc_stack);
-  pjs_free (s->catch_pos_tab);
-  pjs_free (s->stack_level_tab);
-  *pstack_size = 0;
-  return -1;
-}
-
-/* create a function object from a function definition. The function
-   definition is freed. All the child functions are also created. It
-   must be done this way to resolve all the variables. */
-JSValue js_create_function (JSContext *ctx, JSFunctionDef *fd) {
-  JSValue func_obj;
-  JSFunctionBytecode *b;
-  struct list_head *el, *el1;
-  int stack_size, scope, idx;
-  int function_size, byte_code_offset, cpool_offset;
-  int closure_var_offset, vardefs_offset;
-
-  /* recompute scope linkage */
-  for (scope = 0; scope < fd->scope_count; scope++) {
-    fd->scopes[scope].first = -1;
-  }
-  if (fd->has_parameter_expressions) {
-    /* special end of variable list marker for the argument scope */
-    fd->scopes[ARG_SCOPE_INDEX].first = ARG_SCOPE_END;
-  }
-  for (idx = 0; idx < fd->var_count; idx++) {
-    JSVarDef *vd = &fd->vars[idx];
-    vd->scope_next = fd->scopes[vd->scope_level].first;
-    fd->scopes[vd->scope_level].first = idx;
-  }
-  for (scope = 2; scope < fd->scope_count; scope++) {
-    JSVarScope *sd = &fd->scopes[scope];
-    if (sd->first < 0) sd->first = fd->scopes[sd->parent].first;
-  }
-  for (idx = 0; idx < fd->var_count; idx++) {
-    JSVarDef *vd = &fd->vars[idx];
-    if (vd->scope_next < 0 && vd->scope_level > 1) {
-      scope = fd->scopes[vd->scope_level].parent;
-      vd->scope_next = fd->scopes[scope].first;
-    }
-  }
-
-  /* first create all the child functions */
-  list_for_each_safe (el, el1, &fd->child_list) {
-    JSFunctionDef *fd1;
-    int cpool_idx;
-
-    fd1 = list_entry (el, JSFunctionDef, link);
-    cpool_idx = fd1->parent_cpool_idx;
-    func_obj = js_create_function (ctx, fd1);
-    if (JS_IsException (func_obj)) goto fail;
-    /* save it in the constant pool */
-    assert (cpool_idx >= 0);
-    fd->cpool[cpool_idx] = func_obj;
-  }
-
-#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 4)
-  if (!fd->strip_debug) {
-    printf ("pass 1\n");
-    dump_byte_code (ctx, 1, fd->byte_code.buf, fd->byte_code.size, fd->args, fd->arg_count, fd->vars, fd->var_count, fd->closure_var, fd->closure_var_count, fd->cpool, fd->cpool_count, fd->source, fd->label_slots, NULL);
-    printf ("\n");
-  }
-#endif
-
-  if (resolve_variables (ctx, fd)) goto fail;
-
-#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 2)
-  if (!fd->strip_debug) {
-    printf ("pass 2\n");
-    dump_byte_code (ctx, 2, fd->byte_code.buf, fd->byte_code.size, fd->args, fd->arg_count, fd->vars, fd->var_count, fd->closure_var, fd->closure_var_count, fd->cpool, fd->cpool_count, fd->source, fd->label_slots, NULL);
-    printf ("\n");
-  }
-#endif
-
-  if (resolve_labels (ctx, fd)) goto fail;
-
-  if (compute_stack_size (ctx, fd, &stack_size) < 0) goto fail;
-
-  if (fd->strip_debug) {
-    function_size = offsetof (JSFunctionBytecode, debug);
-  } else {
-    function_size = sizeof (*b);
-  }
-  cpool_offset = function_size;
-  function_size += fd->cpool_count * sizeof (*fd->cpool);
-  vardefs_offset = function_size;
-  if (!fd->strip_debug) {
-    function_size += (fd->arg_count + fd->var_count) * sizeof (*b->vardefs);
-  }
-  closure_var_offset = function_size;
-  function_size += fd->closure_var_count * sizeof (*fd->closure_var);
-  byte_code_offset = function_size;
-  function_size += fd->byte_code.size;
-
-  /* Bytecode is immutable - allocate outside GC heap */
-  b = pjs_mallocz (function_size);
-  if (!b) goto fail;
-  b->header = objhdr_make (0, OBJ_CODE, false, false, false, false);
-
-  b->byte_code_buf = (void *)((uint8_t *)b + byte_code_offset);
-  b->byte_code_len = fd->byte_code.size;
-  memcpy (b->byte_code_buf, fd->byte_code.buf, fd->byte_code.size);
-  js_free (ctx, fd->byte_code.buf);
-  fd->byte_code.buf = NULL;
-
-  b->func_name = fd->func_name;
-  if (fd->arg_count + fd->var_count > 0) {
-    if (fd->strip_debug) {
-      /* Strip variable definitions not needed at runtime */
-      int i;
-      for (i = 0; i < fd->var_count; i++) {
-      }
-      for (i = 0; i < fd->arg_count; i++) {
-      }
-      for (i = 0; i < fd->closure_var_count; i++) {
-        fd->closure_var[i].var_name = JS_NULL;
-      }
-    } else {
-      b->vardefs = (void *)((uint8_t *)b + vardefs_offset);
-      memcpy_no_ub (b->vardefs, fd->args, fd->arg_count * sizeof (fd->args[0]));
-      memcpy_no_ub (b->vardefs + fd->arg_count, fd->vars, fd->var_count * sizeof (fd->vars[0]));
-    }
-    b->var_count = fd->var_count;
-    b->arg_count = fd->arg_count;
-    b->defined_arg_count = fd->defined_arg_count;
-    js_free (ctx, fd->args);
-    js_free (ctx, fd->vars);
-  }
-  b->cpool_count = fd->cpool_count;
-  if (b->cpool_count) {
-    b->cpool = (void *)((uint8_t *)b + cpool_offset);
-    memcpy (b->cpool, fd->cpool, b->cpool_count * sizeof (*b->cpool));
-  }
-  js_free (ctx, fd->cpool);
-  fd->cpool = NULL;
-
-  b->stack_size = stack_size;
-
-  if (fd->strip_debug) {
-    dbuf_free (&fd->pc2line); // probably useless
-  } else {
-    /* XXX: source and pc2line info should be packed at the end of the
-       JSFunctionBytecode structure, avoiding allocation overhead
-     */
-    b->has_debug = 1;
-    b->debug.filename = fd->filename;
-
-    // DynBuf pc2line;
-    // compute_pc2line_info(fd, &pc2line);
-    // js_free(ctx, fd->line_number_slots)
-    /* pc2line.buf is allocated by dbuf (system realloc), so just use it directly */
-    b->debug.pc2line_buf = fd->pc2line.buf;
-    fd->pc2line.buf = NULL; /* Transfer ownership */
-    b->debug.pc2line_len = fd->pc2line.size;
-    b->debug.source = fd->source;
-    b->debug.source_len = fd->source_len;
-  }
-  if (fd->scopes != fd->def_scope_array) pjs_free (fd->scopes);
-
-  b->closure_var_count = fd->closure_var_count;
-  if (b->closure_var_count) {
-    b->closure_var = (void *)((uint8_t *)b + closure_var_offset);
-    memcpy (b->closure_var, fd->closure_var, b->closure_var_count * sizeof (*b->closure_var));
-  }
-  pjs_free (fd->closure_var);
-  fd->closure_var = NULL;
-
-  b->has_prototype = fd->has_prototype;
-  b->has_simple_parameter_list = fd->has_simple_parameter_list;
-  b->js_mode = fd->js_mode;
-
-  /* IC removed - shapes no longer used */
-
-  b->is_direct_or_indirect_eval = FALSE;
-
-#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 1)
-  if (!fd->strip_debug) { js_dump_function_bytecode (ctx, b); }
-#endif
-
-  if (fd->parent) {
-    /* remove from parent list */
-    list_del (&fd->link);
-  }
-
-  js_free (ctx, fd);
-  return JS_MKPTR (b);
-fail:
-  js_free_function_def (ctx, fd);
-  return JS_EXCEPTION;
-}
-
-static __exception int js_parse_directives (JSParseState *s) {
-  char str[20];
-  JSParsePos pos;
-  BOOL has_semi;
-
-  if (s->token.val != TOK_STRING) return 0;
-
-  js_parse_get_pos (s, &pos);
-
-  while (s->token.val == TOK_STRING) {
-    /* Copy actual source string representation */
-    snprintf (str, sizeof str, "%.*s", (int)(s->buf_ptr - s->token.ptr - 2), s->token.ptr + 1);
-
-    if (next_token (s)) return -1;
-
-    has_semi = FALSE;
-    switch (s->token.val) {
-    case ';':
-      if (next_token (s)) return -1;
-      has_semi = TRUE;
-      break;
-    case '}':
-    case TOK_EOF:
-      has_semi = TRUE;
-      break;
-    case TOK_NUMBER:
-    case TOK_STRING:
-    case TOK_TEMPLATE:
-    case TOK_IDENT:
-    case TOK_REGEXP:
-    case TOK_DEC:
-    case TOK_INC:
-    case TOK_NULL:
-    case TOK_FALSE:
-    case TOK_TRUE:
-    case TOK_IF:
-    case TOK_RETURN:
-    case TOK_VAR:
-    case TOK_THIS:
-    case TOK_DELETE:
-    case TOK_DO:
-    case TOK_WHILE:
-    case TOK_FOR:
-    case TOK_DISRUPT:
-    case TOK_FUNCTION:
-    case TOK_DEBUGGER:
-    case TOK_DEF:
-    case TOK_ENUM:
-    case TOK_EXPORT:
-    case TOK_IMPORT:
-    case TOK_INTERFACE:
-      /* automatic insertion of ';' */
-      if (s->got_lf) has_semi = TRUE;
-      break;
-    default:
-      break;
-    }
-    if (!has_semi) break;
-  }
-  return js_parse_seek_token (s, &pos);
-}
-
-/* return TRUE if the keyword is forbidden only in strict mode */
-static BOOL is_strict_future_keyword (JSValue name) {
-  BOOL is_strict_reserved = FALSE;
-  int token = js_keyword_lookup (name, &is_strict_reserved);
-  return (token >= 0 && is_strict_reserved);
-}
-
-static int js_parse_function_check_names (JSParseState *s, JSFunctionDef *fd, JSValue func_name) {
-  JSValue name;
-  int i, idx;
-
-  if (!fd->has_simple_parameter_list && fd->has_use_strict) {
-    return js_parse_error (s, "\"use strict\" not allowed in function with "
-                              "default or destructuring parameter");
-  }
-  if (js_key_equal (func_name, JS_KEY_eval)
-      || is_strict_future_keyword (func_name)) {
-    return js_parse_error (s, "invalid function name in strict code");
-  }
-  for (idx = 0; idx < fd->arg_count; idx++) {
-    name = fd->args[idx].var_name;
-
-    if (js_key_equal (name, JS_KEY_eval) || is_strict_future_keyword (name)) {
-      return js_parse_error (s, "invalid argument name in strict code");
-    }
-  }
-
-  for (idx = 0; idx < fd->arg_count; idx++) {
-    name = fd->args[idx].var_name;
-    if (!JS_IsNull (name)) {
-      for (i = 0; i < idx; i++) {
-        if (js_key_equal (fd->args[i].var_name, name)) goto duplicate;
-      }
-      /* Check if argument name duplicates a destructuring parameter */
-      /* XXX: should have a flag for such variables */
-      for (i = 0; i < fd->var_count; i++) {
-        if (js_key_equal (fd->vars[i].var_name, name)
-            && fd->vars[i].scope_level == 0)
-          goto duplicate;
-      }
-    }
-  }
-  return 0;
-
-duplicate:
-  return js_parse_error (
-    s, "duplicate argument names not allowed in this context");
-}
-
-/* func_name must be JS_NULL for JS_PARSE_FUNC_STATEMENT and
-   JS_PARSE_FUNC_EXPR, JS_PARSE_FUNC_ARROW and JS_PARSE_FUNC_VAR */
-static __exception int js_parse_function_decl2 (JSParseState *s,
-                                                JSParseFunctionEnum func_type,
-                                                JSValue func_name,
-                                                const uint8_t *ptr,
-                                                JSFunctionDef **pfd) {
-  JSContext *ctx = s->ctx;
-  JSFunctionDef *fd = s->cur_func;
-  BOOL is_expr;
-  int func_idx, lexical_func_idx = -1;
-  BOOL create_func_var = FALSE;
-
-  is_expr
-    = (func_type != JS_PARSE_FUNC_STATEMENT && func_type != JS_PARSE_FUNC_VAR);
-
-  if (func_type == JS_PARSE_FUNC_STATEMENT || func_type == JS_PARSE_FUNC_VAR
-      || func_type == JS_PARSE_FUNC_EXPR) {
-    if (next_token (s)) return -1;
-
-    if (s->token.val == TOK_IDENT) {
-      if (s->token.u.ident.is_reserved)
-        return js_parse_error_reserved_identifier (s);
-      func_name = s->token.u.ident.str;
-      if (next_token (s)) {
-        return -1;
-      }
-    } else {
-      if (func_type != JS_PARSE_FUNC_EXPR)
-        return js_parse_error (s, "function name expected");
-    }
-
-  } else if (func_type != JS_PARSE_FUNC_ARROW) {
-    /* func_name is already set, nothing to do */
-  }
-
-  if (func_type == JS_PARSE_FUNC_VAR) {
-    /* Create the lexical name here so that the function closure
-       contains it */
-    /* Always create a lexical name, fail if at the same scope as
-       existing name */
-    /* Lexical variable will be initialized upon entering scope */
-    lexical_func_idx
-      = define_var (s, fd, func_name, JS_VAR_DEF_FUNCTION_DECL);
-    if (lexical_func_idx < 0) {
-      return -1;
-    }
-  }
-
-  fd = js_new_function_def (ctx, fd, is_expr, s->filename, ptr, &s->get_line_col_cache);
-  if (!fd) {
-    return -1;
-  }
-  if (pfd) *pfd = fd;
-  s->cur_func = fd;
-  fd->func_name = func_name;
-  /* XXX: test !fd->is_generator is always false */
-  fd->has_prototype
-    = (func_type == JS_PARSE_FUNC_STATEMENT || func_type == JS_PARSE_FUNC_VAR
-       || func_type == JS_PARSE_FUNC_EXPR);
-
-  fd->has_this_binding = (func_type != JS_PARSE_FUNC_ARROW
-                          && func_type != JS_PARSE_FUNC_CLASS_STATIC_INIT);
-
-  /* fd->in_function_body == FALSE prevents yield/await during the parsing
-     of the arguments in generator/async functions. They are parsed as
-     regular identifiers for other function kinds. */
-  fd->func_type = func_type;
-
-  /* parse arguments */
-  fd->has_simple_parameter_list = TRUE;
-  fd->has_parameter_expressions = FALSE;
-  if (func_type == JS_PARSE_FUNC_ARROW && s->token.val == TOK_IDENT) {
-    JSValue name;
-    if (s->token.u.ident.is_reserved) {
-      js_parse_error_reserved_identifier (s);
-      goto fail;
-    }
-    name = s->token.u.ident.str;
-    if (add_arg (ctx, fd, name) < 0) goto fail;
-  } else if (func_type != JS_PARSE_FUNC_CLASS_STATIC_INIT) {
-    if (s->token.val == '(') {
-      int skip_bits;
-      /* if there is an '=' inside the parameter list, we
-         consider there is a parameter expression inside */
-      js_parse_skip_parens_token (s, &skip_bits, FALSE);
-      if (skip_bits & SKIP_HAS_ASSIGNMENT)
-        fd->has_parameter_expressions = TRUE;
-      if (next_token (s)) goto fail;
-    } else {
-      if (js_parse_expect (s, '(')) goto fail;
-    }
-
-    if (fd->has_parameter_expressions) {
-      fd->scope_level = -1; /* force no parent scope */
-      if (push_scope (s) < 0) return -1;
-    }
-
-    while (s->token.val != ')') {
-      JSValue name;
-      int idx, has_initializer;
-
-      if (s->token.val == '[' || s->token.val == '{') {
-        fd->has_simple_parameter_list = FALSE;
-        /* unnamed arg for destructuring */
-        idx = add_arg (ctx, fd, JS_NULL);
-        emit_op (s, OP_get_arg);
-        emit_u16 (s, idx);
-        has_initializer
-          = js_parse_destructuring_element (s, TOK_VAR, 1, TRUE, TRUE, FALSE);
-        if (has_initializer < 0) goto fail;
-      } else if (s->token.val == TOK_IDENT) {
-        if (s->token.u.ident.is_reserved) {
-          js_parse_error_reserved_identifier (s);
-          goto fail;
-        }
-        name = s->token.u.ident.str;
-        if (fd->has_parameter_expressions) {
-          if (js_parse_check_duplicate_parameter (s, name)) goto fail;
-          if (define_var (s, fd, name, JS_VAR_DEF_LET) < 0) goto fail;
-        }
-        idx = add_arg (ctx, fd, name);
-        if (idx < 0) goto fail;
-        if (next_token (s)) goto fail;
-        if (s->token.val == '=') {
-          int label;
-
-          fd->has_simple_parameter_list = FALSE;
-
-          if (next_token (s)) goto fail;
-
-          label = new_label (s);
-          emit_op (s, OP_get_arg);
-          emit_u16 (s, idx);
-          emit_op (s, OP_dup);
-          emit_op (s, OP_null);
-          emit_op (s, OP_strict_eq);
-          emit_goto (s, OP_if_false, label);
-          emit_op (s, OP_drop);
-          if (js_parse_assign_expr (s)) goto fail;
-          set_object_name (s, name);
-          emit_op (s, OP_dup);
-          emit_op (s, OP_put_arg);
-          emit_u16 (s, idx);
-          emit_label (s, label);
-          emit_op (s, OP_scope_put_var_init);
-          emit_key (s, name);
-          emit_u16 (s, fd->scope_level);
-        } else {
-          if (fd->has_parameter_expressions) {
-            /* copy the argument to the argument scope */
-            emit_op (s, OP_get_arg);
-            emit_u16 (s, idx);
-            emit_op (s, OP_scope_put_var_init);
-            emit_key (s, name);
-            emit_u16 (s, fd->scope_level);
-          }
-        }
-      } else {
-        js_parse_error (s, "missing formal parameter");
-        goto fail;
-      }
-      if (s->token.val == ')') break;
-      if (js_parse_expect (s, ',')) goto fail;
-    }
-    if ((func_type == JS_PARSE_FUNC_GETTER && fd->arg_count != 0)
-        || (func_type == JS_PARSE_FUNC_SETTER && fd->arg_count != 1)) {
-      js_parse_error (s, "invalid number of arguments for getter or setter");
-      goto fail;
-    }
-    if (fd->arg_count > 4) {
-      js_parse_error (s, "functions cannot have more than 4 parameters");
-      goto fail;
-    }
-  }
-  /* Explicit arity: defined_arg_count == arg_count always */
-  fd->defined_arg_count = fd->arg_count;
-
-  if (fd->has_parameter_expressions) {
-    int idx;
-
-    /* Copy the variables in the argument scope to the variable
-       scope (see FunctionDeclarationInstantiation() in spec). The
-       normal arguments are already present, so no need to copy
-       them. */
-    idx = fd->scopes[fd->scope_level].first;
-    while (idx >= 0) {
-      JSVarDef *vd = &fd->vars[idx];
-      if (vd->scope_level != fd->scope_level) break;
-      if (find_var (ctx, fd, vd->var_name) < 0) {
-        if (add_var (ctx, fd, vd->var_name) < 0) goto fail;
-        vd = &fd->vars[idx]; /* fd->vars may have been reallocated */
-        emit_op (s, OP_scope_get_var);
-        emit_key (s, vd->var_name);
-        emit_u16 (s, fd->scope_level);
-        emit_op (s, OP_scope_put_var);
-        emit_key (s, vd->var_name);
-        emit_u16 (s, 0);
-      }
-      idx = vd->scope_next;
-    }
-
-    /* the argument scope has no parent, hence we don't use pop_scope(s) */
-    emit_op (s, OP_leave_scope);
-    emit_u16 (s, fd->scope_level);
-
-    /* set the variable scope as the current scope */
-    fd->scope_level = 0;
-    fd->scope_first = fd->scopes[fd->scope_level].first;
-  }
-
-  if (next_token (s)) goto fail;
-
-  /* in generators, yield expression is forbidden during the parsing
-     of the arguments */
-  fd->in_function_body = TRUE;
-  push_scope (s); /* enter body scope */
-  fd->body_scope = fd->scope_level;
-
-  if (s->token.val == TOK_ARROW && func_type == JS_PARSE_FUNC_ARROW) {
-    if (next_token (s)) goto fail;
-
-    if (s->token.val != '{') {
-      if (js_parse_function_check_names (s, fd, func_name)) goto fail;
-
-      if (js_parse_assign_expr (s)) goto fail;
-
-      emit_op (s, OP_return);
-
-      if (!fd->strip_source) {
-        /* save the function source code */
-        /* the end of the function source code is after the last
-           token of the function source stored into s->last_ptr */
-        fd->source_len = s->last_ptr - ptr;
-        fd->source = strndup ((const char *)ptr, fd->source_len);
-        if (!fd->source) goto fail;
-      }
-      goto done;
-    }
-  }
-
-  if (js_parse_expect (s, '{')) goto fail;
-
-  if (js_parse_directives (s)) goto fail;
-
-  /* in strict_mode, check function and argument names */
-  if (js_parse_function_check_names (s, fd, func_name)) goto fail;
-
-  while (s->token.val != '}') {
-    if (js_parse_source_element (s)) goto fail;
-  }
-  if (!fd->strip_source) {
-    /* save the function source code */
-    fd->source_len = s->buf_ptr - ptr;
-    fd->source = strndup ((const char *)ptr, fd->source_len);
-    if (!fd->source) goto fail;
-  }
-
-  if (next_token (s)) {
-    /* consume the '}' */
-    goto fail;
-  }
-
-  /* in case there is no return, add one */
-  if (js_is_live_code (s)) { emit_return (s, FALSE); }
-done:
-  s->cur_func = fd->parent;
-
-  /* Reparse identifiers after the function is terminated so that
-     the token is parsed in the englobing function. It could be done
-     by just using next_token() here for normal functions, but it is
-     necessary for arrow functions with an expression body. */
-  reparse_ident_token (s);
-
-  /* create the function object */
-  {
-    int idx;
-    JSValue func_name_val = fd->func_name;
-
-    /* the real object will be set at the end of the compilation */
-    idx = cpool_add (s, JS_NULL);
-    fd->parent_cpool_idx = idx;
-
-    if (is_expr) {
-      /* OP_fclosure creates the function object from the bytecode
-        and adds the scope information */
-      emit_op (s, OP_fclosure);
-      emit_u32 (s, idx);
-      if (JS_IsNull (func_name_val)) {
-        emit_op (s, OP_set_name);
-        emit_key (s, JS_NULL);
-      }
-    } else if (func_type == JS_PARSE_FUNC_VAR) {
-      emit_op (s, OP_fclosure);
-      emit_u32 (s, idx);
-      if (create_func_var) {
-        if (s->cur_func->is_global_var) {
-          JSGlobalVar *hf;
-          /* the global variable must be defined at the start of the
-             function */
-          hf = add_global_var (ctx, s->cur_func, func_name_val);
-          if (!hf) goto fail;
-          /* it is considered as defined at the top level
-             (needed for annex B.3.3.4 and B.3.3.5
-             checks) */
-          hf->scope_level = 0;
-          hf->force_init = 1;
-          /* store directly into global var, bypass lexical scope */
-          emit_op (s, OP_dup);
-          emit_op (s, OP_scope_put_var);
-          emit_key (s, func_name_val);
-          emit_u16 (s, 0);
-        } else {
-          /* do not call define_var to bypass lexical scope check */
-          func_idx = find_var (ctx, s->cur_func, func_name_val);
-          if (func_idx < 0) {
-            func_idx = add_var (ctx, s->cur_func, func_name_val);
-            if (func_idx < 0) goto fail;
-          }
-          /* store directly into local var, bypass lexical catch scope */
-          emit_op (s, OP_dup);
-          emit_op (s, OP_scope_put_var);
-          emit_key (s, func_name_val);
-          emit_u16 (s, 0);
-        }
-      }
-      if (lexical_func_idx >= 0) {
-        /* lexical variable will be initialized upon entering scope */
-        s->cur_func->vars[lexical_func_idx].func_pool_idx = idx;
-        emit_op (s, OP_drop);
-      } else {
-        /* store function object into its lexical name */
-        /* XXX: could use OP_put_loc directly */
-        emit_op (s, OP_scope_put_var_init);
-        emit_key (s, func_name_val);
-        emit_u16 (s, s->cur_func->scope_level);
-      }
-    } else {
-      if (!s->cur_func->is_global_var) {
-        int var_idx
-          = define_var (s, s->cur_func, func_name_val, JS_VAR_DEF_VAR);
-
-        if (var_idx < 0) goto fail;
-        /* the variable will be assigned at the top of the function */
-        if (var_idx & ARGUMENT_VAR_OFFSET) {
-          s->cur_func->args[var_idx - ARGUMENT_VAR_OFFSET].func_pool_idx = idx;
-        } else {
-          s->cur_func->vars[var_idx].func_pool_idx = idx;
-        }
-      } else {
-        JSValue func_var_name;
-        JSGlobalVar *hf;
-        if (JS_IsNull (func_name_val))
-          func_var_name = JS_KEY_STR (ctx, "default"); /* export default */
-        else
-          func_var_name = func_name_val;
-        /* the variable will be assigned at the top of the function */
-        hf = add_global_var (ctx, s->cur_func, func_var_name);
-        if (!hf) goto fail;
-        hf->cpool_idx = idx;
-      }
-    }
-  }
-  return 0;
-fail:
-  s->cur_func = fd->parent;
-  js_free_function_def (ctx, fd);
-  if (pfd) *pfd = NULL;
-  return -1;
-}
-
-static __exception int js_parse_function_decl (JSParseState *s,
-                                               JSParseFunctionEnum func_type,
-                                               JSValue func_name,
-                                               const uint8_t *ptr) {
-  return js_parse_function_decl2 (s, func_type, func_name, ptr, NULL);
-}
-
-static __exception int js_parse_program (JSParseState *s) {
-  JSFunctionDef *fd = s->cur_func;
-  if (next_token (s)) return -1;
-
-  if (js_parse_directives (s)) return -1;
-
-  /* Global object is immutable - all variables are locals of the eval function */
-  fd->is_global_var = FALSE;
-
-  while (s->token.val != TOK_EOF) {
-    if (js_parse_source_element (s)) return -1;
-  }
-
-  /* For eval-like semantics: if the last statement was an expression,
-     return its value instead of null. Expression statements emit OP_drop
-     to discard the value - remove that and emit OP_return instead. */
-  if (get_prev_opcode (fd) == OP_drop) {
-    fd->byte_code.size = fd->last_opcode_pos;
-    fd->last_opcode_pos = -1;
-    emit_return (s, TRUE);
-  } else {
-    emit_return (s, FALSE);
-  }
-
-  return 0;
-}
-
-static void js_parse_init (JSContext *ctx, JSParseState *s, const char *input, size_t input_len, const char *filename) {
-  memset (s, 0, sizeof (*s));
-  s->ctx = ctx;
-  s->filename = filename;
-  s->buf_start = s->buf_ptr = (const uint8_t *)input;
-  s->buf_end = s->buf_ptr + input_len;
-  s->token.val = ' ';
-  s->token.ptr = s->buf_ptr;
-
-  s->get_line_col_cache.ptr = s->buf_start;
-  s->get_line_col_cache.buf_start = s->buf_start;
-  s->get_line_col_cache.line_num = 0;
-  s->get_line_col_cache.col_num = 0;
-}
-
-/* Forward declaration */
-JSValue __JS_CompileInternal (JSContext *ctx, const char *input, size_t input_len, const char *filename);
-
-/* Compile source code to bytecode without executing.
-   Returns unlinked bytecode on success, JS_EXCEPTION on error.
-   'input' must be zero terminated i.e. input[input_len] = '\0'. */
-JSValue JS_Compile (JSContext *ctx, const char *input, size_t input_len,
-                    const char *filename) {
-  return __JS_CompileInternal (ctx, input, input_len, filename);
-}
-
-/* Link compiled bytecode with environment and execute.
-   The env should be a stoned record (or null for no env).
-   Variables resolve: env first, then global intrinsics. */
-JSValue JS_Integrate (JSContext *ctx, JSValue fun_obj, JSValue env) {
-  JSValue ret_val;
-  uint32_t tag;
-  JSGCRef env_ref, fun_ref;
-  JSFunctionBytecode *tpl, *linked_bc;
-
-  tag = JS_VALUE_GET_TAG (fun_obj);
-  /* JSFunctionBytecode uses OBJ_CODE type with JS_TAG_PTR */
-  if (tag != JS_TAG_PTR || objhdr_type (*(objhdr_t *)JS_VALUE_GET_PTR (fun_obj)) != OBJ_CODE) {
-    return JS_ThrowTypeError (ctx, "bytecode function expected");
-  }
-
-  /* Protect env and fun_obj from GC during linking */
-  JS_AddGCRef (ctx, &env_ref);
-  env_ref.val = env;
-  JS_AddGCRef (ctx, &fun_ref);
-  fun_ref.val = fun_obj;
-
-  /* Link bytecode with environment */
-  tpl = (JSFunctionBytecode *)JS_VALUE_GET_PTR (fun_ref.val);
-  linked_bc = js_link_bytecode (ctx, tpl, env_ref.val);
-  if (!linked_bc) {
-    JS_DeleteGCRef (ctx, &fun_ref);
-    JS_DeleteGCRef (ctx, &env_ref);
-    return JS_EXCEPTION;
-  }
-  JSValue linked = JS_MKPTR (linked_bc);
-
-  /* Update env from GC ref (may have moved) */
-  env = env_ref.val;
-  JS_DeleteGCRef (ctx, &fun_ref);
-  JS_DeleteGCRef (ctx, &env_ref);
-
-  /* Create closure and set env_record on the function object */
-  linked = js_closure (ctx, linked, NULL);
-  if (JS_IsException (linked)) {
-    return JS_EXCEPTION;
-  }
-
-  /* Store env_record on the function for OP_get_env_slot access */
-  JSFunction *f = JS_VALUE_GET_FUNCTION (linked);
-  f->u.func.env_record = env;
-
-  ret_val = JS_Call (ctx, linked, ctx->global_obj, 0, NULL);
-
-  return ret_val;
-}
-
-/* Compile source to bytecode.
-   'input' must be zero terminated i.e. input[input_len] = '\0'. */
-JSValue __JS_CompileInternal (JSContext *ctx, const char *input, size_t input_len, const char *filename) {
-  JSParseState s1, *s = &s1;
-  int err;
-  JSValue fun_obj;
-  JSFunctionDef *fd;
-
-  js_parse_init (ctx, s, input, input_len, filename);
-
-  fd = js_new_function_def (ctx, NULL, FALSE, filename, s->buf_start, &s->get_line_col_cache);
-  if (!fd) goto fail1;
-  s->cur_func = fd;
-  ctx->current_parse_fd = fd;  /* Set GC root for parser's cpool */
-  fd->has_this_binding = TRUE;
-  fd->js_mode = 0;
-  fd->func_name = JS_KEY__eval_;
-
-  push_scope (s); /* body scope */
-  fd->body_scope = fd->scope_level;
-
-  err = js_parse_program (s);
-  if (err) {
-    free_token (s, &s->token);
-    ctx->current_parse_fd = NULL;  /* Clear GC root before freeing */
-    js_free_function_def (ctx, fd);
-    goto fail1;
-  }
-
-  /* create the function object and all the enclosed functions */
-  ctx->current_parse_fd = NULL;  /* Clear GC root - fd ownership transfers to js_create_function */
-  fun_obj = js_create_function (ctx, fd);
-  if (JS_IsException (fun_obj)) goto fail1;
-  return fun_obj;
-fail1:
-  return JS_EXCEPTION;
-}
-
-/*******************************************************************/
-/* object list */
-
-typedef struct {
-  JSRecord *obj;
-  uint32_t hash_next; /* -1 if no next entry */
-} JSRecordListEntry;
-
-/* XXX: reuse it to optimize weak references */
-typedef struct {
-  JSRecordListEntry *object_tab;
-  int object_count;
-  int object_size;
-  uint32_t *hash_table;
-  uint32_t hash_size;
-} JSRecordList;
-
-static void js_object_list_init (JSRecordList *s) {
-  memset (s, 0, sizeof (*s));
-}
-
-static uint32_t js_object_list_get_hash (JSRecord *p, uint32_t hash_size) {
-  return ((uintptr_t)p * 3163) & (hash_size - 1);
-}
-
-static int js_object_list_resize_hash (JSContext *ctx, JSRecordList *s, uint32_t new_hash_size) {
-  JSRecordListEntry *e;
-  uint32_t i, h, *new_hash_table;
-
-  new_hash_table = js_malloc (ctx, sizeof (new_hash_table[0]) * new_hash_size);
-  if (!new_hash_table) return -1;
-  js_free (ctx, s->hash_table);
-  s->hash_table = new_hash_table;
-  s->hash_size = new_hash_size;
-
-  for (i = 0; i < s->hash_size; i++) {
-    s->hash_table[i] = -1;
-  }
-  for (i = 0; i < s->object_count; i++) {
-    e = &s->object_tab[i];
-    h = js_object_list_get_hash (e->obj, s->hash_size);
-    e->hash_next = s->hash_table[h];
-    s->hash_table[h] = i;
-  }
-  return 0;
-}
-
-/* the reference count of 'obj' is not modified. Return 0 if OK, -1 if
-   memory error */
-static int js_object_list_add (JSContext *ctx, JSRecordList *s, JSRecord *obj) {
-  JSRecordListEntry *e;
-  uint32_t h, new_hash_size;
-
-  if (js_resize_array (ctx, (void *)&s->object_tab, sizeof (s->object_tab[0]), &s->object_size, s->object_count + 1))
-    return -1;
-  if (unlikely ((s->object_count + 1) >= s->hash_size)) {
-    new_hash_size = max_uint32 (s->hash_size, 4);
-    while (new_hash_size <= s->object_count)
-      new_hash_size *= 2;
-    if (js_object_list_resize_hash (ctx, s, new_hash_size)) return -1;
-  }
-  e = &s->object_tab[s->object_count++];
-  h = js_object_list_get_hash (obj, s->hash_size);
-  e->obj = obj;
-  e->hash_next = s->hash_table[h];
-  s->hash_table[h] = s->object_count - 1;
-  return 0;
-}
-
-/* return -1 if not present or the object index */
-static int js_object_list_find (JSContext *ctx, JSRecordList *s, JSRecord *obj) {
-  JSRecordListEntry *e;
-  uint32_t h, p;
-
-  /* must test empty size because there is no hash table */
-  if (s->object_count == 0) return -1;
-  h = js_object_list_get_hash (obj, s->hash_size);
-  p = s->hash_table[h];
-  while (p != -1) {
-    e = &s->object_tab[p];
-    if (e->obj == obj) return p;
-    p = e->hash_next;
-  }
-  return -1;
-}
-
-static void js_object_list_end (JSContext *ctx, JSRecordList *s) {
-  js_free (ctx, s->object_tab);
-  js_free (ctx, s->hash_table);
-}
-
-/*******************************************************************/
-/* binary object writer & reader */
-
-typedef enum BCTagEnum {
-  BC_TAG_NULL = 1,
-  BC_TAG_BOOL_FALSE,
-  BC_TAG_BOOL_TRUE,
-  BC_TAG_INT32,
-  BC_TAG_FLOAT64,
-  BC_TAG_STRING,
-  BC_TAG_OBJECT,
-  BC_TAG_ARRAY,
-  BC_TAG_TEMPLATE_OBJECT,
-  BC_TAG_FUNCTION_BYTECODE,
-  BC_TAG_MODULE,
-  BC_TAG_OBJECT_VALUE,
-  BC_TAG_OBJECT_REFERENCE,
-} BCTagEnum;
-
-#define BC_VERSION 6
-
-typedef struct BCWriterState {
-  JSContext *ctx;
-  DynBuf dbuf;
-  BOOL allow_bytecode : 8;
-  BOOL allow_sab : 8;
-  BOOL allow_reference : 8;
-  uint8_t **sab_tab;
-  int sab_tab_len;
-  int sab_tab_size;
-  /* list of referenced objects (used if allow_reference = TRUE) */
-  JSRecordList object_list;
-} BCWriterState;
-
-#ifdef DUMP_READ_OBJECT
-static const char *const bc_tag_str[] = {
-  "invalid",
-  "null",
-  "false",
-  "true",
-  "int32",
-  "float64",
-  "string",
-  "object",
-  "array",
-  "template",
-  "function",
-  "module",
-  "ObjectReference",
-};
-#endif
-
-static inline BOOL is_be (void) {
-  union {
-    uint16_t a;
-    uint8_t b;
-  } u = { 0x100 };
-  return u.b;
-}
-
-static void bc_put_u8 (BCWriterState *s, uint8_t v) {
-  dbuf_putc (&s->dbuf, v);
-}
-
-static void bc_put_u16 (BCWriterState *s, uint16_t v) {
-  if (is_be ()) v = bswap16 (v);
-  dbuf_put_u16 (&s->dbuf, v);
-}
-
-static __maybe_unused void bc_put_u32 (BCWriterState *s, uint32_t v) {
-  if (is_be ()) v = bswap32 (v);
-  dbuf_put_u32 (&s->dbuf, v);
-}
-
-static void bc_put_u64 (BCWriterState *s, uint64_t v) {
-  if (is_be ()) v = bswap64 (v);
-  dbuf_put (&s->dbuf, (uint8_t *)&v, sizeof (v));
-}
-
-static void bc_put_leb128 (BCWriterState *s, uint32_t v) {
-  dbuf_put_leb128 (&s->dbuf, v);
-}
-
-static void bc_put_sleb128 (BCWriterState *s, int32_t v) {
-  dbuf_put_sleb128 (&s->dbuf, v);
-}
-
-static void bc_set_flags (uint32_t *pflags, int *pidx, uint32_t val, int n) {
-  *pflags = *pflags | (val << *pidx);
-  *pidx += n;
-}
-
-/* Write a JSValue key (text) to bytecode stream */
-static int bc_put_key (BCWriterState *s, JSValue key) {
-  /* Handle immediate ASCII strings */
-  if (MIST_IsImmediateASCII (key)) {
-    int len = MIST_GetImmediateASCIILen (key);
-    bc_put_leb128 (s, (uint32_t)len);
-    for (int i = 0; i < len; i++) {
-      bc_put_u8 (s, (uint8_t)MIST_GetImmediateASCIIChar (key, i));
-    }
-    return 0;
-  }
-
-  /* Handle heap strings */
-  if (!JS_IsText (key)) {
-    /* Not a string - write empty */
-    bc_put_leb128 (s, 0);
-    return 0;
-  }
-
-  JSText *p = JS_VALUE_GET_STRING (key);
-  /* Write as UTF-8 */
-  uint32_t len = (uint32_t)JSText_len (p);
-  /* Calculate UTF-8 size */
-  size_t utf8_size = 0;
-  for (uint32_t i = 0; i < len; i++) {
-    uint32_t c = string_get (p, i);
-    if (c < 0x80)
-      utf8_size += 1;
-    else if (c < 0x800)
-      utf8_size += 2;
-    else if (c < 0x10000)
-      utf8_size += 3;
-    else
-      utf8_size += 4;
-  }
-  bc_put_leb128 (s, (uint32_t)utf8_size);
-  for (uint32_t i = 0; i < len; i++) {
-    uint32_t c = string_get (p, i);
-    if (c < 0x80) {
-      bc_put_u8 (s, c);
-    } else if (c < 0x800) {
-      bc_put_u8 (s, 0xC0 | (c >> 6));
-      bc_put_u8 (s, 0x80 | (c & 0x3F));
-    } else if (c < 0x10000) {
-      bc_put_u8 (s, 0xE0 | (c >> 12));
-      bc_put_u8 (s, 0x80 | ((c >> 6) & 0x3F));
-      bc_put_u8 (s, 0x80 | (c & 0x3F));
-    } else {
-      bc_put_u8 (s, 0xF0 | (c >> 18));
-      bc_put_u8 (s, 0x80 | ((c >> 12) & 0x3F));
-      bc_put_u8 (s, 0x80 | ((c >> 6) & 0x3F));
-      bc_put_u8 (s, 0x80 | (c & 0x3F));
-    }
-  }
-  return 0;
-}
-
-static void bc_byte_swap (uint8_t *bc_buf, int bc_len) {
-  int pos, len, op, fmt;
-
-  pos = 0;
-  while (pos < bc_len) {
-    op = bc_buf[pos];
-    len = short_opcode_info (op).size;
-    fmt = short_opcode_info (op).fmt;
-    switch (fmt) {
-    case OP_FMT_u16:
-    case OP_FMT_i16:
-    case OP_FMT_label16:
-    case OP_FMT_npop:
-    case OP_FMT_loc:
-    case OP_FMT_arg:
-      put_u16 (bc_buf + pos + 1, bswap16 (get_u16 (bc_buf + pos + 1)));
-      break;
-    case OP_FMT_i32:
-    case OP_FMT_u32:
-    case OP_FMT_const:
-    case OP_FMT_label:
-    case OP_FMT_key:
-    case OP_FMT_key_u8:
-      put_u32 (bc_buf + pos + 1, bswap32 (get_u32 (bc_buf + pos + 1)));
-      break;
-    case OP_FMT_key_u16:
-    case OP_FMT_label_u16:
-      put_u32 (bc_buf + pos + 1, bswap32 (get_u32 (bc_buf + pos + 1)));
-      put_u16 (bc_buf + pos + 1 + 4, bswap16 (get_u16 (bc_buf + pos + 1 + 4)));
-      break;
-    case OP_FMT_key_label_u16:
-      put_u32 (bc_buf + pos + 1, bswap32 (get_u32 (bc_buf + pos + 1)));
-      put_u32 (bc_buf + pos + 1 + 4, bswap32 (get_u32 (bc_buf + pos + 1 + 4)));
-      put_u16 (bc_buf + pos + 1 + 4 + 4,
-               bswap16 (get_u16 (bc_buf + pos + 1 + 4 + 4)));
-      break;
-    case OP_FMT_npop_u16:
-      put_u16 (bc_buf + pos + 1, bswap16 (get_u16 (bc_buf + pos + 1)));
-      put_u16 (bc_buf + pos + 1 + 2, bswap16 (get_u16 (bc_buf + pos + 1 + 2)));
-      break;
-    default:
-      break;
-    }
-    pos += len;
-  }
-}
-
-static int JS_WriteFunctionBytecode (BCWriterState *s, const uint8_t *bc_buf1, int bc_len) {
-  int pos, len, op;
-  uint8_t *bc_buf;
-
-  bc_buf = js_malloc (s->ctx, bc_len);
-  if (!bc_buf) return -1;
-  memcpy (bc_buf, bc_buf1, bc_len);
-
-  pos = 0;
-  while (pos < bc_len) {
-    op = bc_buf[pos];
-    len = short_opcode_info (op).size;
-    switch (short_opcode_info (op).fmt) {
-    case OP_FMT_key:
-    case OP_FMT_key_u8:
-    case OP_FMT_key_u16:
-    case OP_FMT_key_label_u16:
-      /* Key operand is a cpool index; cpool values serialized separately */
-      break;
-    default:
-      break;
-    }
-    pos += len;
-  }
-
-  if (is_be ()) bc_byte_swap (bc_buf, bc_len);
-
-  dbuf_put (&s->dbuf, bc_buf, bc_len);
-
-  js_free (s->ctx, bc_buf);
-  return 0;
-}
-
-static void JS_WriteString (BCWriterState *s, JSText *p) {
-  int i;
-  int len = (int)JSText_len (p);
-  /* UTF-32: write length, then each character as 32-bit value */
-  bc_put_leb128 (s, (uint32_t)len);
-  for (i = 0; i < len; i++) {
-    uint32_t c = string_get (p, i);
-    bc_put_u32 (s, c);
-  }
-}
-
-static int JS_WriteObjectRec (BCWriterState *s, JSValue obj);
-
-static int JS_WriteObjectTag (BCWriterState *s, JSValue obj) {
-  JSRecord *rec = (JSRecord *)JS_VALUE_GET_OBJ (obj);
-  uint32_t mask = (uint32_t)objhdr_cap56 (rec->mist_hdr);
-  uint32_t i, prop_count;
-  int pass;
-
-  bc_put_u8 (s, BC_TAG_OBJECT);
-  prop_count = 0;
-
-  /* Two-pass: count then write */
-  for (pass = 0; pass < 2; pass++) {
-    if (pass == 1) bc_put_leb128 (s, prop_count);
-    for (i = 1; i <= mask; i++) {
-      JSValue k = rec->slots[i].key;
-      if (!rec_key_is_empty (k) && !rec_key_is_tomb (k) && JS_IsText (k)) {
-        if (pass == 0) {
-          prop_count++;
-        } else {
-          /* Write key as JSValue text directly */
-          bc_put_key (s, k);
-          if (JS_WriteObjectRec (s, rec->slots[i].val)) goto fail;
-        }
-      }
-    }
-  }
-  return 0;
-fail:
-  return -1;
-}
-
-static int JS_WriteObjectRec (BCWriterState *s, JSValue obj) {
-  uint32_t tag;
-
-  if (js_check_stack_overflow (s->ctx, 0)) {
-    JS_ThrowStackOverflow (s->ctx);
-    return -1;
-  }
-
-  tag = JS_VALUE_GET_NORM_TAG (obj);
-  switch (tag) {
-  case JS_TAG_NULL:
-    bc_put_u8 (s, BC_TAG_NULL);
-    break;
-  case JS_TAG_BOOL:
-    bc_put_u8 (s, BC_TAG_BOOL_FALSE + JS_VALUE_GET_INT (obj));
-    break;
-  case JS_TAG_INT:
-    bc_put_u8 (s, BC_TAG_INT32);
-    bc_put_sleb128 (s, JS_VALUE_GET_INT (obj));
-    break;
-  case JS_TAG_FLOAT64: {
-    JSFloat64Union u;
-    bc_put_u8 (s, BC_TAG_FLOAT64);
-    u.d = JS_VALUE_GET_FLOAT64 (obj);
-    bc_put_u64 (s, u.u64);
-  } break;
-  case JS_TAG_STRING_IMM: {
-    /* Immediate ASCII string */
-    int len = MIST_GetImmediateASCIILen (obj);
-    char buf[8];
-    for (int i = 0; i < len; i++)
-      buf[i] = MIST_GetImmediateASCIIChar (obj, i);
-    JSValue tmp = js_new_string8_len (s->ctx, buf, len);
-    if (JS_IsException (tmp)) goto fail;
-    JSText *p = JS_VALUE_GET_STRING (tmp);
-    bc_put_u8 (s, BC_TAG_STRING);
-    JS_WriteString (s, p);
-  } break;
-  case JS_TAG_PTR:
-    /* Check if this is a heap string */
-    if (JS_IsText (obj)) {
-      JSText *p = JS_VALUE_GET_STRING (obj);
-      bc_put_u8 (s, BC_TAG_STRING);
-      JS_WriteString (s, p);
-      break;
-    }
-    /* Check if this is an intrinsic array */
-    if (JS_IsArray (obj)) {
-      JSArray *arr = JS_VALUE_GET_ARRAY (obj);
-      uint32_t i;
-      bc_put_u8 (s, BC_TAG_ARRAY);
-      bc_put_leb128 (s, arr->len);
-      for (i = 0; i < arr->len; i++) {
-        if (JS_WriteObjectRec (s, arr->values[i])) goto fail;
-      }
-    } else {
-      JSRecord *p = JS_VALUE_GET_OBJ (obj);
-      int ret, idx;
-
-      /* Always use object_list for cycle detection */
-      idx = js_object_list_find (s->ctx, &s->object_list, p);
-      if (idx >= 0) {
-        if (s->allow_reference) {
-          bc_put_u8 (s, BC_TAG_OBJECT_REFERENCE);
-          bc_put_leb128 (s, idx);
-          break;
-        } else {
-          JS_ThrowTypeError (s->ctx, "circular reference");
-          goto fail;
-        }
-      }
-      if (js_object_list_add (s->ctx, &s->object_list, p)) goto fail;
-      switch (REC_GET_CLASS_ID(p)) {
-      case JS_CLASS_OBJECT:
-        ret = JS_WriteObjectTag (s, obj);
-        break;
-      default:
-        JS_ThrowTypeError (s->ctx, "unsupported object class");
-        ret = -1;
-        break;
-      }
-      if (ret) goto fail;
-    }
-    break;
-  default:
-    JS_ThrowInternalError (s->ctx, "unsupported tag (%d)", tag);
-    goto fail;
-  }
-  return 0;
-
-fail:
-  return -1;
-}
-
-/* create the atom table */
-static int JS_WriteObjectAtoms (BCWriterState *s) {
-  DynBuf dbuf1;
-  int atoms_size;
-
-  dbuf1 = s->dbuf;
-  js_dbuf_init (s->ctx, &s->dbuf);
-  bc_put_u8 (s, BC_VERSION);
-
-  /* Atoms removed - write empty atom table */
-  bc_put_leb128 (s, 0);
-  /* XXX: should check for OOM in above phase */
-
-  /* move the atoms at the start */
-  /* XXX: could just append dbuf1 data, but it uses more memory if
-     dbuf1 is larger than dbuf */
-  atoms_size = s->dbuf.size;
-  if (dbuf_realloc (&dbuf1, dbuf1.size + atoms_size)) goto fail;
-  memmove (dbuf1.buf + atoms_size, dbuf1.buf, dbuf1.size);
-  memcpy (dbuf1.buf, s->dbuf.buf, atoms_size);
-  dbuf1.size += atoms_size;
-  dbuf_free (&s->dbuf);
-  s->dbuf = dbuf1;
-  return 0;
-fail:
-  dbuf_free (&dbuf1);
-  return -1;
-}
-
-uint8_t *JS_WriteObject2 (JSContext *ctx, size_t *psize, JSValue obj, int flags, uint8_t ***psab_tab, size_t *psab_tab_len) {
-  BCWriterState ss, *s = &ss;
-
-  memset (s, 0, sizeof (*s));
-  s->ctx = ctx;
-  s->allow_bytecode = ((flags & JS_WRITE_OBJ_BYTECODE) != 0);
-  s->allow_sab = ((flags & JS_WRITE_OBJ_SAB) != 0);
-  s->allow_reference = ((flags & JS_WRITE_OBJ_REFERENCE) != 0);
-  js_dbuf_init (ctx, &s->dbuf);
-  js_object_list_init (&s->object_list);
-
-  if (JS_WriteObjectRec (s, obj)) goto fail;
-  if (JS_WriteObjectAtoms (s)) goto fail;
-  js_object_list_end (ctx, &s->object_list);
-  *psize = s->dbuf.size;
-  if (psab_tab) *psab_tab = s->sab_tab;
-  if (psab_tab_len) *psab_tab_len = s->sab_tab_len;
-  return s->dbuf.buf;
-fail:
-  js_object_list_end (ctx, &s->object_list);
-  dbuf_free (&s->dbuf);
-  *psize = 0;
-  if (psab_tab) *psab_tab = NULL;
-  if (psab_tab_len) *psab_tab_len = 0;
-  return NULL;
-}
-
-uint8_t *JS_WriteObject (JSContext *ctx, size_t *psize, JSValue obj, int flags) {
-  return JS_WriteObject2 (ctx, psize, obj, flags, NULL, NULL);
-}
-
-typedef struct BCReaderState {
-  JSContext *ctx;
-  const uint8_t *buf_start, *ptr, *buf_end;
-  int error_state;
-  BOOL allow_sab : 8;
-  BOOL allow_bytecode : 8;
-  BOOL is_rom_data : 8;
-  BOOL allow_reference : 8;
-  /* object references */
-  JSRecord **objects;
-  int objects_count;
-  int objects_size;
-
-#ifdef DUMP_READ_OBJECT
-  const uint8_t *ptr_last;
-  int level;
-#endif
-} BCReaderState;
-
-#ifdef DUMP_READ_OBJECT
-static void __attribute__ ((format (printf, 2, 3)))
-bc_read_trace (BCReaderState *s, const char *fmt, ...) {
-  va_list ap;
-  int i, n, n0;
-
-  if (!s->ptr_last) s->ptr_last = s->buf_start;
-
-  n = n0 = 0;
-  if (s->ptr > s->ptr_last || s->ptr == s->buf_start) {
-    n0 = printf ("%04x: ", (int)(s->ptr_last - s->buf_start));
-    n += n0;
-  }
-  for (i = 0; s->ptr_last < s->ptr; i++) {
-    if ((i & 7) == 0 && i > 0) {
-      printf ("\n%*s", n0, "");
-      n = n0;
-    }
-    n += printf (" %02x", *s->ptr_last++);
-  }
-  if (*fmt == '}') s->level--;
-  if (n < 32 + s->level * 2) { printf ("%*s", 32 + s->level * 2 - n, ""); }
-  va_start (ap, fmt);
-  vfprintf (stdout, fmt, ap);
-  va_end (ap);
-  if (strchr (fmt, '{')) s->level++;
-}
-#else
-#define bc_read_trace(...)
-#endif
-
-static int bc_read_error_end (BCReaderState *s) {
-  if (!s->error_state) {
-    JS_ThrowSyntaxError (s->ctx, "read after the end of the buffer");
-  }
-  return s->error_state = -1;
-}
-
-static int bc_get_u8 (BCReaderState *s, uint8_t *pval) {
-  if (unlikely (s->buf_end - s->ptr < 1)) {
-    *pval = 0; /* avoid warning */
-    return bc_read_error_end (s);
-  }
-  *pval = *s->ptr++;
-  return 0;
-}
-
-static int bc_get_u16 (BCReaderState *s, uint16_t *pval) {
-  uint16_t v;
-  if (unlikely (s->buf_end - s->ptr < 2)) {
-    *pval = 0; /* avoid warning */
-    return bc_read_error_end (s);
-  }
-  v = get_u16 (s->ptr);
-  if (is_be ()) v = bswap16 (v);
-  *pval = v;
-  s->ptr += 2;
-  return 0;
-}
-
-static __maybe_unused int bc_get_u32 (BCReaderState *s, uint32_t *pval) {
-  uint32_t v;
-  if (unlikely (s->buf_end - s->ptr < 4)) {
-    *pval = 0; /* avoid warning */
-    return bc_read_error_end (s);
-  }
-  v = get_u32 (s->ptr);
-  if (is_be ()) v = bswap32 (v);
-  *pval = v;
-  s->ptr += 4;
-  return 0;
-}
-
-static int bc_get_u64 (BCReaderState *s, uint64_t *pval) {
-  uint64_t v;
-  if (unlikely (s->buf_end - s->ptr < 8)) {
-    *pval = 0; /* avoid warning */
-    return bc_read_error_end (s);
-  }
-  v = get_u64 (s->ptr);
-  if (is_be ()) v = bswap64 (v);
-  *pval = v;
-  s->ptr += 8;
-  return 0;
-}
-
-static int bc_get_leb128 (BCReaderState *s, uint32_t *pval) {
-  int ret;
-  ret = get_leb128 (pval, s->ptr, s->buf_end);
-  if (unlikely (ret < 0)) return bc_read_error_end (s);
-  s->ptr += ret;
-  return 0;
-}
-
-static int bc_get_sleb128 (BCReaderState *s, int32_t *pval) {
-  int ret;
-  ret = get_sleb128 (pval, s->ptr, s->buf_end);
-  if (unlikely (ret < 0)) return bc_read_error_end (s);
-  s->ptr += ret;
-  return 0;
-}
-
-/* XXX: used to read an `int` with a positive value */
-static int bc_get_leb128_int (BCReaderState *s, int *pval) {
-  return bc_get_leb128 (s, (uint32_t *)pval);
-}
-
-static int bc_get_leb128_u16 (BCReaderState *s, uint16_t *pval) {
-  uint32_t val;
-  if (bc_get_leb128 (s, &val)) {
-    *pval = 0;
-    return -1;
-  }
-  *pval = val;
-  return 0;
-}
-
-static int bc_get_buf (BCReaderState *s, uint8_t *buf, uint32_t buf_len) {
-  if (buf_len != 0) {
-    if (unlikely (!buf || s->buf_end - s->ptr < buf_len))
-      return bc_read_error_end (s);
-    memcpy (buf, s->ptr, buf_len);
-    s->ptr += buf_len;
-  }
-  return 0;
-}
-
-/* Read a JSValue key (text) from bytecode stream */
-static int bc_get_key (BCReaderState *s, JSValue *pkey) {
-  uint32_t len;
-  if (bc_get_leb128 (s, &len)) return -1;
-  if (len == 0) {
-    *pkey = JS_KEY_empty;
-    return 0;
-  }
-  /* Read UTF-8 bytes */
-  char *buf = alloca (len + 1);
-  for (uint32_t i = 0; i < len; i++) {
-    uint8_t byte;
-    if (bc_get_u8 (s, &byte)) return -1;
-    buf[i] = (char)byte;
-  }
-  buf[len] = '\0';
-  /* Create interned key from UTF-8 */
-  *pkey = js_key_new_len (s->ctx, buf, len);
-  return JS_IsNull (*pkey) ? -1 : 0;
-}
-
-static JSText *JS_ReadString (BCReaderState *s) {
-  uint32_t len;
-  size_t size;
-  JSText *p;
-  uint32_t i;
-
-  if (bc_get_leb128 (s, &len)) return NULL;
-  /* len is uint32_t, JS_STRING_LEN_MAX is 56 bits, so this always fits */
-  p = js_alloc_string (s->ctx, len);
-  if (!p) {
-    s->error_state = -1;
-    return NULL;
-  }
-  /* UTF-32: each character is 32-bit */
-  size = (size_t)len * sizeof (uint32_t);
-  if ((s->buf_end - s->ptr) < size) {
-    bc_read_error_end (s);
-    /* GC handles cleanup - partial string will be collected */
-    return NULL;
-  }
-  for (i = 0; i < len; i++) {
-    uint32_t c = get_u32 (s->ptr);
-    if (is_be ()) c = bswap32 (c);
-    string_put (p, i, c);
-    s->ptr += 4;
-  }
-#ifdef DUMP_READ_OBJECT
-  JS_DumpString (s->ctx->rt, p);
-  printf ("\n");
-#endif
-  return p;
-}
-
-static uint32_t bc_get_flags (uint32_t flags, int *pidx, int n) {
-  uint32_t val;
-  /* XXX: this does not work for n == 32 */
-  val = (flags >> *pidx) & ((1U << n) - 1);
-  *pidx += n;
-  return val;
-}
-
-static int JS_ReadFunctionBytecode (BCReaderState *s, JSFunctionBytecode *b, int byte_code_offset, uint32_t bc_len) {
-  uint8_t *bc_buf;
-  int pos, len, op;
-
-  if (s->is_rom_data) {
-    /* directly use the input buffer */
-    if (unlikely (s->buf_end - s->ptr < bc_len)) return bc_read_error_end (s);
-    bc_buf = (uint8_t *)s->ptr;
-    s->ptr += bc_len;
-  } else {
-    bc_buf = (void *)((uint8_t *)b + byte_code_offset);
-    if (bc_get_buf (s, bc_buf, bc_len)) return -1;
-  }
-  b->byte_code_buf = bc_buf;
-
-  if (is_be ()) bc_byte_swap (bc_buf, bc_len);
-
-  pos = 0;
-  while (pos < bc_len) {
-    op = bc_buf[pos];
-    len = short_opcode_info (op).size;
-    switch (short_opcode_info (op).fmt) {
-    case OP_FMT_key:
-    case OP_FMT_key_u8:
-    case OP_FMT_key_u16:
-    case OP_FMT_key_label_u16:
-      /* Key operand is a cpool index; cpool values deserialized separately */
-      break;
-    default:
-      break;
-    }
-    pos += len;
-  }
-  return 0;
-}
-
-static JSValue JS_ReadObjectRec (BCReaderState *s);
-
-static int BC_add_object_ref1 (BCReaderState *s, JSRecord *p) {
-  if (s->allow_reference) {
-    if (js_resize_array (s->ctx, (void *)&s->objects, sizeof (s->objects[0]), &s->objects_size, s->objects_count + 1))
-      return -1;
-    s->objects[s->objects_count++] = p;
-  }
-  return 0;
-}
-
-static int BC_add_object_ref (BCReaderState *s, JSValue obj) {
-  return BC_add_object_ref1 (s, JS_VALUE_GET_OBJ (obj));
-}
-
-static JSValue JS_ReadFunctionTag (BCReaderState *s) {
-  JSContext *ctx = s->ctx;
-  JSFunctionBytecode bc, *b;
-  JSValue obj = JS_NULL;
-  uint16_t v16;
-  uint8_t v8;
-  int idx, i, local_count;
-  int function_size, cpool_offset, byte_code_offset;
-  int closure_var_offset, vardefs_offset;
-
-  memset (&bc, 0, sizeof (bc));
-  bc.header = objhdr_make (0, OBJ_CODE, false, false, false, false);
-
-  if (bc_get_u16 (s, &v16)) goto fail;
-  idx = 0;
-  bc.has_prototype = bc_get_flags (v16, &idx, 1);
-  bc.has_simple_parameter_list = bc_get_flags (v16, &idx, 1);
-  bc.func_kind = bc_get_flags (v16, &idx, 2);
-  bc.has_debug = bc_get_flags (v16, &idx, 1);
-  bc.is_direct_or_indirect_eval = bc_get_flags (v16, &idx, 1);
-  bc.read_only_bytecode = s->is_rom_data;
-  if (bc_get_u8 (s, &v8)) goto fail;
-  bc.js_mode = v8;
-  if (bc_get_key (s, &bc.func_name)) goto fail;
-  if (bc_get_leb128_u16 (s, &bc.arg_count)) goto fail;
-  if (bc_get_leb128_u16 (s, &bc.var_count)) goto fail;
-  if (bc_get_leb128_u16 (s, &bc.defined_arg_count)) goto fail;
-  if (bc_get_leb128_u16 (s, &bc.stack_size)) goto fail;
-  if (bc_get_leb128_int (s, &bc.closure_var_count)) goto fail;
-  if (bc_get_leb128_int (s, &bc.cpool_count)) goto fail;
-  if (bc_get_leb128_int (s, &bc.byte_code_len)) goto fail;
-  if (bc_get_leb128_int (s, &local_count)) goto fail;
-
-  if (bc.has_debug) {
-    function_size = sizeof (*b);
-  } else {
-    function_size = offsetof (JSFunctionBytecode, debug);
-  }
-  cpool_offset = function_size;
-  function_size += bc.cpool_count * sizeof (*bc.cpool);
-  vardefs_offset = function_size;
-  function_size += local_count * sizeof (*bc.vardefs);
-  closure_var_offset = function_size;
-  function_size += bc.closure_var_count * sizeof (*bc.closure_var);
-  byte_code_offset = function_size;
-  if (!bc.read_only_bytecode) { function_size += bc.byte_code_len; }
-
-  b = js_mallocz (ctx, function_size);
-  if (!b) return JS_EXCEPTION;
-
-  memcpy (b, &bc, offsetof (JSFunctionBytecode, debug));
-  b->header = objhdr_make (0, OBJ_CODE, false, false, false, false);
-  if (local_count != 0) {
-    b->vardefs = (void *)((uint8_t *)b + vardefs_offset);
-  }
-  if (b->closure_var_count != 0) {
-    b->closure_var = (void *)((uint8_t *)b + closure_var_offset);
-  }
-  if (b->cpool_count != 0) {
-    b->cpool = (void *)((uint8_t *)b + cpool_offset);
-  }
-
-  obj = JS_MKPTR (b);
-
-#ifdef DUMP_READ_OBJECT
-  bc_read_trace (s, "name: ");
-  print_atom (s->ctx, b->func_name);
-  printf ("\n");
-#endif
-  bc_read_trace (s, "args=%d vars=%d defargs=%d closures=%d cpool=%d\n", b->arg_count, b->var_count, b->defined_arg_count, b->closure_var_count, b->cpool_count);
-  bc_read_trace (s, "stack=%d bclen=%d locals=%d\n", b->stack_size, b->byte_code_len, local_count);
-
-  if (local_count != 0) {
-    bc_read_trace (s, "vars {\n");
-    for (i = 0; i < local_count; i++) {
-      JSVarDef *vd = &b->vardefs[i];
-      if (bc_get_key (s, &vd->var_name)) goto fail;
-      if (bc_get_leb128_int (s, &vd->scope_level)) goto fail;
-      if (bc_get_leb128_int (s, &vd->scope_next)) goto fail;
-      vd->scope_next--;
-      if (bc_get_u8 (s, &v8)) goto fail;
-      idx = 0;
-      vd->var_kind = bc_get_flags (v8, &idx, 4);
-      vd->is_const = bc_get_flags (v8, &idx, 1);
-      vd->is_lexical = bc_get_flags (v8, &idx, 1);
-      vd->is_captured = bc_get_flags (v8, &idx, 1);
-#ifdef DUMP_READ_OBJECT
-      bc_read_trace (s, "name: ");
-      print_atom (s->ctx, vd->var_name);
-      printf ("\n");
-#endif
-    }
-    bc_read_trace (s, "}\n");
-  }
-  if (b->closure_var_count != 0) {
-    bc_read_trace (s, "closure vars {\n");
-    for (i = 0; i < b->closure_var_count; i++) {
-      JSClosureVar *cv = &b->closure_var[i];
-      int var_idx;
-      if (bc_get_key (s, &cv->var_name)) goto fail;
-      if (bc_get_leb128_int (s, &var_idx)) goto fail;
-      cv->var_idx = var_idx;
-      if (bc_get_u8 (s, &v8)) goto fail;
-      idx = 0;
-      cv->is_local = bc_get_flags (v8, &idx, 1);
-      cv->is_arg = bc_get_flags (v8, &idx, 1);
-      cv->is_const = bc_get_flags (v8, &idx, 1);
-      cv->is_lexical = bc_get_flags (v8, &idx, 1);
-      cv->var_kind = bc_get_flags (v8, &idx, 4);
-#ifdef DUMP_READ_OBJECT
-      bc_read_trace (s, "name: ");
-      print_atom (s->ctx, cv->var_name);
-      printf ("\n");
-#endif
-    }
-    bc_read_trace (s, "}\n");
-  }
-  {
-    bc_read_trace (s, "bytecode {\n");
-    if (JS_ReadFunctionBytecode (s, b, byte_code_offset, b->byte_code_len))
-      goto fail;
-    bc_read_trace (s, "}\n");
-  }
-  if (b->has_debug) {
-    /* read optional debug information */
-    bc_read_trace (s, "debug {\n");
-    if (bc_get_key (s, &b->debug.filename)) goto fail;
-#ifdef DUMP_READ_OBJECT
-    bc_read_trace (s, "filename: ");
-    print_atom (s->ctx, b->debug.filename);
-    printf ("\n");
-#endif
-    if (bc_get_leb128_int (s, &b->debug.pc2line_len)) goto fail;
-    if (b->debug.pc2line_len) {
-      b->debug.pc2line_buf = js_mallocz (ctx, b->debug.pc2line_len);
-      if (!b->debug.pc2line_buf) goto fail;
-      if (bc_get_buf (s, b->debug.pc2line_buf, b->debug.pc2line_len))
-        goto fail;
-    }
-    if (bc_get_leb128_int (s, &b->debug.source_len)) goto fail;
-    if (b->debug.source_len) {
-      bc_read_trace (s, "source: %d bytes\n", b->source_len);
-      b->debug.source = js_mallocz (ctx, b->debug.source_len);
-      if (!b->debug.source) goto fail;
-      if (bc_get_buf (s, (uint8_t *)b->debug.source, b->debug.source_len))
-        goto fail;
-    }
-    bc_read_trace (s, "}\n");
-  }
-  if (b->cpool_count != 0) {
-    bc_read_trace (s, "cpool {\n");
-    for (i = 0; i < b->cpool_count; i++) {
-      JSValue val;
-      val = JS_ReadObjectRec (s);
-      if (JS_IsException (val)) goto fail;
-      b->cpool[i] = val;
-    }
-    bc_read_trace (s, "}\n");
-  }
-  return obj;
-fail:
-  return JS_EXCEPTION;
-}
-
-static JSValue JS_ReadObjectTag (BCReaderState *s) {
-  JSContext *ctx = s->ctx;
-  JSValue obj;
-  uint32_t prop_count, i;
-  JSValue key;
-  JSValue val;
-  int ret;
-
-  obj = JS_NewObject (ctx);
-  if (BC_add_object_ref (s, obj)) goto fail;
-  if (bc_get_leb128 (s, &prop_count)) goto fail;
-  for (i = 0; i < prop_count; i++) {
-    if (bc_get_key (s, &key)) goto fail;
-#ifdef DUMP_READ_OBJECT
-    bc_read_trace (s, "propname: ");
-    JS_DumpValue (key);
-    printf ("\n");
-#endif
-    val = JS_ReadObjectRec (s);
-    if (JS_IsException (val)) {
-      goto fail;
-    }
-    ret = JS_SetPropertyInternal (ctx, obj, key, val);
-    if (ret < 0) goto fail;
-  }
-  return obj;
-fail:
-  return JS_EXCEPTION;
-}
-
-static JSValue JS_ReadArray (BCReaderState *s, int tag) {
-  JSContext *ctx = s->ctx;
-  JSValue obj;
-  uint32_t len, i;
-  JSValue val;
-  BOOL is_template;
-
-  is_template = (tag == BC_TAG_TEMPLATE_OBJECT);
-
-  if (bc_get_leb128 (s, &len)) return JS_EXCEPTION;
-
-  /* Create intrinsic array with preallocated capacity */
-  obj = JS_NewArrayLen (ctx, len);
-  if (JS_IsException (obj)) return JS_EXCEPTION;
-
-  /* Note: intrinsic arrays don't support object reference tracking
-     for circular references - they're simpler value containers */
-
-  /* Read and set each element directly */
-  JSArray *arr = JS_VALUE_GET_ARRAY (obj);
-  for (i = 0; i < len; i++) {
-    val = JS_ReadObjectRec (s);
-    if (JS_IsException (val)) goto fail;
-    /* Replace the null placeholder with the read value */
-    arr->values[i] = val;
-  }
-
-  /* Template objects have additional 'raw' property - not supported for
-   * intrinsic arrays */
-  if (is_template) {
-    val = JS_ReadObjectRec (s);
-    if (JS_IsException (val)) goto fail;
-    /* Skip the raw property for intrinsic arrays */
-  }
-  return obj;
-fail:
-  return JS_EXCEPTION;
-}
-
-static JSValue JS_ReadObjectRec (BCReaderState *s) {
-  JSContext *ctx = s->ctx;
-  uint8_t tag;
-  JSValue obj = JS_NULL;
-
-  if (js_check_stack_overflow (ctx, 0)) return JS_ThrowStackOverflow (ctx);
-
-  if (bc_get_u8 (s, &tag)) return JS_EXCEPTION;
-
-  bc_read_trace (s, "%s {\n", bc_tag_str[tag]);
-
-  switch (tag) {
-  case BC_TAG_NULL:
-    obj = JS_NULL;
-    break;
-  case BC_TAG_BOOL_FALSE:
-  case BC_TAG_BOOL_TRUE:
-    obj = JS_NewBool (ctx, tag - BC_TAG_BOOL_FALSE);
-    break;
-  case BC_TAG_INT32: {
-    int32_t val;
-    if (bc_get_sleb128 (s, &val)) return JS_EXCEPTION;
-    bc_read_trace (s, "%d\n", val);
-    obj = JS_NewInt32 (ctx, val);
-  } break;
-  case BC_TAG_FLOAT64: {
-    JSFloat64Union u;
-    if (bc_get_u64 (s, &u.u64)) return JS_EXCEPTION;
-    bc_read_trace (s, "%g\n", u.d);
-    obj = __JS_NewFloat64 (ctx, u.d);
-  } break;
-  case BC_TAG_STRING: {
-    JSText *p;
-    p = JS_ReadString (s);
-    if (!p) return JS_EXCEPTION;
-    obj = JS_MKPTR (p);
-  } break;
-  case BC_TAG_FUNCTION_BYTECODE:
-    if (!s->allow_bytecode) goto invalid_tag;
-    obj = JS_ReadFunctionTag (s);
-    break;
-  case BC_TAG_OBJECT:
-    obj = JS_ReadObjectTag (s);
-    break;
-  case BC_TAG_ARRAY:
-  case BC_TAG_TEMPLATE_OBJECT:
-    obj = JS_ReadArray (s, tag);
-    break;
-  case BC_TAG_OBJECT_REFERENCE: {
-    uint32_t val;
-    if (!s->allow_reference)
-      return JS_ThrowSyntaxError (ctx, "object references are not allowed");
-    if (bc_get_leb128 (s, &val)) return JS_EXCEPTION;
-    bc_read_trace (s, "%u\n", val);
-    if (val >= s->objects_count) {
-      return JS_ThrowSyntaxError (ctx, "invalid object reference (%u >= %u)", val, s->objects_count);
-    }
-    obj = JS_MKPTR (s->objects[val]);
-  } break;
-  default:
-  invalid_tag:
-    return JS_ThrowSyntaxError (ctx, "invalid tag (tag=%d pos=%u)", tag, (unsigned int)(s->ptr - s->buf_start));
-  }
-  bc_read_trace (s, "}\n");
-  return obj;
-}
-
-static int JS_ReadObjectAtoms (BCReaderState *s) {
-  uint8_t v8;
-  uint32_t atom_count;
-
-  if (bc_get_u8 (s, &v8)) return -1;
-  if (v8 != BC_VERSION) {
-    JS_ThrowSyntaxError (s->ctx, "invalid version (%d expected=%d)", v8, BC_VERSION);
-    return -1;
-  }
-  /* Read atom count - should always be 0 for new bytecode */
-  if (bc_get_leb128 (s, &atom_count)) return -1;
-  bc_read_trace (s, "%d atom indexes\n", atom_count);
-  if (atom_count != 0) {
-    JS_ThrowSyntaxError (s->ctx, "legacy atom format not supported");
-    return -1;
-  }
-  return 0;
-}
-
-static void bc_reader_free (BCReaderState *s) {
-  js_free (s->ctx, s->objects);
-}
-
-JSValue JS_ReadObject (JSContext *ctx, const uint8_t *buf, size_t buf_len, int flags) {
-  BCReaderState ss, *s = &ss;
-  JSValue obj;
-
-  ctx->binary_object_count += 1;
-  ctx->binary_object_size += buf_len;
-
-  memset (s, 0, sizeof (*s));
-  s->ctx = ctx;
-  s->buf_start = buf;
-  s->buf_end = buf + buf_len;
-  s->ptr = buf;
-  s->allow_bytecode = ((flags & JS_READ_OBJ_BYTECODE) != 0);
-  s->is_rom_data = ((flags & JS_READ_OBJ_ROM_DATA) != 0);
-  s->allow_sab = ((flags & JS_READ_OBJ_SAB) != 0);
-  s->allow_reference = ((flags & JS_READ_OBJ_REFERENCE) != 0);
-  if (JS_ReadObjectAtoms (s)) {
-    obj = JS_EXCEPTION;
-  } else {
-    obj = JS_ReadObjectRec (s);
-  }
-  bc_reader_free (s);
-  return obj;
-}
-
-/*******************************************************************/
-/* JSCompiledUnit Serialization */
-
-/* Magic number for compiled unit files */
-#define COMPILED_UNIT_MAGIC 0x43454C4C  /* "CELL" */
-#define COMPILED_UNIT_VERSION 1
-
-/* Write a JSCompiledUnit to a byte buffer.
-   Returns allocated buffer (caller must free), or NULL on error.
-   The format is:
-   - magic (4 bytes): "CELL"
-   - version (1 byte)
-   - flags (1 byte): has_debug
-   - local_count (2 bytes)
-   - stack_size (2 bytes)
-   - cpool_count (4 bytes)
-   - byte_code_len (4 bytes)
-   - cpool values (variable)
-   - bytecode (byte_code_len bytes)
-   - debug section (if has_debug)
-*/
-uint8_t *JS_WriteCompiledUnit (JSContext *ctx, JSCompiledUnit *unit, size_t *out_len) {
-  DynBuf dbuf;
-  dbuf_init (&dbuf);
-
-  /* Magic */
-  dbuf_put_u32 (&dbuf, COMPILED_UNIT_MAGIC);
-
-  /* Version */
-  dbuf_putc (&dbuf, COMPILED_UNIT_VERSION);
-
-  /* Flags */
-  uint8_t flags = 0;
-  if (unit->has_debug) flags |= 1;
-  dbuf_putc (&dbuf, flags);
-
-  /* Stack requirements */
-  dbuf_put_u16 (&dbuf, unit->local_count);
-  dbuf_put_u16 (&dbuf, unit->stack_size);
-
-  /* Counts */
-  dbuf_put_u32 (&dbuf, unit->cpool_count);
-  dbuf_put_u32 (&dbuf, unit->byte_code_len);
-
-  /* Write constant pool (simplified - just strings for now) */
-  for (int i = 0; i < unit->cpool_count; i++) {
-    JSValue val = unit->cpool[i];
-    uint32_t tag = JS_VALUE_GET_TAG (val);
-
-    if (tag == JS_TAG_INT) {
-      dbuf_putc (&dbuf, 1);  /* type: int */
-      int32_t v = JS_VALUE_GET_INT (val);
-      dbuf_put_u32 (&dbuf, (uint32_t)v);
-    } else if (tag == JS_TAG_FLOAT64) {
-      dbuf_putc (&dbuf, 2);  /* type: float */
-      double d = JS_VALUE_GET_FLOAT64 (val);
-      dbuf_put (&dbuf, (uint8_t *)&d, sizeof (d));
-    } else if (JS_IsText (val)) {
-      dbuf_putc (&dbuf, 3);  /* type: string */
-      const char *str = JS_ToCString (ctx, val);
-      if (str) {
-        size_t len = strlen (str);
-        dbuf_put_u32 (&dbuf, (uint32_t)len);
-        dbuf_put (&dbuf, (uint8_t *)str, len);
-        JS_FreeCString (ctx, str);
-      } else {
-        dbuf_put_u32 (&dbuf, 0);
-      }
-    } else {
-      dbuf_putc (&dbuf, 0);  /* type: null/unsupported */
-    }
-  }
-
-  /* Write bytecode */
-  dbuf_put (&dbuf, unit->byte_code_buf, unit->byte_code_len);
-
-  /* Write debug section if present */
-  if (unit->has_debug) {
-    /* Filename */
-    const char *fname = JS_ToCString (ctx, unit->debug.filename);
-    if (fname) {
-      size_t len = strlen (fname);
-      dbuf_put_u32 (&dbuf, (uint32_t)len);
-      dbuf_put (&dbuf, (uint8_t *)fname, len);
-      JS_FreeCString (ctx, fname);
-    } else {
-      dbuf_put_u32 (&dbuf, 0);
-    }
-
-    /* source_len, pc2line_len */
-    dbuf_put_u32 (&dbuf, unit->debug.source_len);
-    dbuf_put_u32 (&dbuf, unit->debug.pc2line_len);
-
-    /* pc2line_buf */
-    if (unit->debug.pc2line_len > 0 && unit->debug.pc2line_buf) {
-      dbuf_put (&dbuf, unit->debug.pc2line_buf, unit->debug.pc2line_len);
-    }
-
-    /* source */
-    if (unit->debug.source_len > 0 && unit->debug.source) {
-      dbuf_put (&dbuf, (uint8_t *)unit->debug.source, unit->debug.source_len);
-    }
-  }
-
-  *out_len = dbuf.size;
-  return dbuf.buf;
-}
-
-/* Read a JSCompiledUnit from a byte buffer.
-   Returns unit on success, NULL on error. */
-JSCompiledUnit *JS_ReadCompiledUnit (JSContext *ctx, const uint8_t *buf, size_t buf_len) {
-  const uint8_t *p = buf;
-  const uint8_t *end = buf + buf_len;
-
-  if (buf_len < 18) return NULL;  /* Minimum header size */
-
-  /* Check magic */
-  uint32_t magic = get_u32 (p); p += 4;
-  if (magic != COMPILED_UNIT_MAGIC) return NULL;
-
-  /* Version */
-  uint8_t version = *p++;
-  if (version != COMPILED_UNIT_VERSION) return NULL;
-
-  /* Flags */
-  uint8_t flags = *p++;
-  BOOL has_debug = (flags & 1) != 0;
-
-  /* Stack requirements */
-  uint16_t local_count = get_u16 (p); p += 2;
-  uint16_t stack_size = get_u16 (p); p += 2;
-
-  /* Counts */
-  uint32_t cpool_count = get_u32 (p); p += 4;
-  uint32_t byte_code_len = get_u32 (p); p += 4;
-
-  /* Calculate allocation size */
-  size_t unit_size;
-  if (has_debug) {
-    unit_size = sizeof (JSCompiledUnit);
-  } else {
-    unit_size = offsetof (JSCompiledUnit, debug);
-  }
-  size_t cpool_offset = unit_size;
-  unit_size += cpool_count * sizeof (JSValue);
-  size_t bc_offset = unit_size;
-  unit_size += byte_code_len;
-
-  /* Allocate unit */
-  JSCompiledUnit *unit = pjs_mallocz (unit_size);
-  if (!unit) return NULL;
-
-  /* Initialize header */
-  unit->header = objhdr_make (0, OBJ_CODE, false, false, false, false);
-  unit->has_debug = has_debug;
-  unit->read_only_bytecode = 0;
-  unit->local_count = local_count;
-  unit->stack_size = stack_size;
-  unit->cpool_count = cpool_count;
-  unit->byte_code_len = byte_code_len;
-
-  /* Setup pointers */
-  if (cpool_count > 0) {
-    unit->cpool = (JSValue *)((uint8_t *)unit + cpool_offset);
-  } else {
-    unit->cpool = NULL;
-  }
-  unit->byte_code_buf = (uint8_t *)unit + bc_offset;
-
-  /* Read constant pool */
-  for (uint32_t i = 0; i < cpool_count; i++) {
-    if (p >= end) goto fail;
-    uint8_t type = *p++;
-
-    switch (type) {
-    case 0:  /* null */
-      unit->cpool[i] = JS_NULL;
-      break;
-    case 1:  /* int */
-      if (p + 4 > end) goto fail;
-      unit->cpool[i] = JS_NewInt32 (ctx, (int32_t)get_u32 (p));
-      p += 4;
-      break;
-    case 2:  /* float */
-      if (p + 8 > end) goto fail;
-      {
-        double d;
-        memcpy (&d, p, sizeof (d));
-        unit->cpool[i] = JS_NewFloat64 (ctx, d);
-        p += 8;
-      }
-      break;
-    case 3:  /* string */
-      if (p + 4 > end) goto fail;
-      {
-        uint32_t len = get_u32 (p); p += 4;
-        if (p + len > end) goto fail;
-        unit->cpool[i] = JS_NewStringLen (ctx, (const char *)p, len);
-        p += len;
-      }
-      break;
-    default:
-      unit->cpool[i] = JS_NULL;
-      break;
-    }
-  }
-
-  /* Read bytecode */
-  if (p + byte_code_len > end) goto fail;
-  memcpy (unit->byte_code_buf, p, byte_code_len);
-  p += byte_code_len;
-
-  /* Read debug section if present */
-  if (has_debug) {
-    /* Filename */
-    if (p + 4 > end) goto fail;
-    uint32_t fname_len = get_u32 (p); p += 4;
-    if (p + fname_len > end) goto fail;
-    if (fname_len > 0) {
-      unit->debug.filename = JS_NewStringLen (ctx, (const char *)p, fname_len);
-    } else {
-      unit->debug.filename = JS_NULL;
-    }
-    p += fname_len;
-
-    /* source_len, pc2line_len */
-    if (p + 8 > end) goto fail;
-    unit->debug.source_len = get_u32 (p); p += 4;
-    unit->debug.pc2line_len = get_u32 (p); p += 4;
-
-    /* pc2line_buf */
-    if (unit->debug.pc2line_len > 0) {
-      if (p + unit->debug.pc2line_len > end) goto fail;
-      unit->debug.pc2line_buf = js_malloc (ctx, unit->debug.pc2line_len);
-      if (!unit->debug.pc2line_buf) goto fail;
-      memcpy (unit->debug.pc2line_buf, p, unit->debug.pc2line_len);
-      p += unit->debug.pc2line_len;
-    } else {
-      unit->debug.pc2line_buf = NULL;
-    }
-
-    /* source */
-    if (unit->debug.source_len > 0) {
-      if (p + unit->debug.source_len > end) goto fail;
-      unit->debug.source = js_malloc (ctx, unit->debug.source_len + 1);
-      if (!unit->debug.source) goto fail;
-      memcpy (unit->debug.source, p, unit->debug.source_len);
-      unit->debug.source[unit->debug.source_len] = '\0';
-      p += unit->debug.source_len;
-    } else {
-      unit->debug.source = NULL;
-    }
-  }
-
-  return unit;
-
-fail:
-  pjs_free (unit);
-  return NULL;
-}
-
-/*******************************************************************/
-/* CellModule Serialization (context-neutral) */
-
-/* Free a CellModule and all its contents */
-void cell_module_free (CellModule *mod) {
-  if (!mod) return;
-
-  /* Free string table */
-  if (mod->string_data) pjs_free (mod->string_data);
-  if (mod->string_offsets) pjs_free (mod->string_offsets);
-
-  /* Free units */
-  if (mod->units) {
-    for (uint32_t i = 0; i < mod->unit_count; i++) {
-      CellUnit *u = &mod->units[i];
-      if (u->constants) pjs_free (u->constants);
-      if (u->bytecode) pjs_free (u->bytecode);
-      if (u->upvalues) pjs_free (u->upvalues);
-      if (u->externals) pjs_free (u->externals);
-      if (u->pc2line) pjs_free (u->pc2line);
-    }
-    pjs_free (mod->units);
-  }
-
-  /* Free source */
-  if (mod->source) pjs_free (mod->source);
-
-  pjs_free (mod);
-}
-
-/* Write a CellModule to a byte buffer (context-neutral format).
-   Returns allocated buffer (caller must free with pjs_free), or NULL on error.
-   Format:
-   - magic (4 bytes): 0x4C4C4543 "CELL"
-   - version (1 byte)
-   - flags (1 byte)
-   - string_count (4 bytes)
-   - string_data_size (4 bytes)
-   - string_data (string_data_size bytes)
-   - string_offsets (string_count * 4 bytes)
-   - unit_count (4 bytes)
-   - for each unit:
-     - const_count (4 bytes)
-     - for each const: type (1 byte), value (4-8 bytes)
-     - bytecode_len (4 bytes)
-     - bytecode (bytecode_len bytes)
-     - arg_count (2 bytes)
-     - var_count (2 bytes)
-     - stack_size (2 bytes)
-     - upvalue_count (2 bytes)
-     - for each upvalue: kind (1 byte), index (2 bytes)
-     - external_count (4 bytes)
-     - for each external: pc_offset (4), name_sid (4), kind (1)
-     - pc2line_len (4 bytes)
-     - pc2line (pc2line_len bytes)
-     - name_sid (4 bytes)
-   - source_len (4 bytes)
-   - source (source_len bytes)
-*/
-uint8_t *cell_module_write (CellModule *mod, size_t *out_len) {
-  DynBuf buf;
-  dbuf_init (&buf);
-
-  /* Header */
-  dbuf_put_u32 (&buf, mod->magic);
-  dbuf_putc (&buf, mod->version);
-  dbuf_putc (&buf, mod->flags);
-
-  /* String table */
-  dbuf_put_u32 (&buf, mod->string_count);
-  dbuf_put_u32 (&buf, mod->string_data_size);
-  if (mod->string_data_size > 0 && mod->string_data) {
-    dbuf_put (&buf, mod->string_data, mod->string_data_size);
-  }
-  if (mod->string_count > 0 && mod->string_offsets) {
-    for (uint32_t i = 0; i < mod->string_count; i++) {
-      dbuf_put_u32 (&buf, mod->string_offsets[i]);
-    }
-  }
-
-  /* Units */
-  dbuf_put_u32 (&buf, mod->unit_count);
-  for (uint32_t u = 0; u < mod->unit_count; u++) {
-    CellUnit *unit = &mod->units[u];
-
-    /* Constants */
-    dbuf_put_u32 (&buf, unit->const_count);
-    for (uint32_t c = 0; c < unit->const_count; c++) {
-      CellConst *cc = &unit->constants[c];
-      dbuf_putc (&buf, cc->type);
-      switch (cc->type) {
-      case CELL_CONST_NULL:
-        break;
-      case CELL_CONST_INT:
-        dbuf_put_u32 (&buf, (uint32_t)cc->i32);
-        break;
-      case CELL_CONST_FLOAT: {
-        JSFloat64Union fu;
-        fu.d = cc->f64;
-        dbuf_put_u32 (&buf, (uint32_t)(fu.u64 & 0xFFFFFFFF));
-        dbuf_put_u32 (&buf, (uint32_t)(fu.u64 >> 32));
-        break;
-      }
-      case CELL_CONST_STRING:
-      case CELL_CONST_UNIT:
-        dbuf_put_u32 (&buf, cc->string_sid);
-        break;
-      }
-    }
-
-    /* Bytecode */
-    dbuf_put_u32 (&buf, unit->bytecode_len);
-    if (unit->bytecode_len > 0 && unit->bytecode) {
-      dbuf_put (&buf, unit->bytecode, unit->bytecode_len);
-    }
-
-    /* Stack requirements */
-    dbuf_put_u16 (&buf, unit->arg_count);
-    dbuf_put_u16 (&buf, unit->var_count);
-    dbuf_put_u16 (&buf, unit->stack_size);
-
-    /* Upvalues */
-    dbuf_put_u16 (&buf, unit->upvalue_count);
-    for (uint16_t i = 0; i < unit->upvalue_count; i++) {
-      dbuf_putc (&buf, unit->upvalues[i].kind);
-      dbuf_put_u16 (&buf, unit->upvalues[i].index);
-    }
-
-    /* Externals */
-    dbuf_put_u32 (&buf, unit->external_count);
-    for (uint32_t i = 0; i < unit->external_count; i++) {
-      dbuf_put_u32 (&buf, unit->externals[i].pc_offset);
-      dbuf_put_u32 (&buf, unit->externals[i].name_sid);
-      dbuf_putc (&buf, unit->externals[i].kind);
-    }
-
-    /* Debug */
-    dbuf_put_u32 (&buf, unit->pc2line_len);
-    if (unit->pc2line_len > 0 && unit->pc2line) {
-      dbuf_put (&buf, unit->pc2line, unit->pc2line_len);
-    }
-    dbuf_put_u32 (&buf, unit->name_sid);
-  }
-
-  /* Source */
-  dbuf_put_u32 (&buf, mod->source_len);
-  if (mod->source_len > 0 && mod->source) {
-    dbuf_put (&buf, (uint8_t *)mod->source, mod->source_len);
-  }
-
-  if (buf.error) {
-    dbuf_free (&buf);
-    *out_len = 0;
-    return NULL;
-  }
-
-  *out_len = buf.size;
-  return buf.buf;
-}
-
-/* Read a CellModule from a byte buffer.
-   Returns allocated CellModule (caller must free with cell_module_free), or NULL on error. */
-CellModule *cell_module_read (const uint8_t *buf, size_t buf_len) {
-  const uint8_t *p = buf;
-  const uint8_t *end = buf + buf_len;
-
-  if (buf_len < 14) return NULL;  /* minimum header size */
-
-  CellModule *mod = pjs_mallocz (sizeof (CellModule));
-  if (!mod) return NULL;
-
-  /* Header */
-  mod->magic = get_u32 (p); p += 4;
-  if (mod->magic != CELL_MODULE_MAGIC) goto fail;
-  mod->version = *p++;
-  if (mod->version != CELL_MODULE_VERSION) goto fail;
-  mod->flags = *p++;
-
-  /* String table */
-  if (p + 8 > end) goto fail;
-  mod->string_count = get_u32 (p); p += 4;
-  mod->string_data_size = get_u32 (p); p += 4;
-
-  if (mod->string_data_size > 0) {
-    if (p + mod->string_data_size > end) goto fail;
-    mod->string_data = pjs_malloc (mod->string_data_size);
-    if (!mod->string_data) goto fail;
-    memcpy (mod->string_data, p, mod->string_data_size);
-    p += mod->string_data_size;
-  }
-
-  if (mod->string_count > 0) {
-    if (p + mod->string_count * 4 > end) goto fail;
-    mod->string_offsets = pjs_malloc (mod->string_count * sizeof (uint32_t));
-    if (!mod->string_offsets) goto fail;
-    for (uint32_t i = 0; i < mod->string_count; i++) {
-      mod->string_offsets[i] = get_u32 (p); p += 4;
-    }
-  }
-
-  /* Units */
-  if (p + 4 > end) goto fail;
-  mod->unit_count = get_u32 (p); p += 4;
-
-  if (mod->unit_count > 0) {
-    mod->units = pjs_mallocz (mod->unit_count * sizeof (CellUnit));
-    if (!mod->units) goto fail;
-
-    for (uint32_t u = 0; u < mod->unit_count; u++) {
-      CellUnit *unit = &mod->units[u];
-
-      /* Constants */
-      if (p + 4 > end) goto fail;
-      unit->const_count = get_u32 (p); p += 4;
-
-      if (unit->const_count > 0) {
-        unit->constants = pjs_mallocz (unit->const_count * sizeof (CellConst));
-        if (!unit->constants) goto fail;
-
-        for (uint32_t c = 0; c < unit->const_count; c++) {
-          if (p + 1 > end) goto fail;
-          unit->constants[c].type = *p++;
-          switch (unit->constants[c].type) {
-          case CELL_CONST_NULL:
-            break;
-          case CELL_CONST_INT:
-            if (p + 4 > end) goto fail;
-            unit->constants[c].i32 = (int32_t)get_u32 (p); p += 4;
-            break;
-          case CELL_CONST_FLOAT: {
-            if (p + 8 > end) goto fail;
-            JSFloat64Union fu;
-            fu.u64 = get_u32 (p);
-            fu.u64 |= ((uint64_t)get_u32 (p + 4)) << 32;
-            p += 8;
-            unit->constants[c].f64 = fu.d;
-            break;
-          }
-          case CELL_CONST_STRING:
-          case CELL_CONST_UNIT:
-            if (p + 4 > end) goto fail;
-            unit->constants[c].string_sid = get_u32 (p); p += 4;
-            break;
-          }
-        }
-      }
-
-      /* Bytecode */
-      if (p + 4 > end) goto fail;
-      unit->bytecode_len = get_u32 (p); p += 4;
-
-      if (unit->bytecode_len > 0) {
-        if (p + unit->bytecode_len > end) goto fail;
-        unit->bytecode = pjs_malloc (unit->bytecode_len);
-        if (!unit->bytecode) goto fail;
-        memcpy (unit->bytecode, p, unit->bytecode_len);
-        p += unit->bytecode_len;
-      }
-
-      /* Stack requirements */
-      if (p + 6 > end) goto fail;
-      unit->arg_count = get_u16 (p); p += 2;
-      unit->var_count = get_u16 (p); p += 2;
-      unit->stack_size = get_u16 (p); p += 2;
-
-      /* Upvalues */
-      if (p + 2 > end) goto fail;
-      unit->upvalue_count = get_u16 (p); p += 2;
-
-      if (unit->upvalue_count > 0) {
-        unit->upvalues = pjs_malloc (unit->upvalue_count * sizeof (CellCapDesc));
-        if (!unit->upvalues) goto fail;
-        for (uint16_t i = 0; i < unit->upvalue_count; i++) {
-          if (p + 3 > end) goto fail;
-          unit->upvalues[i].kind = *p++;
-          unit->upvalues[i].index = get_u16 (p); p += 2;
-        }
-      }
-
-      /* Externals */
-      if (p + 4 > end) goto fail;
-      unit->external_count = get_u32 (p); p += 4;
-
-      if (unit->external_count > 0) {
-        unit->externals = pjs_malloc (unit->external_count * sizeof (CellExternalReloc));
-        if (!unit->externals) goto fail;
-        for (uint32_t i = 0; i < unit->external_count; i++) {
-          if (p + 9 > end) goto fail;
-          unit->externals[i].pc_offset = get_u32 (p); p += 4;
-          unit->externals[i].name_sid = get_u32 (p); p += 4;
-          unit->externals[i].kind = *p++;
-        }
-      }
-
-      /* Debug */
-      if (p + 4 > end) goto fail;
-      unit->pc2line_len = get_u32 (p); p += 4;
-
-      if (unit->pc2line_len > 0) {
-        if (p + unit->pc2line_len > end) goto fail;
-        unit->pc2line = pjs_malloc (unit->pc2line_len);
-        if (!unit->pc2line) goto fail;
-        memcpy (unit->pc2line, p, unit->pc2line_len);
-        p += unit->pc2line_len;
-      }
-
-      if (p + 4 > end) goto fail;
-      unit->name_sid = get_u32 (p); p += 4;
-    }
-  }
-
-  /* Source */
-  if (p + 4 > end) goto fail;
-  mod->source_len = get_u32 (p); p += 4;
-
-  if (mod->source_len > 0) {
-    if (p + mod->source_len > end) goto fail;
-    mod->source = pjs_malloc (mod->source_len + 1);
-    if (!mod->source) goto fail;
-    memcpy (mod->source, p, mod->source_len);
-    mod->source[mod->source_len] = '\0';
-    p += mod->source_len;
-  }
-
-  return mod;
-
-fail:
-  cell_module_free (mod);
-  return NULL;
-}
-
-/* Helper: get string from CellModule string table */
-static const char *cell_module_get_string (CellModule *mod, uint32_t sid, uint32_t *out_len) {
-  if (sid >= mod->string_count) return NULL;
-  uint32_t offset = mod->string_offsets[sid];
-  uint32_t next_offset = (sid + 1 < mod->string_count)
-                         ? mod->string_offsets[sid + 1]
-                         : mod->string_data_size;
-  *out_len = next_offset - offset;
-  return (const char *)(mod->string_data + offset);
-}
-
-/* Integrate a CellModule with an environment and execute.
-   This materializes the string table into the target context's stone arena,
-   creates runtime bytecode, patches external relocations, and returns the
-   main unit wrapped as a callable function.
-
-   Parameters:
-   - ctx: target context
-   - mod: context-neutral module (ownership NOT transferred)
-   - env: stoned record for environment (or JS_NULL)
-
-   Returns: callable function value, or JS_EXCEPTION on error.
-*/
-JSValue cell_module_integrate (JSContext *ctx, CellModule *mod, JSValue env) {
-  JSValue *string_table = NULL;
-  JSFunctionBytecode **units = NULL;
-  JSValue result = JS_EXCEPTION;
-  uint32_t i, j;
-
-  if (mod->unit_count == 0) {
-    JS_ThrowTypeError (ctx, "module has no units");
-    return JS_EXCEPTION;
-  }
-
-  /* Step 1: Materialize string table into context's stone arena */
-  if (mod->string_count > 0) {
-    string_table = pjs_mallocz (mod->string_count * sizeof (JSValue));
-    if (!string_table) goto fail;
-
-    for (i = 0; i < mod->string_count; i++) {
-      uint32_t len;
-      const char *str = cell_module_get_string (mod, i, &len);
-      if (!str) {
-        string_table[i] = JS_NULL;
-      } else {
-        /* Intern as a stoned key */
-        string_table[i] = js_key_new_len (ctx, str, len);
-      }
-    }
-  }
-
-  /* Step 2: Create JSFunctionBytecode for each unit */
-  units = pjs_mallocz (mod->unit_count * sizeof (JSFunctionBytecode *));
-  if (!units) goto fail;
-
-  for (i = 0; i < mod->unit_count; i++) {
-    CellUnit *cu = &mod->units[i];
-
-    /* Calculate bytecode structure size */
-    int function_size = sizeof (JSFunctionBytecode);
-    int cpool_offset = function_size;
-    function_size += cu->const_count * sizeof (JSValue);
-    int byte_code_offset = function_size;
-    function_size += cu->bytecode_len;
-
-    JSFunctionBytecode *b = pjs_mallocz (function_size);
-    if (!b) goto fail;
-    units[i] = b;
-
-    /* Initialize header */
-    b->header = objhdr_make (0, OBJ_CODE, false, false, false, false);
-    b->arg_count = cu->arg_count;
-    b->var_count = cu->var_count;
-    b->defined_arg_count = cu->arg_count;  /* Same as arg_count for simple functions */
-    b->has_simple_parameter_list = 1;       /* Assume simple parameter list */
-    b->stack_size = cu->stack_size;
-    b->cpool_count = cu->const_count;
-    b->byte_code_len = cu->bytecode_len;
-
-    /* Set up pointers */
-    b->cpool = (JSValue *)((uint8_t *)b + cpool_offset);
-    b->byte_code_buf = (uint8_t *)b + byte_code_offset;
-
-    /* Materialize constants */
-    for (j = 0; j < cu->const_count; j++) {
-      CellConst *cc = &cu->constants[j];
-      switch (cc->type) {
-      case CELL_CONST_NULL:
-        b->cpool[j] = JS_NULL;
-        break;
-      case CELL_CONST_INT:
-        b->cpool[j] = JS_NewInt32 (ctx, cc->i32);
-        break;
-      case CELL_CONST_FLOAT:
-        b->cpool[j] = JS_NewFloat64 (ctx, cc->f64);
-        break;
-      case CELL_CONST_STRING:
-        if (cc->string_sid < mod->string_count) {
-          b->cpool[j] = string_table[cc->string_sid];
-        } else {
-          b->cpool[j] = JS_NULL;
-        }
-        break;
-      case CELL_CONST_UNIT:
-        /* Will be patched after all units are created */
-        b->cpool[j] = JS_NULL;
-        break;
-      }
-    }
-
-    /* Copy bytecode */
-    memcpy (b->byte_code_buf, cu->bytecode, cu->bytecode_len);
-
-    /* Set function name from string table */
-    if (cu->name_sid < mod->string_count) {
-      b->func_name = string_table[cu->name_sid];
-    } else {
-      b->func_name = JS_KEY_empty;
-    }
-  }
-
-  /* Step 3: Patch unit references in cpool */
-  for (i = 0; i < mod->unit_count; i++) {
-    CellUnit *cu = &mod->units[i];
-    JSFunctionBytecode *b = units[i];
-
-    for (j = 0; j < cu->const_count; j++) {
-      if (cu->constants[j].type == CELL_CONST_UNIT) {
-        uint32_t uid = cu->constants[j].unit_id;
-        if (uid < mod->unit_count) {
-          b->cpool[j] = JS_MKPTR (units[uid]);
-        }
-      }
-    }
-  }
-
-  /* Step 4: Patch external relocations for main unit (unit 0) */
-  {
-    CellUnit *cu = &mod->units[0];
-    JSFunctionBytecode *b = units[0];
-    uint8_t *bc = b->byte_code_buf;
-
-    /* Get env record if provided */
-    JSRecord *env_rec = NULL;
-    if (!JS_IsNull (env) && JS_IsRecord (env)) {
-      env_rec = (JSRecord *)JS_VALUE_GET_OBJ (env);
-    }
-
-    for (j = 0; j < cu->external_count; j++) {
-      CellExternalReloc *rel = &cu->externals[j];
-      uint32_t pc = rel->pc_offset;
-      uint32_t name_sid = rel->name_sid;
-
-      if (name_sid >= mod->string_count) continue;
-      JSValue name = string_table[name_sid];
-
-      if (rel->kind == EXT_GET) {
-        /* Try env first */
-        if (env_rec) {
-          int slot = rec_find_slot (env_rec, name);
-          if (slot > 0) {
-            bc[pc] = OP_get_env_slot;
-            put_u16 (bc + pc + 1, (uint16_t)slot);
-            bc[pc + 3] = OP_nop;
-            bc[pc + 4] = OP_nop;
-            continue;
-          }
-        }
-
-        /* Try global */
-        JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-        int slot = rec_find_slot (global, name);
-        if (slot > 0) {
-          bc[pc] = OP_get_global_slot;
-          put_u16 (bc + pc + 1, (uint16_t)slot);
-          bc[pc + 3] = OP_nop;
-          bc[pc + 4] = OP_nop;
-          continue;
-        }
-
-        /* Link error */
-        char buf[64];
-        JS_ThrowReferenceError (ctx, "'%s' is not defined",
-                                JS_KeyGetStr (ctx, buf, sizeof (buf), name));
-        goto fail;
-
-      } else if (rel->kind == EXT_SET) {
-        /* Try env first (writable) */
-        if (env_rec) {
-          int slot = rec_find_slot (env_rec, name);
-          if (slot > 0) {
-            bc[pc] = OP_set_env_slot;
-            put_u16 (bc + pc + 1, (uint16_t)slot);
-            bc[pc + 3] = OP_nop;
-            bc[pc + 4] = OP_nop;
-            continue;
-          }
-        }
-
-        /* Try global */
-        JSRecord *global = (JSRecord *)JS_VALUE_GET_OBJ (ctx->global_obj);
-        int slot = rec_find_slot (global, name);
-        if (slot > 0) {
-          bc[pc] = OP_set_global_slot;
-          put_u16 (bc + pc + 1, (uint16_t)slot);
-          bc[pc + 3] = OP_nop;
-          bc[pc + 4] = OP_nop;
-          continue;
-        }
-
-        /* Link error */
-        char buf[64];
-        JS_ThrowReferenceError (ctx, "cannot assign to '%s' - not found",
-                                JS_KeyGetStr (ctx, buf, sizeof (buf), name));
-        goto fail;
-      }
-    }
-  }
-
-  /* Step 5: Create closure from main unit and set env_record */
-  {
-    JSValue linked = JS_MKPTR (units[0]);
-    linked = js_closure (ctx, linked, NULL);
-    if (JS_IsException (linked)) goto fail;
-
-    /* Set env_record on the function */
-    JSFunction *f = JS_VALUE_GET_FUNCTION (linked);
-    f->u.func.env_record = env;
-
-    result = linked;
-  }
-
-  /* Success - don't free units (now owned by result closure) */
-  pjs_free (string_table);
-  pjs_free (units);
-  return result;
-
-fail:
-  /* Free allocated units on failure */
-  if (units) {
-    for (i = 0; i < mod->unit_count; i++) {
-      if (units[i]) pjs_free (units[i]);
-    }
-    pjs_free (units);
-  }
-  if (string_table) pjs_free (string_table);
-  return JS_EXCEPTION;
-}
-
-/*******************************************************************/
-/* JSFunctionBytecode to CellModule conversion */
-
-/* Helper structure for building string table */
-typedef struct {
-  JSValue *strings;      /* array of JSValue strings */
-  uint32_t count;
-  uint32_t capacity;
-} StringTableBuilder;
-
-static void stb_init (StringTableBuilder *stb) {
-  stb->strings = NULL;
-  stb->count = 0;
-  stb->capacity = 0;
-}
-
-static void stb_free (StringTableBuilder *stb) {
-  if (stb->strings) pjs_free (stb->strings);
-  stb->strings = NULL;
-  stb->count = 0;
-  stb->capacity = 0;
-}
-
-/* Add a string to the builder, return its string_id.
-   If string already exists, return existing id. */
-static uint32_t stb_add (StringTableBuilder *stb, JSValue str) {
-  /* Check if already present */
-  for (uint32_t i = 0; i < stb->count; i++) {
-    if (stb->strings[i] == str) return i;
-  }
-
-  /* Add new entry */
-  if (stb->count >= stb->capacity) {
-    uint32_t new_cap = stb->capacity ? stb->capacity * 2 : 16;
-    JSValue *new_arr = pjs_realloc (stb->strings, new_cap * sizeof (JSValue));
-    if (!new_arr) return UINT32_MAX;
-    stb->strings = new_arr;
-    stb->capacity = new_cap;
-  }
-
-  stb->strings[stb->count] = str;
-  return stb->count++;
-}
-
-/* Helper structure for collecting bytecodes */
-typedef struct {
-  JSFunctionBytecode **funcs;
-  uint32_t count;
-  uint32_t capacity;
-} FuncCollector;
-
-static void fc_init (FuncCollector *fc) {
-  fc->funcs = NULL;
-  fc->count = 0;
-  fc->capacity = 0;
-}
-
-static void fc_free (FuncCollector *fc) {
-  if (fc->funcs) pjs_free (fc->funcs);
-  fc->funcs = NULL;
-  fc->count = 0;
-  fc->capacity = 0;
-}
-
-/* Add a function to collector, return its unit_id */
-static uint32_t fc_add (FuncCollector *fc, JSFunctionBytecode *b) {
-  /* Check if already present */
-  for (uint32_t i = 0; i < fc->count; i++) {
-    if (fc->funcs[i] == b) return i;
-  }
-
-  /* Add new entry */
-  if (fc->count >= fc->capacity) {
-    uint32_t new_cap = fc->capacity ? fc->capacity * 2 : 8;
-    JSFunctionBytecode **new_arr = pjs_realloc (fc->funcs, new_cap * sizeof (JSFunctionBytecode *));
-    if (!new_arr) return UINT32_MAX;
-    fc->funcs = new_arr;
-    fc->capacity = new_cap;
-  }
-
-  fc->funcs[fc->count] = b;
-  return fc->count++;
-}
-
-/* Recursively collect all functions in bytecode tree */
-static int collect_functions (FuncCollector *fc, JSFunctionBytecode *b) {
-  uint32_t uid = fc_add (fc, b);
-  if (uid == UINT32_MAX) return -1;
-
-  /* Scan cpool for nested functions */
-  for (int i = 0; i < b->cpool_count; i++) {
-    JSValue v = b->cpool[i];
-    if (JS_VALUE_GET_TAG (v) == JS_TAG_PTR) {
-      void *ptr = JS_VALUE_GET_PTR (v);
-      objhdr_t hdr = *(objhdr_t *)ptr;
-      if (objhdr_type (hdr) == OBJ_CODE) {
-        /* This is a nested function */
-        if (collect_functions (fc, (JSFunctionBytecode *)ptr) < 0)
-          return -1;
-      }
-    }
-  }
-  return 0;
-}
-
-/* Collect all strings from a function's cpool and name */
-static int collect_strings (StringTableBuilder *stb, JSFunctionBytecode *b) {
-  /* Function name */
-  if (JS_IsText (b->func_name)) {
-    if (stb_add (stb, b->func_name) == UINT32_MAX) return -1;
-  }
-
-  /* Filename */
-  if (b->has_debug && JS_IsText (b->debug.filename)) {
-    if (stb_add (stb, b->debug.filename) == UINT32_MAX) return -1;
-  }
-
-  /* Cpool strings */
-  for (int i = 0; i < b->cpool_count; i++) {
-    JSValue v = b->cpool[i];
-    if (JS_IsText (v)) {
-      if (stb_add (stb, v) == UINT32_MAX) return -1;
-    }
-  }
-
-  /* Variable names (for debugging) */
-  if (b->vardefs) {
-    for (int i = 0; i < b->arg_count + b->var_count; i++) {
-      if (JS_IsText (b->vardefs[i].var_name)) {
-        if (stb_add (stb, b->vardefs[i].var_name) == UINT32_MAX) return -1;
-      }
-    }
-  }
-
-  /* Closure variable names */
-  if (b->closure_var) {
-    for (int i = 0; i < b->closure_var_count; i++) {
-      if (JS_IsText (b->closure_var[i].var_name)) {
-        if (stb_add (stb, b->closure_var[i].var_name) == UINT32_MAX) return -1;
-      }
-    }
-  }
-
-  return 0;
-}
-
-/* Find string_id for a JSValue string */
-static uint32_t find_string_id (StringTableBuilder *stb, JSValue str) {
-  for (uint32_t i = 0; i < stb->count; i++) {
-    if (stb->strings[i] == str) return i;
-  }
-  return UINT32_MAX;
-}
-
-/* Find unit_id for a JSFunctionBytecode */
-static uint32_t find_unit_id (FuncCollector *fc, JSFunctionBytecode *b) {
-  for (uint32_t i = 0; i < fc->count; i++) {
-    if (fc->funcs[i] == b) return i;
-  }
-  return UINT32_MAX;
-}
-
-/* Convert JSFunctionBytecode tree to CellModule.
-   This extracts all functions, builds a shared string table,
-   and creates external relocations for unresolved variables.
-
-   Parameters:
-   - ctx: context (for string conversion)
-   - main_func: compiled main function bytecode
-
-   Returns: allocated CellModule (caller must free with cell_module_free), or NULL on error.
-*/
-CellModule *cell_module_from_bytecode (JSContext *ctx, JSFunctionBytecode *main_func) {
-  CellModule *mod = NULL;
-  StringTableBuilder stb;
-  FuncCollector fc;
-  DynBuf string_data;
-  uint32_t i, j;
-
-  stb_init (&stb);
-  fc_init (&fc);
-  dbuf_init (&string_data);
-
-  /* Step 1: Collect all functions */
-  if (collect_functions (&fc, main_func) < 0) goto fail;
-
-  /* Step 2: Collect all strings from all functions */
-  for (i = 0; i < fc.count; i++) {
-    if (collect_strings (&stb, fc.funcs[i]) < 0) goto fail;
-  }
-
-  /* Step 3: Allocate module */
-  mod = pjs_mallocz (sizeof (CellModule));
-  if (!mod) goto fail;
-
-  mod->magic = CELL_MODULE_MAGIC;
-  mod->version = CELL_MODULE_VERSION;
-  mod->flags = 0;
-
-  /* Step 4: Build string table data */
-  mod->string_count = stb.count;
-  if (stb.count > 0) {
-    mod->string_offsets = pjs_malloc (stb.count * sizeof (uint32_t));
-    if (!mod->string_offsets) goto fail;
-
-    for (i = 0; i < stb.count; i++) {
-      mod->string_offsets[i] = string_data.size;
-
-      /* Convert JSValue string to UTF-8 */
-      const char *cstr = JS_ToCString (ctx, stb.strings[i]);
-      if (cstr) {
-        size_t len = strlen (cstr);
-        dbuf_put (&string_data, (uint8_t *)cstr, len);
-        JS_FreeCString (ctx, cstr);
-      }
-    }
-
-    if (string_data.error) goto fail;
-
-    mod->string_data_size = string_data.size;
-    mod->string_data = string_data.buf;
-    string_data.buf = NULL;  /* Transfer ownership */
-  }
-
-  /* Step 5: Create units */
-  mod->unit_count = fc.count;
-  mod->units = pjs_mallocz (fc.count * sizeof (CellUnit));
-  if (!mod->units) goto fail;
-
-  for (i = 0; i < fc.count; i++) {
-    JSFunctionBytecode *b = fc.funcs[i];
-    CellUnit *cu = &mod->units[i];
-
-    /* Function name */
-    if (JS_IsText (b->func_name)) {
-      cu->name_sid = find_string_id (&stb, b->func_name);
-    } else {
-      cu->name_sid = UINT32_MAX;
-    }
-
-    /* Stack requirements */
-    cu->arg_count = b->arg_count;
-    cu->var_count = b->var_count;
-    cu->stack_size = b->stack_size;
-
-    /* Copy bytecode */
-    cu->bytecode_len = b->byte_code_len;
-    if (b->byte_code_len > 0) {
-      cu->bytecode = pjs_malloc (b->byte_code_len);
-      if (!cu->bytecode) goto fail;
-      memcpy (cu->bytecode, b->byte_code_buf, b->byte_code_len);
-    }
-
-    /* Build constants */
-    cu->const_count = b->cpool_count;
-    if (b->cpool_count > 0) {
-      cu->constants = pjs_mallocz (b->cpool_count * sizeof (CellConst));
-      if (!cu->constants) goto fail;
-
-      for (j = 0; j < (uint32_t)b->cpool_count; j++) {
-        JSValue v = b->cpool[j];
-        CellConst *cc = &cu->constants[j];
-
-        if (JS_IsNull (v)) {
-          cc->type = CELL_CONST_NULL;
-        } else if (JS_VALUE_GET_TAG (v) == JS_TAG_INT) {
-          cc->type = CELL_CONST_INT;
-          cc->i32 = JS_VALUE_GET_INT (v);
-        } else if (JS_VALUE_GET_TAG (v) == JS_TAG_FLOAT64) {
-          cc->type = CELL_CONST_FLOAT;
-          cc->f64 = JS_VALUE_GET_FLOAT64 (v);
-        } else if (JS_IsText (v)) {
-          cc->type = CELL_CONST_STRING;
-          cc->string_sid = find_string_id (&stb, v);
-        } else if (JS_VALUE_GET_TAG (v) == JS_TAG_PTR) {
-          void *ptr = JS_VALUE_GET_PTR (v);
-          objhdr_t hdr = *(objhdr_t *)ptr;
-          if (objhdr_type (hdr) == OBJ_CODE) {
-            /* Nested function reference */
-            cc->type = CELL_CONST_UNIT;
-            cc->unit_id = find_unit_id (&fc, (JSFunctionBytecode *)ptr);
-          } else {
-            cc->type = CELL_CONST_NULL;
-          }
-        } else {
-          cc->type = CELL_CONST_NULL;
-        }
-      }
-    }
-
-    /* Build upvalue descriptors from closure_var */
-    cu->upvalue_count = b->closure_var_count;
-    if (b->closure_var_count > 0 && b->closure_var) {
-      cu->upvalues = pjs_malloc (b->closure_var_count * sizeof (CellCapDesc));
-      if (!cu->upvalues) goto fail;
-
-      for (j = 0; j < (uint32_t)b->closure_var_count; j++) {
-        JSClosureVar *cv = &b->closure_var[j];
-        cu->upvalues[j].kind = cv->is_local ? CAP_FROM_PARENT_LOCAL : CAP_FROM_PARENT_UPVALUE;
-        cu->upvalues[j].index = cv->var_idx;
-      }
-    }
-
-    /* Scan bytecode for external relocations (OP_get_var, OP_put_var, etc.) */
-    {
-      DynBuf relocs;
-      dbuf_init (&relocs);
-
-      uint8_t *bc = cu->bytecode;
-      int pos = 0;
-      while (pos < (int)cu->bytecode_len) {
-        uint8_t op = bc[pos];
-        int len = short_opcode_info (op).size;
-
-        if (op == OP_get_var || op == OP_get_var_undef) {
-          CellExternalReloc rel;
-          rel.pc_offset = pos;
-          uint32_t cpool_idx = get_u32 (bc + pos + 1);
-          if (cpool_idx < (uint32_t)b->cpool_count && JS_IsText (b->cpool[cpool_idx])) {
-            rel.name_sid = find_string_id (&stb, b->cpool[cpool_idx]);
-          } else {
-            rel.name_sid = UINT32_MAX;
-          }
-          rel.kind = EXT_GET;
-          dbuf_put (&relocs, (uint8_t *)&rel, sizeof (rel));
-        } else if (op == OP_put_var || op == OP_put_var_init || op == OP_put_var_strict) {
-          CellExternalReloc rel;
-          rel.pc_offset = pos;
-          uint32_t cpool_idx = get_u32 (bc + pos + 1);
-          if (cpool_idx < (uint32_t)b->cpool_count && JS_IsText (b->cpool[cpool_idx])) {
-            rel.name_sid = find_string_id (&stb, b->cpool[cpool_idx]);
-          } else {
-            rel.name_sid = UINT32_MAX;
-          }
-          rel.kind = EXT_SET;
-          dbuf_put (&relocs, (uint8_t *)&rel, sizeof (rel));
-        }
-
-        pos += len;
-      }
-
-      if (relocs.size > 0 && !relocs.error) {
-        cu->external_count = relocs.size / sizeof (CellExternalReloc);
-        cu->externals = (CellExternalReloc *)relocs.buf;
-        relocs.buf = NULL;  /* Transfer ownership */
-      }
-      dbuf_free (&relocs);
-    }
-
-    /* Copy debug info */
-    if (b->has_debug) {
-      cu->pc2line_len = b->debug.pc2line_len;
-      if (b->debug.pc2line_len > 0 && b->debug.pc2line_buf) {
-        cu->pc2line = pjs_malloc (b->debug.pc2line_len);
-        if (!cu->pc2line) goto fail;
-        memcpy (cu->pc2line, b->debug.pc2line_buf, b->debug.pc2line_len);
-      }
-    }
-  }
-
-  /* Step 6: Copy source from main function */
-  if (main_func->has_debug && main_func->debug.source_len > 0 && main_func->debug.source) {
-    mod->source_len = main_func->debug.source_len;
-    mod->source = pjs_malloc (mod->source_len + 1);
-    if (!mod->source) goto fail;
-    memcpy (mod->source, main_func->debug.source, mod->source_len);
-    mod->source[mod->source_len] = '\0';
-  }
-
-  /* Success */
-  stb_free (&stb);
-  fc_free (&fc);
-  dbuf_free (&string_data);
-  return mod;
-
-fail:
-  stb_free (&stb);
-  fc_free (&fc);
-  dbuf_free (&string_data);
-  if (mod) cell_module_free (mod);
-  return NULL;
-}
-
-/* Compile source code directly to CellModule (context-neutral format).
-   This is a convenience function that combines JS_Compile + cell_module_from_bytecode.
-
-   Parameters:
-   - ctx: context for compilation
-   - input: source code (must be null-terminated)
-   - input_len: length of source code
-   - filename: source filename for debug info
-
-   Returns: allocated CellModule (caller must free with cell_module_free), or NULL on error.
-*/
-CellModule *JS_CompileModule (JSContext *ctx, const char *input, size_t input_len, const char *filename) {
-  JSValue bytecode = JS_Compile (ctx, input, input_len, filename);
-  if (JS_IsException (bytecode)) {
-    return NULL;
-  }
-
-  JSFunctionBytecode *b = JS_VALUE_GET_PTR (bytecode);
-  CellModule *mod = cell_module_from_bytecode (ctx, b);
-
-  /* Note: bytecode is not freed here - it's still valid and could be used
-     with JS_Integrate if desired. Caller can free it if not needed. */
-
-  return mod;
-}
-/* JSON */
-
-static int json_parse_expect (JSParseState *s, int tok) {
-  if (s->token.val != tok) {
-    /* XXX: dump token correctly in all cases */
-    return js_parse_error (s, "expecting '%c'", tok);
-  }
-  return json_next_token (s);
-}
-
-static JSValue json_parse_value (JSParseState *s) {
-  JSContext *ctx = s->ctx;
-  JSValue val = JS_NULL;
-  int ret;
-
-  switch (s->token.val) {
-  case '{': {
-    JSValue prop_val;
-    JSValue prop_name;
-    JSGCRef val_ref, tok_ref;
-
-    JS_PushGCRef (ctx, &val_ref);
-    JS_PushGCRef (ctx, &tok_ref);
-
-    if (json_next_token (s)) {
-      JS_PopGCRef (ctx, &tok_ref);
-      JS_PopGCRef (ctx, &val_ref);
-      goto fail;
-    }
-    tok_ref.val = s->token.u.str.str; /* Root the token string before GC */
-
-    val_ref.val = JS_NewObject (ctx);
-    if (JS_IsException (val_ref.val)) {
-      JS_PopGCRef (ctx, &tok_ref);
-      JS_PopGCRef (ctx, &val_ref);
-      goto fail;
-    }
-    if (s->token.val != '}') {
-      for (;;) {
-        if (s->token.val == TOK_STRING) {
-          prop_name = js_key_from_string (ctx, tok_ref.val); /* Use rooted token */
-          if (JS_IsNull (prop_name)) {
-            JS_PopGCRef (ctx, &tok_ref);
-            JS_PopGCRef (ctx, &val_ref);
-            goto fail;
-          }
-        } else if (s->ext_json && s->token.val == TOK_IDENT) {
-          prop_name = tok_ref.val; /* Use rooted ident */
-        } else {
-          js_parse_error (s, "expecting property name");
-          JS_PopGCRef (ctx, &tok_ref);
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        if (json_next_token (s)) {
-          JS_PopGCRef (ctx, &tok_ref);
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        if (json_parse_expect (s, ':')) {
-          JS_PopGCRef (ctx, &tok_ref);
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        prop_val = json_parse_value (s);
-        if (JS_IsException (prop_val)) {
-          JS_PopGCRef (ctx, &tok_ref);
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        ret = JS_SetPropertyInternal (ctx, val_ref.val, prop_name, prop_val);
-        if (ret < 0) {
-          JS_PopGCRef (ctx, &tok_ref);
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-
-        if (s->token.val != ',') break;
-        if (json_next_token (s)) {
-          JS_PopGCRef (ctx, &tok_ref);
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        tok_ref.val = s->token.u.str.str; /* Root the new key token */
-        if (s->ext_json && s->token.val == '}') break;
-      }
-    }
-    if (json_parse_expect (s, '}')) {
-      JS_PopGCRef (ctx, &tok_ref);
-      JS_PopGCRef (ctx, &val_ref);
-      goto fail;
-    }
-    val = val_ref.val;
-    JS_PopGCRef (ctx, &tok_ref);
-    JS_PopGCRef (ctx, &val_ref);
-  } break;
-  case '[': {
-    JSValue el;
-    uint32_t idx;
-    JSGCRef val_ref;
-
-    JS_PushGCRef (ctx, &val_ref);
-
-    if (json_next_token (s)) {
-      JS_PopGCRef (ctx, &val_ref);
-      goto fail;
-    }
-    val_ref.val = JS_NewArray (ctx);
-    if (JS_IsException (val_ref.val)) {
-      JS_PopGCRef (ctx, &val_ref);
-      goto fail;
-    }
-    if (s->token.val != ']') {
-      idx = 0;
-      for (;;) {
-        el = json_parse_value (s);
-        if (JS_IsException (el)) {
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        ret = JS_SetPropertyUint32 (ctx, val_ref.val, idx, el);
-        if (ret < 0) {
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        if (s->token.val != ',') break;
-        if (json_next_token (s)) {
-          JS_PopGCRef (ctx, &val_ref);
-          goto fail;
-        }
-        idx++;
-        if (s->ext_json && s->token.val == ']') break;
-      }
-    }
-    if (json_parse_expect (s, ']')) {
-      JS_PopGCRef (ctx, &val_ref);
-      goto fail;
-    }
-    val = val_ref.val;
-    JS_PopGCRef (ctx, &val_ref);
-  } break;
-  case TOK_STRING: {
-    JSGCRef val_ref;
-    JS_PushGCRef (ctx, &val_ref);
-    val_ref.val = s->token.u.str.str;
-    if (json_next_token (s)) {
-      JS_PopGCRef (ctx, &val_ref);
-      goto fail;
-    }
-    val = val_ref.val;
-    JS_PopGCRef (ctx, &val_ref);
-  } break;
-  case TOK_NUMBER:
-    val = s->token.u.num.val;
-    if (json_next_token (s)) goto fail;
-    break;
-  case TOK_IDENT:
-    if (js_key_equal (s->token.u.ident.str, JS_KEY_false)
-        || js_key_equal (s->token.u.ident.str, JS_KEY_true)) {
-      val = JS_NewBool (ctx, js_key_equal (s->token.u.ident.str, JS_KEY_true));
-    } else if (js_key_equal (s->token.u.ident.str, JS_KEY_null)) {
-      val = JS_NULL;
-    } else if (js_key_equal_str (s->token.u.ident.str, "NaN") && s->ext_json) {
-      /* Note: json5 identifier handling is ambiguous e.g. is
-         '{ NaN: 1 }' a valid JSON5 production ? */
-      val = JS_NewFloat64 (s->ctx, NAN);
-    } else if (js_key_equal_str (s->token.u.ident.str, "Infinity")
-               && s->ext_json) {
-      val = JS_NewFloat64 (s->ctx, INFINITY);
-    } else {
-      goto def_token;
-    }
-    if (json_next_token (s)) goto fail;
-    break;
-  default:
-  def_token:
-    if (s->token.val == TOK_EOF) {
-      js_parse_error (s, "Unexpected end of JSON input");
-    } else {
-      js_parse_error (s, "unexpected token: '%.*s'", (int)(s->buf_ptr - s->token.ptr), s->token.ptr);
-    }
-    goto fail;
-  }
-  return val;
-fail:
-  return JS_EXCEPTION;
-}
-
-JSValue JS_ParseJSON2 (JSContext *ctx, const char *buf, size_t buf_len, const char *filename, int flags) {
-  JSParseState s1, *s = &s1;
-  JSValue val = JS_NULL;
-
-  js_parse_init (ctx, s, buf, buf_len, filename);
-  s->ext_json = ((flags & JS_PARSE_JSON_EXT) != 0);
-  if (json_next_token (s)) goto fail;
-  val = json_parse_value (s);
-  if (JS_IsException (val)) goto fail;
-  if (s->token.val != TOK_EOF) {
-    if (js_parse_error (s, "unexpected data at the end")) goto fail;
-  }
-  return val;
-fail:
-  free_token (s, &s->token);
-  return JS_EXCEPTION;
-}
-
-JSValue JS_ParseJSON (JSContext *ctx, const char *buf, size_t buf_len, const char *filename) {
-  return JS_ParseJSON2 (ctx, buf, buf_len, filename, 0);
-}
diff --git a/source/mach.c b/source/mach.c
index 52e2cf26..689a047e 100644
--- a/source/mach.c
+++ b/source/mach.c
@@ -2919,7 +2919,8 @@ JSValue JS_CallRegisterVM(JSContext *ctx, JSCodeRegister *code,
           break;
         }
         if (JS_IsNull(frame->caller)) {
-          result = JS_Throw(ctx, JS_NewString(ctx, "unhandled disruption"));
+          fprintf(stderr, "unhandled disruption\n");
+          result = JS_Throw(ctx, JS_NULL);
           frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
           goto done;
         }
diff --git a/source/mcode.c b/source/mcode.c
index 2e55b473..e5d4e1a1 100644
--- a/source/mcode.c
+++ b/source/mcode.c
@@ -3393,7 +3393,8 @@ JSValue mcode_exec(JSContext *ctx, JSMCode *code, JSValue this_obj,
           break;
         }
         if (JS_IsNull(frame->caller)) {
-          result = JS_Throw(ctx, JS_NewString(ctx, "unhandled disruption"));
+          fprintf(stderr, "unhandled disruption\n");
+          result = JS_Throw(ctx, JS_NULL);
           frame = (JSFrameRegister *)JS_VALUE_GET_PTR(frame_ref.val);
           goto done;
         }
diff --git a/source/quickjs-internal.h b/source/quickjs-internal.h
index 54f70090..f2a928fb 100644
--- a/source/quickjs-internal.h
+++ b/source/quickjs-internal.h
@@ -274,8 +274,7 @@ static JSValue JS_Invoke (JSContext *ctx, JSValue this_val, JSValue method, int
 enum {
   /* classid tag        */ /* union usage   | properties */
   JS_CLASS_OBJECT = 1,     /* must be first */
-  JS_CLASS_ERROR,
-  JS_CLASS_REGEXP,         /* u.regexp */
+  JS_CLASS_REGEXP = 3,     /* u.regexp */
   JS_CLASS_BLOB,           /* u.opaque (blob *) */
 
   JS_CLASS_INIT_COUNT, /* last entry for predefined classes */
@@ -291,7 +290,7 @@ typedef enum JSErrorEnum {
   JS_INTERNAL_ERROR,
   JS_AGGREGATE_ERROR,
 
-  JS_NATIVE_ERROR_COUNT, /* number of different NativeError objects */
+  JS_NATIVE_ERROR_COUNT, /* number of different error name strings */
 } JSErrorEnum;
 
 /* the variable and scope indexes must fit on 16 bits. The (-1) and
@@ -941,7 +940,6 @@ struct JSContext {
   JSClass *class_array;
   JSValue *class_proto;
   JSValue regexp_ctor;
-  JSValue native_error_proto[JS_NATIVE_ERROR_COUNT];
   JSValue throw_type_error;
 
   JSValue global_obj;     /* global object (immutable intrinsics) */
@@ -1439,7 +1437,7 @@ static JSValue js_cell_text_format (JSContext *ctx, JSValue this_val, int argc,
 static JSValue js_print (JSContext *ctx, JSValue this_val, int argc, JSValue *argv);
 cJSON *JS_GetStack(JSContext *ctx);
 JSValue JS_ThrowOutOfMemory (JSContext *ctx);
-JSValue JS_EvalInternal (JSContext *ctx, JSValue this_obj, const char *input, size_t input_len, const char *filename, int flags, int scope_idx);
+
 
 JSValue JS_ToNumber (JSContext *ctx, JSValue val);
 int JS_SetPropertyValue (JSContext *ctx, JSValue this_obj, JSValue prop, JSValue val);
@@ -1454,7 +1452,6 @@ void free_arg_list (JSContext *ctx, JSValue *tab, uint32_t len);
 JSValue *build_arg_list (JSContext *ctx, uint32_t *plen, JSValue *parray_arg);
 JSValue js_regexp_toString (JSContext *ctx, JSValue this_val, int argc, JSValue *argv);
 
-JSValue js_error_toString (JSContext *ctx, JSValue this_val, int argc, JSValue *argv);
 
 
 /* === Inline utility functions (used across modules) === */
@@ -1694,43 +1691,6 @@ typedef struct {
   const uint8_t *buf_start;
 } GetLineColCache;
 
-/* === JSOpCode (needed by debugger in runtime.c and bytecode in cell_js.c) === */
-typedef struct JSOpCode {
-#ifdef DUMP_BYTECODE
-  const char *name;
-#endif
-  uint8_t size; /* in bytes */
-  /* the opcodes remove n_pop items from the top of the stack, then
-     pushes n_push items */
-  uint8_t n_pop;
-  uint8_t n_push;
-  uint8_t fmt;
-} JSOpCode;
-
-static const JSOpCode opcode_info[OP_COUNT + (OP_TEMP_END - OP_TEMP_START)] = {
-#define FMT(f)
-#ifdef DUMP_BYTECODE
-#define DEF(id, size, n_pop, n_push, f) \
-  { #id, size, n_pop, n_push, OP_FMT_##f },
-#else
-#define DEF(id, size, n_pop, n_push, f) { size, n_pop, n_push, OP_FMT_##f },
-#endif
-#include "quickjs-opcode.h"
-#undef DEF
-#undef FMT
-};
-
-#if SHORT_OPCODES
-/* After the final compilation pass, short opcodes are used. Their
-   opcodes overlap with the temporary opcodes which cannot appear in
-   the final bytecode. Their description is after the temporary
-   opcodes in opcode_info[]. */
-#define short_opcode_info(op)                                              \
-  opcode_info[(op) >= OP_TEMP_START ? (op) + (OP_TEMP_END - OP_TEMP_START) \
-                                    : (op)]
-#else
-#define short_opcode_info(op) opcode_info[op]
-#endif
 
 /* === MachVarInfo (shared by mach.c and mcode.c) === */
 typedef struct MachVarInfo {
@@ -1792,11 +1752,7 @@ extern JSClassID js_class_id_alloc;
 
 /* === Forward declarations for functions split across modules === */
 
-/* cell_js.c exports */
-void gc_scan_parser_cpool (JSContext *ctx, uint8_t *from_base, uint8_t *from_end,
-                           uint8_t *to_base, uint8_t **to_free, uint8_t *to_end);
-void gc_scan_bytecode_cpool (JSContext *ctx, JSValue v, uint8_t *from_base, uint8_t *from_end,
-                              uint8_t *to_base, uint8_t **to_free, uint8_t *to_end);
+/* runtime.c — line/column, GC, and VM dispatch */
 int ctx_gc (JSContext *ctx, int allow_grow, size_t alloc_size);
 JSValue JS_CallInternal (JSContext *ctx, JSValue func_obj, JSValue this_obj, int argc, JSValue *argv, int flags);
 int get_line_col (int *pcol_num, const uint8_t *buf, size_t len);
@@ -1806,12 +1762,10 @@ int get_line_col_cached (GetLineColCache *s, int *pcol_num, const uint8_t *ptr);
 JSValue JS_ThrowStackOverflow (JSContext *ctx);
 JSValue JS_ThrowSyntaxErrorVarRedeclaration (JSContext *ctx, JSValue prop);
 JSValue JS_ThrowReferenceErrorUninitialized (JSContext *ctx, JSValue name);
-JSValue JS_ThrowReferenceErrorUninitialized2 (JSContext *ctx, JSFunctionBytecode *b, int idx, BOOL is_ref);
 int JS_DefineObjectName (JSContext *ctx, JSValue obj, JSValue name);
 int JS_DefineObjectNameComputed (JSContext *ctx, JSValue obj, JSValue str);
 int js_method_set_properties (JSContext *ctx, JSValue func_obj, JSValue name, int flags, JSValue home_obj);
 JSValue JS_GetPropertyValue (JSContext *ctx, JSValue this_obj, JSValue prop);
-JSValue js_closure (JSContext *ctx, JSValue bfunc, JSStackFrame *sf);
 __exception int JS_CopyDataProperties (JSContext *ctx, JSValue target, JSValue source, JSValue excluded, BOOL setprop);
 int js_string_compare_value (JSContext *ctx, JSValue op1, JSValue op2, BOOL eq_only);
 int js_string_compare_value_nocase (JSContext *ctx, JSValue op1, JSValue op2);
@@ -1867,8 +1821,7 @@ static inline JSValue *get_upvalue_ptr (JSValue frame_val, int depth, int slot)
   return &frame->slots[slot];
 }
 
-void build_backtrace (JSContext *ctx, JSValue error_obj, const char *filename, int line_num, int col_num, int backtrace_flags);
-BOOL is_backtrace_needed (JSContext *ctx, JSValue obj);
+void print_backtrace (JSContext *ctx, const char *filename, int line_num, int col_num);
 JSValue JS_ThrowError2 (JSContext *ctx, JSErrorEnum error_num, const char *fmt, va_list ap, BOOL add_backtrace);
 JSValue gc_copy_value (JSContext *ctx, JSValue v, uint8_t *from_base, uint8_t *from_end, uint8_t *to_base, uint8_t **to_free, uint8_t *to_end);
 PPretext *ppretext_init (int capacity);
diff --git a/source/quickjs.h b/source/quickjs.h
index d00ce026..7c15407b 100644
--- a/source/quickjs.h
+++ b/source/quickjs.h
@@ -577,11 +577,8 @@ static JS_BOOL JS_IsStone(JSValue v);
 int JS_GetLength (JSContext *ctx, JSValue obj, int64_t *pres);
 
 JSValue JS_Throw (JSContext *ctx, JSValue obj);
-void JS_SetUncatchableException (JSContext *ctx, JS_BOOL flag);
 JSValue JS_GetException (JSContext *ctx);
 JS_BOOL JS_HasException (JSContext *ctx);
-JS_BOOL JS_IsError (JSContext *ctx, JSValue val);
-JSValue JS_NewError (JSContext *ctx);
 JSValue __js_printf_like (2, 3)
   JS_ThrowSyntaxError (JSContext *ctx, const char *fmt, ...);
 JSValue __js_printf_like (2, 3)
@@ -714,16 +711,6 @@ JSValue JS_GetOwnPropertyNames (JSContext *ctx, JSValue obj);
 
 JSValue JS_Call (JSContext *ctx, JSValue func_obj, JSValue this_obj, int argc, JSValue *argv);
 
-/* Compile source code to bytecode without executing.
-   'input' must be zero terminated i.e. input[input_len] = '\0'.
-   Returns unlinked bytecode on success, JS_EXCEPTION on error. */
-JSValue JS_Compile (JSContext *ctx, const char *input, size_t input_len,
-                    const char *filename);
-
-/* Link compiled bytecode with environment and execute.
-   env should be stoned record or null.
-   Variables resolve: env first, then global intrinsics. */
-JSValue JS_Integrate (JSContext *ctx, JSValue bytecode, JSValue env);
 void JS_SetOpaque (JSValue obj, void *opaque);
 void *JS_GetOpaque (JSValue obj, JSClassID class_id);
 void *JS_GetOpaque2 (JSContext *ctx, JSValue obj, JSClassID class_id);
@@ -749,28 +736,6 @@ void JS_SetInterruptHandler (JSContext *ctx, JSInterruptHandler *cb,
 void JS_SetStripInfo (JSRuntime *rt, int flags);
 int JS_GetStripInfo (JSRuntime *rt);
 
-/* Object Writer/Reader (currently only used to handle precompiled code) */
-#define JS_WRITE_OBJ_BYTECODE (1 << 0) /* allow function/module */
-#define JS_WRITE_OBJ_BSWAP (1 << 1)    /* byte swapped output */
-#define JS_WRITE_OBJ_SAB (1 << 2)      /* allow SharedArrayBuffer */
-#define JS_WRITE_OBJ_REFERENCE                                                \
-  (1 << 3) /* allow object references to                                      \
-              encode arbitrary object                                         \
-              graph */
-uint8_t *JS_WriteObject (JSContext *ctx, size_t *psize, JSValue obj,
-                         int flags);
-uint8_t *JS_WriteObject2 (JSContext *ctx, size_t *psize, JSValue obj,
-                          int flags, uint8_t ***psab_tab,
-                          size_t *psab_tab_len);
-
-#define JS_READ_OBJ_BYTECODE (1 << 0)  /* allow function/module */
-#define JS_READ_OBJ_ROM_DATA (1 << 1)  /* avoid duplicating 'buf' data */
-#define JS_READ_OBJ_SAB (1 << 2)       /* allow SharedArrayBuffer */
-#define JS_READ_OBJ_REFERENCE (1 << 3) /* allow object references */
-JSValue JS_ReadObject (JSContext *ctx, const uint8_t *buf, size_t buf_len,
-                       int flags);
-/* Dump bytecode of a compiled function (for debugging) */
-void JS_DumpFunctionBytecode (JSContext *ctx, JSValue func_val);
 
 /* C function definition */
 typedef enum JSCFunctionEnum {
@@ -1100,124 +1065,6 @@ void *js_malloc_rt (size_t size);
 void *js_mallocz_rt (size_t size);
 void js_free_rt (void *ptr);
 
-/* ============================================================================
-   Context-Neutral Module Format (CellModule)
-   ============================================================================ */
-
-/* Capture descriptor - what a nested function closes over */
-typedef enum {
-  CAP_FROM_PARENT_LOCAL = 1,   /* capture local from parent function */
-  CAP_FROM_PARENT_UPVALUE = 2  /* forward upvalue from parent's upvalues */
-} CellCapKind;
-
-typedef struct CellCapDesc {
-  uint8_t kind;    /* CAP_FROM_PARENT_LOCAL or CAP_FROM_PARENT_UPVALUE */
-  uint16_t index;  /* local index in parent, or upvalue index in parent */
-} CellCapDesc;
-
-/* External relocation - for integrate-time patching */
-typedef enum {
-  EXT_GET = 1,  /* OP_get_var -> OP_get_env_slot or OP_get_global_slot */
-  EXT_SET = 2   /* OP_put_var -> OP_set_env_slot or OP_set_global_slot */
-} CellExtKind;
-
-typedef struct CellExternalReloc {
-  uint32_t pc_offset;  /* where operand lives in bytecode */
-  uint32_t name_sid;   /* string id of the external name */
-  uint8_t kind;        /* EXT_GET or EXT_SET */
-} CellExternalReloc;
-
-/* Constant types in cpool */
-typedef enum {
-  CELL_CONST_NULL = 0,
-  CELL_CONST_INT = 1,
-  CELL_CONST_FLOAT = 2,
-  CELL_CONST_STRING = 3,  /* string_sid into module string table */
-  CELL_CONST_UNIT = 4     /* unit_id for nested function */
-} CellConstType;
-
-typedef struct CellConst {
-  uint8_t type;  /* CellConstType */
-  union {
-    int32_t i32;
-    double f64;
-    uint32_t string_sid;
-    uint32_t unit_id;
-  };
-} CellConst;
-
-/* Per-unit structure (context-neutral, flattened) */
-typedef struct CellUnit {
-  /* Constant pool */
-  uint32_t const_count;
-  CellConst *constants;
-
-  /* Bytecode */
-  uint32_t bytecode_len;
-  uint8_t *bytecode;
-
-  /* Stack requirements */
-  uint16_t arg_count;
-  uint16_t var_count;
-  uint16_t stack_size;
-
-  /* Upvalue (capture) descriptors */
-  uint16_t upvalue_count;
-  CellCapDesc *upvalues;
-
-  /* External relocations */
-  uint32_t external_count;
-  CellExternalReloc *externals;
-
-  /* Debug info (optional) */
-  uint32_t pc2line_len;
-  uint8_t *pc2line;
-  uint32_t name_sid;  /* unit name for stack traces */
-} CellUnit;
-
-/* Module-level structure (context-neutral) */
-#define CELL_MODULE_MAGIC 0x4C4C4543  /* "CELL" */
-#define CELL_MODULE_VERSION 1
-
-typedef struct CellModule {
-  uint32_t magic;    /* CELL_MODULE_MAGIC */
-  uint8_t version;   /* CELL_MODULE_VERSION */
-  uint8_t flags;
-
-  /* Shared string table (module-global) */
-  uint32_t string_count;
-  uint32_t string_data_size;
-  uint8_t *string_data;      /* concatenated UTF-8 strings */
-  uint32_t *string_offsets;  /* offset for each string */
-
-  /* Unit table (entry 0 is the main/entry unit) */
-  uint32_t unit_count;
-  CellUnit *units;
-
-  /* Debug: source stored once at module level */
-  uint32_t source_len;
-  char *source;
-} CellModule;
-
-/* Free a CellModule and all its contents */
-void cell_module_free (CellModule *mod);
-
-/* Write a CellModule to a byte buffer.
-   Returns allocated buffer (caller must free with pjs_free), or NULL on error. */
-uint8_t *cell_module_write (CellModule *mod, size_t *out_len);
-
-/* Read a CellModule from a byte buffer.
-   Returns allocated CellModule (caller must free with cell_module_free), or NULL on error. */
-CellModule *cell_module_read (const uint8_t *buf, size_t buf_len);
-
-/* Convert compiled JSFunctionBytecode to CellModule.
-   Returns allocated CellModule (caller must free with cell_module_free), or NULL on error. */
-CellModule *cell_module_from_bytecode (JSContext *ctx, JSFunctionBytecode *main_func);
-
-/* Compile source code directly to CellModule.
-   Returns allocated CellModule (caller must free with cell_module_free), or NULL on error. */
-CellModule *JS_CompileModule (JSContext *ctx, const char *input, size_t input_len, const char *filename);
-
 /* Parse source code and return AST as cJSON tree.
    Caller must call cJSON_Delete() on result. */
 struct cJSON *JS_ASTTree (const char *source, size_t len, const char *filename);
@@ -1280,10 +1127,6 @@ JSValue JS_CallMcode (JSContext *ctx, const char *mcode_json);
    Caller must call cJSON_Delete() on the result. */
 struct cJSON *JS_GetStack (JSContext *ctx);
 
-/* Integrate a CellModule with an environment and execute.
-   Returns callable function value, or JS_EXCEPTION on error. */
-JSValue cell_module_integrate (JSContext *ctx, CellModule *mod, JSValue env);
-
 #undef js_unlikely
 #undef inline
 
diff --git a/source/runtime.c b/source/runtime.c
index 359edebf..e323f1c4 100644
--- a/source/runtime.c
+++ b/source/runtime.c
@@ -910,7 +910,7 @@ JSValue js_key_from_string (JSContext *ctx, JSValue val) {
 }
 
 static JSClass const js_std_class_def[] = {
-  { "error", NULL, NULL },                                            /* JS_CLASS_ERROR */
+  { NULL, NULL, NULL },                                               /* placeholder (was JS_CLASS_ERROR, now unused) */
   { "regexp", js_regexp_finalizer, NULL },                            /* JS_CLASS_REGEXP */
   { "blob", NULL, NULL },                                             /* JS_CLASS_BLOB - registered separately */
 };
@@ -1118,23 +1118,7 @@ void gc_scan_object (JSContext *ctx, void *ptr, uint8_t *from_base, uint8_t *fro
     JSFunction *fn = (JSFunction *)ptr;
     /* Scan the function name */
     fn->name = gc_copy_value (ctx, fn->name, from_base, from_end, to_base, to_free, to_end);
-    /* Scan bytecode's cpool - it contains JSValues that may reference GC objects */
-    if (fn->kind == JS_FUNC_KIND_BYTECODE && fn->u.func.function_bytecode) {
-      JSFunctionBytecode *b = fn->u.func.function_bytecode;
-      /* Scan cpool entries */
-      for (int i = 0; i < b->cpool_count; i++) {
-        b->cpool[i] = gc_copy_value (ctx, b->cpool[i], from_base, from_end, to_base, to_free, to_end);
-      }
-      /* Scan func_name and filename */
-      b->func_name = gc_copy_value (ctx, b->func_name, from_base, from_end, to_base, to_free, to_end);
-      if (b->has_debug) {
-        b->debug.filename = gc_copy_value (ctx, b->debug.filename, from_base, from_end, to_base, to_free, to_end);
-      }
-      /* Scan outer_frame (for closures) - it's already a JSValue */
-      fn->u.func.outer_frame = gc_copy_value (ctx, fn->u.func.outer_frame, from_base, from_end, to_base, to_free, to_end);
-      /* Scan env_record (stone record / module environment) */
-      fn->u.func.env_record = gc_copy_value (ctx, fn->u.func.env_record, from_base, from_end, to_base, to_free, to_end);
-    } else if (fn->kind == JS_FUNC_KIND_REGISTER && fn->u.reg.code) {
+    if (fn->kind == JS_FUNC_KIND_REGISTER && fn->u.reg.code) {
       /* Register VM function - scan cpool (off-heap but contains JSValues) */
       JSCodeRegister *code = fn->u.reg.code;
       for (uint32_t i = 0; i < code->cpool_count; i++) {
@@ -1166,16 +1150,9 @@ void gc_scan_object (JSContext *ctx, void *ptr, uint8_t *from_base, uint8_t *fro
   case OBJ_BLOB:
     /* No internal references to scan */
     break;
-  case OBJ_CODE: {
-    /* JSFunctionBytecode - scan func_name and filename */
-    JSFunctionBytecode *bc = (JSFunctionBytecode *)ptr;
-    bc->func_name = gc_copy_value (ctx, bc->func_name, from_base, from_end, to_base, to_free, to_end);
-    if (bc->has_debug) {
-      bc->debug.filename = gc_copy_value (ctx, bc->debug.filename, from_base, from_end, to_base, to_free, to_end);
-    }
-    /* Note: cpool, vardefs, closure_var, byte_code_buf are allocated via js_malloc */
+  case OBJ_CODE:
+    /* Dead code: old bytecode objects no longer created */
     break;
-  }
   case OBJ_FRAME: {
     /* JSFrame - scan function, caller, and slots */
     JSFrame *frame = (JSFrame *)ptr;
@@ -1196,32 +1173,12 @@ void gc_scan_object (JSContext *ctx, void *ptr, uint8_t *from_base, uint8_t *fro
   }
 }
 
-/* Forward declaration - defined after JSFunctionDef */
+/* gc_scan_parser_cpool - no-op now that the old compiler is removed.
+   current_parse_fd is always NULL without cell_js.c. */
 void gc_scan_parser_cpool (JSContext *ctx, uint8_t *from_base, uint8_t *from_end,
-                                  uint8_t *to_base, uint8_t **to_free, uint8_t *to_end);
-
-/* Scan OBJ_CODE cpool for bytecode objects outside GC heap */
-void gc_scan_bytecode_cpool (JSContext *ctx, JSValue v, uint8_t *from_base, uint8_t *from_end,
-                                    uint8_t *to_base, uint8_t **to_free, uint8_t *to_end) {
-  if (!JS_IsPtr (v)) return;
-  void *ptr = JS_VALUE_GET_PTR (v);
-  if (ptr_in_range (ptr, from_base, from_end)) return; /* On GC heap, handled normally */
-  if (is_stone_ptr (ctx, ptr)) return; /* Stone memory */
-
-  /* Check if this is an OBJ_CODE outside GC heap */
-  objhdr_t hdr = *(objhdr_t *)ptr;
-  if (objhdr_type (hdr) == OBJ_CODE) {
-    JSFunctionBytecode *bc = (JSFunctionBytecode *)ptr;
-    /* Scan cpool entries */
-    for (int i = 0; i < bc->cpool_count; i++) {
-      bc->cpool[i] = gc_copy_value (ctx, bc->cpool[i], from_base, from_end, to_base, to_free, to_end);
-    }
-    /* Scan func_name and filename */
-    bc->func_name = gc_copy_value (ctx, bc->func_name, from_base, from_end, to_base, to_free, to_end);
-    if (bc->has_debug) {
-      bc->debug.filename = gc_copy_value (ctx, bc->debug.filename, from_base, from_end, to_base, to_free, to_end);
-    }
-  }
+                           uint8_t *to_base, uint8_t **to_free, uint8_t *to_end) {
+  (void)ctx; (void)from_base; (void)from_end;
+  (void)to_base; (void)to_free; (void)to_end;
 }
 
 /* Cheney copying GC - collect garbage and compact live objects
@@ -1295,13 +1252,6 @@ int ctx_gc (JSContext *ctx, int allow_grow, size_t alloc_size) {
 #endif
   ctx->current_exception = gc_copy_value (ctx, ctx->current_exception, from_base, from_end, to_base, &to_free, to_end);
 
-#ifdef DUMP_GC_DETAIL
-  printf("  roots: native_error_proto\n"); fflush(stdout);
-#endif
-  for (int i = 0; i < JS_NATIVE_ERROR_COUNT; i++) {
-    ctx->native_error_proto[i] = gc_copy_value (ctx, ctx->native_error_proto[i], from_base, from_end, to_base, &to_free, to_end);
-  }
-
   /* Copy class prototypes */
 #ifdef DUMP_GC_DETAIL
   printf("  roots: class_proto (count=%d)\n", ctx->class_count); fflush(stdout);
@@ -1340,42 +1290,6 @@ int ctx_gc (JSContext *ctx, int allow_grow, size_t alloc_size) {
 #endif
   for (JSStackFrame *sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
     sf->cur_func = gc_copy_value (ctx, sf->cur_func, from_base, from_end, to_base, &to_free, to_end);
-    /* Also scan bytecode cpool if it's a bytecode object outside GC heap */
-    gc_scan_bytecode_cpool (ctx, sf->cur_func, from_base, from_end, to_base, &to_free, to_end);
-    /* Scan arg_buf and var_buf contents - they're on C stack but hold JSValues */
-    if (JS_IsFunction(sf->cur_func)) {
-      JSFunction *fn = JS_VALUE_GET_FUNCTION(sf->cur_func);
-      if (fn->kind == JS_FUNC_KIND_BYTECODE && fn->u.func.function_bytecode) {
-        JSFunctionBytecode *b = fn->u.func.function_bytecode;
-        /* Scan arg_buf */
-        if (sf->arg_buf) {
-          for (int i = 0; i < sf->arg_count; i++) {
-            sf->arg_buf[i] = gc_copy_value(ctx, sf->arg_buf[i], from_base, from_end, to_base, &to_free, to_end);
-          }
-        }
-        /* Scan var_buf */
-        if (sf->var_buf) {
-          for (int i = 0; i < b->var_count; i++) {
-            sf->var_buf[i] = gc_copy_value(ctx, sf->var_buf[i], from_base, from_end, to_base, &to_free, to_end);
-          }
-        }
-        /* Scan js_frame if present - it's on regular heap but contains JSValues pointing to GC heap */
-        sf->js_frame = gc_copy_value(ctx, sf->js_frame, from_base, from_end, to_base, &to_free, to_end);
-        if (!JS_IsNull(sf->js_frame)) {
-          JSFrame *jf = JS_VALUE_GET_FRAME(sf->js_frame);
-          jf->function = gc_copy_value(ctx, jf->function, from_base, from_end, to_base, &to_free, to_end);
-          jf->caller = gc_copy_value(ctx, jf->caller, from_base, from_end, to_base, &to_free, to_end);
-          /* Note: jf->slots are same as arg_buf/var_buf, already scanned above */
-        }
-        /* Scan operand stack */
-        if (sf->stack_buf && sf->p_sp) {
-          JSValue *sp = *sf->p_sp;
-          for (JSValue *p = sf->stack_buf; p < sp; p++) {
-            *p = gc_copy_value(ctx, *p, from_base, from_end, to_base, &to_free, to_end);
-          }
-        }
-      }
-    }
   }
 
   /* Copy JS_PUSH_VALUE/JS_POP_VALUE roots */
@@ -1383,7 +1297,6 @@ int ctx_gc (JSContext *ctx, int allow_grow, size_t alloc_size) {
   printf("  roots: top_gc_ref\n"); fflush(stdout);
 #endif
   for (JSGCRef *ref = ctx->top_gc_ref; ref != NULL; ref = ref->prev) {
-    gc_scan_bytecode_cpool (ctx, ref->val, from_base, from_end, to_base, &to_free, to_end);
     ref->val = gc_copy_value (ctx, ref->val, from_base, from_end, to_base, &to_free, to_end);
   }
 
@@ -1392,7 +1305,6 @@ int ctx_gc (JSContext *ctx, int allow_grow, size_t alloc_size) {
   printf("  roots: last_gc_ref\n"); fflush(stdout);
 #endif
   for (JSGCRef *ref = ctx->last_gc_ref; ref != NULL; ref = ref->prev) {
-    gc_scan_bytecode_cpool (ctx, ref->val, from_base, from_end, to_base, &to_free, to_end);
     ref->val = gc_copy_value (ctx, ref->val, from_base, from_end, to_base, &to_free, to_end);
   }
 
@@ -2691,6 +2603,60 @@ JS_HasException (JSContext *ctx) {
 }
 
 
+/* Relocated from cell_js.c — used by tokenize.c via ast_get_line_col */
+int get_line_col (int *pcol_num, const uint8_t *buf, size_t len) {
+  int line_num, col_num, c;
+  size_t i;
+
+  line_num = 0;
+  col_num = 0;
+  for (i = 0; i < len; i++) {
+    c = buf[i];
+    if (c == '\n') {
+      line_num++;
+      col_num = 0;
+    } else if (c < 0x80 || c >= 0xc0) {
+      col_num++;
+    }
+  }
+  *pcol_num = col_num;
+  return line_num;
+}
+
+int get_line_col_cached (GetLineColCache *s, int *pcol_num, const uint8_t *ptr) {
+  int line_num, col_num;
+  if (ptr >= s->ptr) {
+    line_num = get_line_col (&col_num, s->ptr, ptr - s->ptr);
+    if (line_num == 0) {
+      s->col_num += col_num;
+    } else {
+      s->line_num += line_num;
+      s->col_num = col_num;
+    }
+  } else {
+    line_num = get_line_col (&col_num, ptr, s->ptr - ptr);
+    if (line_num == 0) {
+      s->col_num -= col_num;
+    } else {
+      const uint8_t *p;
+      s->line_num -= line_num;
+      /* find the absolute column position */
+      col_num = 0;
+      for (p = ptr - 1; p >= s->buf_start; p--) {
+        if (*p == '\n') {
+          break;
+        } else if (*p < 0x80 || *p >= 0xc0) {
+          col_num++;
+        }
+      }
+      s->col_num = col_num;
+    }
+  }
+  s->ptr = ptr;
+  *pcol_num = s->col_num;
+  return s->line_num;
+}
+
 /* use pc_value = -1 to get the position of the function definition */
 static int find_line_num (JSContext *ctx, JSFunctionBytecode *b, uint32_t pc_value, int *pcol_num) {
   const uint8_t *p_end, *p;
@@ -2769,144 +2735,70 @@ static const char *get_func_name (JSContext *ctx, JSValue func) {
   return JS_ToCString (ctx, val);
 }
 
-#define JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL (1 << 0)
+static const char *const native_error_name[JS_NATIVE_ERROR_COUNT] = {
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "InternalError",
+  "AggregateError",
+};
 
-/* if filename != NULL, an additional level is added with the filename
-   and line number information (used for parse error). */
-void build_backtrace (JSContext *ctx, JSValue error_obj, const char *filename, int line_num, int col_num, int backtrace_flags) {
-  JSStackFrame *sf;
-  JSValue str;
-  DynBuf dbuf;
-  const char *func_name_str;
-  const char *str1;
-  JSGCRef err_ref;
-
-  if (!JS_IsObject (error_obj))
-    return; /* protection in the out of memory case */
-
-  /* Protect error_obj from GC during backtrace building */
-  JS_PushGCRef (ctx, &err_ref);
-  err_ref.val = error_obj;
-
-  js_dbuf_init (ctx, &dbuf);
+/* Print backtrace to stderr. Walks the register VM frame chain via
+   ctx->reg_current_frame, then falls back to the C stack frame chain. */
+void print_backtrace (JSContext *ctx, const char *filename, int line_num, int col_num) {
   if (filename) {
-    dbuf_printf (&dbuf, "    at %s", filename);
-    if (line_num != -1) dbuf_printf (&dbuf, ":%d:%d", line_num, col_num);
-    dbuf_putc (&dbuf, '\n');
-    /* Use short immediate strings for keys to avoid GC issues */
-    JSValue key_fileName = MIST_TryNewImmediateASCII ("file", 4);
-    JSValue key_lineNumber = MIST_TryNewImmediateASCII ("line", 4);
-    JSValue key_columnNumber = MIST_TryNewImmediateASCII ("col", 3);
-    str = JS_NewString (ctx, filename);
-    if (JS_IsException (str)) {
-      JS_PopGCRef (ctx, &err_ref);
-      return;
-    }
-    if (JS_SetPropertyInternal (ctx, err_ref.val, key_fileName, str) < 0
-        || JS_SetPropertyInternal (ctx, err_ref.val, key_lineNumber, JS_NewInt32 (ctx, line_num))
-             < 0
-        || JS_SetPropertyInternal (ctx, err_ref.val, key_columnNumber, JS_NewInt32 (ctx, col_num))
-             < 0) {
-      JS_PopGCRef (ctx, &err_ref);
-      return;
-    }
+    fprintf (stderr, "    at %s", filename);
+    if (line_num != -1) fprintf (stderr, ":%d:%d", line_num, col_num);
+    fputc ('\n', stderr);
   }
-  for (sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
-    if (sf->js_mode & JS_MODE_BACKTRACE_BARRIER) break;
-    if (backtrace_flags & JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL) {
-      backtrace_flags &= ~JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL;
-      continue;
-    }
-    func_name_str = get_func_name (ctx, sf->cur_func);
-    if (!func_name_str || func_name_str[0] == '\0')
-      str1 = "<anonymous>";
-    else
-      str1 = func_name_str;
-    dbuf_printf (&dbuf, "    at %s", str1);
-    JS_FreeCString (ctx, func_name_str);
 
-    if (JS_IsFunction (sf->cur_func)) {
-      JSFunction *fn = JS_VALUE_GET_FUNCTION (sf->cur_func);
-      if (fn->kind == JS_FUNC_KIND_BYTECODE) {
-        JSFunctionBytecode *b;
-        const char *atom_str;
-        int line_num1, col_num1;
-
-        b = fn->u.func.function_bytecode;
-        if (b->has_debug) {
-          line_num1 = find_line_num (ctx, b, sf->cur_pc - b->byte_code_buf - 1, &col_num1);
-          atom_str = JS_ToCString (ctx, b->debug.filename);
-          dbuf_printf (&dbuf, " (%s", atom_str ? atom_str : "<null>");
-          JS_FreeCString (ctx, atom_str);
-          if (line_num1 != 0)
-            dbuf_printf (&dbuf, ":%d:%d", line_num1, col_num1);
-          dbuf_putc (&dbuf, ')');
-        }
-      } else {
-        dbuf_printf (&dbuf, " (native)");
+  /* Walk register VM frame chain (mach / mcode) */
+  if (!JS_IsNull (ctx->reg_current_frame)) {
+    cJSON *stack = JS_GetStack (ctx);
+    if (stack) {
+      int n = cJSON_GetArraySize (stack);
+      for (int i = 0; i < n; i++) {
+        cJSON *fr = cJSON_GetArrayItem (stack, i);
+        const char *fn = cJSON_GetStringValue (cJSON_GetObjectItem (fr, "function"));
+        const char *file = cJSON_GetStringValue (cJSON_GetObjectItem (fr, "file"));
+        int ln = (int)cJSON_GetNumberValue (cJSON_GetObjectItem (fr, "line"));
+        int cn = (int)cJSON_GetNumberValue (cJSON_GetObjectItem (fr, "column"));
+        fprintf (stderr, "    at %s (%s:%d:%d)\n",
+                 fn ? fn : "<anonymous>", file ? file : "<unknown>", ln, cn);
       }
-    } else {
-      dbuf_printf (&dbuf, " (native)");
+      cJSON_Delete (stack);
     }
-    dbuf_putc (&dbuf, '\n');
+    return;
+  }
+
+  /* Fallback: walk C stack frame chain (old bytecode VM) */
+  for (JSStackFrame *sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
+    if (sf->js_mode & JS_MODE_BACKTRACE_BARRIER) break;
+    const char *func_name_str = get_func_name (ctx, sf->cur_func);
+    const char *str1 = (func_name_str && func_name_str[0] != '\0')
+                        ? func_name_str : "<anonymous>";
+    fprintf (stderr, "    at %s (native)\n", str1);
+    JS_FreeCString (ctx, func_name_str);
   }
-  dbuf_putc (&dbuf, '\0');
-  if (dbuf_error (&dbuf))
-    str = JS_NULL;
-  else
-    str = JS_NewString (ctx, (char *)dbuf.buf);
-  dbuf_free (&dbuf);
-  JS_SetPropertyInternal (ctx, err_ref.val, JS_KEY_stack, str);
-  JS_PopGCRef (ctx, &err_ref);
-}
-
-/* Note: it is important that no exception is returned by this function */
-BOOL is_backtrace_needed (JSContext *ctx, JSValue obj) {
-  JSRecord *p;
-  if (!JS_IsRecord (obj)) return FALSE;
-  p = JS_VALUE_GET_OBJ (obj);
-  if (REC_GET_CLASS_ID(p) != JS_CLASS_ERROR) return FALSE;
-  /* Check if "stack" property already exists */
-  JSValue stack_key = MIST_TryNewImmediateASCII ("stack", 5);
-  JSRecord *rec = (JSRecord *)p;
-  int slot = rec_find_slot (rec, stack_key);
-  if (slot > 0) return FALSE;
-  return TRUE;
-}
-
-JSValue JS_NewError (JSContext *ctx) {
-  return JS_NewObjectClass (ctx, JS_CLASS_ERROR);
 }
 
+/* Print error message + backtrace to stderr, then set exception flag.
+   No Error object is created — just print and flag. */
 JSValue JS_ThrowError2 (JSContext *ctx, JSErrorEnum error_num, const char *fmt, va_list ap, BOOL add_backtrace) {
   char buf[256];
-  JSValue ret;
-  JSGCRef obj_ref;
-
   vsnprintf (buf, sizeof (buf), fmt, ap);
-  JS_PushGCRef (ctx, &obj_ref);
-  obj_ref.val = JS_NewObjectProtoClass (ctx, ctx->native_error_proto[error_num], JS_CLASS_ERROR);
-  if (unlikely (JS_IsException (obj_ref.val))) {
-    /* out of memory: throw JS_NULL to avoid recursing */
-    obj_ref.val = JS_NULL;
-  } else {
-    JSValue msg = JS_NewString (ctx, buf);
-    JS_SetPropertyInternal (ctx, obj_ref.val, JS_KEY_message, msg);
-    if (add_backtrace) { build_backtrace (ctx, obj_ref.val, NULL, 0, 0, 0); }
+  fprintf (stderr, "%s: %s\n", native_error_name[error_num], buf);
+  if (add_backtrace) {
+    print_backtrace (ctx, NULL, 0, 0);
   }
-  ret = JS_Throw (ctx, obj_ref.val);
-  JS_PopGCRef (ctx, &obj_ref);
-  return ret;
+  return JS_Throw (ctx, JS_NULL);
 }
 
 static JSValue JS_ThrowError (JSContext *ctx, JSErrorEnum error_num, const char *fmt, va_list ap) {
-  JSStackFrame *sf;
-  BOOL add_backtrace;
-
-  /* the backtrace is added later if called from a bytecode function */
-  sf = ctx->current_stack_frame;
-  add_backtrace = (!sf || (JS_GetFunctionBytecode (sf->cur_func) == NULL));
-  return JS_ThrowError2 (ctx, error_num, fmt, ap, add_backtrace);
+  return JS_ThrowError2 (ctx, error_num, fmt, ap, TRUE);
 }
 
 JSValue __attribute__ ((format (printf, 2, 3)))
@@ -2985,19 +2877,6 @@ JSValue JS_ThrowReferenceErrorUninitialized (JSContext *ctx,
     ctx, "%s is not initialized", JS_IsNull (name) ? "lexical variable" : JS_KeyGetStr (ctx, buf, sizeof (buf), name));
 }
 
-JSValue JS_ThrowReferenceErrorUninitialized2 (JSContext *ctx,
-                                                     JSFunctionBytecode *b,
-                                                     int idx,
-                                                     BOOL is_ref) {
-  JSValue name = JS_NULL;
-  if (is_ref) {
-    name = b->closure_var[idx].var_name;
-  } else {
-    /* not present if the function is stripped and contains no eval() */
-    if (b->vardefs) name = b->vardefs[b->arg_count + idx].var_name;
-  }
-  return JS_ThrowReferenceErrorUninitialized (ctx, name);
-}
 
 static JSValue JS_ThrowTypeErrorInvalidClass (JSContext *ctx, int class_id) {
   const char *name = ctx->class_array[class_id].class_name;
@@ -3006,7 +2885,6 @@ static JSValue JS_ThrowTypeErrorInvalidClass (JSContext *ctx, int class_id) {
 
 void JS_ThrowInterrupted (JSContext *ctx) {
   JS_ThrowInternalError (ctx, "interrupted");
-  JS_SetUncatchableException (ctx, TRUE);
 }
 
 
@@ -3554,19 +3432,6 @@ BOOL JS_IsCFunction (JSValue val, JSCFunction *func, int magic) {
     return FALSE;
 }
 
-BOOL JS_IsError (JSContext *ctx, JSValue val) {
-  JSRecord *p;
-  if (JS_VALUE_GET_TAG (val) != JS_TAG_PTR) return FALSE;
-  p = JS_VALUE_GET_OBJ (val);
-  return (REC_GET_CLASS_ID(p) == JS_CLASS_ERROR);
-}
-
-/* must be called after JS_Throw() - stubbed out, uncatchable not implemented */
-void JS_SetUncatchableException (JSContext *ctx, JS_BOOL flag) {
-  (void)ctx; (void)flag;
-  /* uncatchable exception flag not supported with copying GC */
-}
-
 void JS_SetOpaque (JSValue obj, void *opaque) {
   JSRecord *p;
   if (JS_VALUE_GET_TAG (obj) == JS_TAG_PTR) {
@@ -4882,51 +4747,6 @@ exception:
   return -1;
 }
 
-JSValue js_closure2 (JSContext *ctx, JSValue func_obj, JSFunctionBytecode *b, JSStackFrame *sf) {
-  JSFunction *f;
-  f = JS_VALUE_GET_FUNCTION (func_obj);
-  f->u.func.function_bytecode = b;
-
-  /* Set outer_frame to parent's JSFrame for the new closure model.
-     This allows OP_get_up/OP_set_up to access captured variables via frame chain. */
-  f->u.func.outer_frame = sf ? sf->js_frame : JS_NULL;
-
-  return func_obj;
-}
-
-JSValue js_closure (JSContext *ctx, JSValue bfunc, JSStackFrame *sf) {
-  JSFunctionBytecode *b;
-  JSValue func_obj;
-  JSFunction *f;
-  JSGCRef bfunc_ref;
-
-  /* Protect bfunc from GC during function allocation */
-  JS_PUSH_VALUE (ctx, bfunc);
-
-  func_obj = js_new_function (ctx, JS_FUNC_KIND_BYTECODE);
-  if (JS_IsException (func_obj)) {
-    JS_POP_VALUE (ctx, bfunc);
-    return JS_EXCEPTION;
-  }
-
-  JS_POP_VALUE (ctx, bfunc);
-  b = JS_VALUE_GET_PTR (bfunc);
-
-  func_obj = js_closure2 (ctx, func_obj, b, sf);
-  if (JS_IsException (func_obj)) {
-    /* bfunc has been freed */
-    goto fail;
-  }
-  f = JS_VALUE_GET_FUNCTION (func_obj);
-  /* Use bytecode func_name if valid, otherwise empty string */
-  f->name = JS_IsText (b->func_name) ? b->func_name
-                                     : JS_KEY_empty;
-  f->length = b->arg_count; /* arity = total parameter count */
-  return func_obj;
-fail:
-  /* bfunc is freed when func_obj is freed */
-  return JS_EXCEPTION;
-}
 
 
 JSValue js_call_c_function (JSContext *ctx, JSValue func_obj, JSValue this_obj, int argc, JSValue *argv) {
@@ -5060,6 +4880,29 @@ JSValue js_call_c_function (JSContext *ctx, JSValue func_obj, JSValue this_obj,
   return ret_val;
 }
 
+/* Central function dispatcher — replaces the old bytecode VM entry point.
+   Now dispatches to MACH (register VM), MCODE, or C functions. */
+JSValue JS_CallInternal (JSContext *ctx, JSValue func_obj, JSValue this_obj,
+                         int argc, JSValue *argv, int flags) {
+  (void)flags;
+  if (js_poll_interrupts (ctx)) return JS_EXCEPTION;
+  if (!JS_IsFunction (func_obj))
+    return JS_ThrowTypeError (ctx, "not a function");
+  JSFunction *f = JS_VALUE_GET_FUNCTION (func_obj);
+  switch (f->kind) {
+  case JS_FUNC_KIND_C:
+  case JS_FUNC_KIND_C_DATA:
+    return js_call_c_function (ctx, func_obj, this_obj, argc, argv);
+  case JS_FUNC_KIND_REGISTER:
+    return JS_CallRegisterVM (ctx, f->u.reg.code, this_obj, argc, argv,
+                              f->u.reg.env_record, f->u.reg.outer_frame);
+  case JS_FUNC_KIND_MCODE:
+    return mcode_exec (ctx, f->u.mcode.code, this_obj, argc, argv, f->u.mcode.outer_frame);
+  default:
+    return JS_ThrowTypeError (ctx, "not a function");
+  }
+}
+
 JSValue JS_Call (JSContext *ctx, JSValue func_obj, JSValue this_obj, int argc, JSValue *argv) {
   if (js_poll_interrupts (ctx)) return JS_EXCEPTION;
   if (unlikely (!JS_IsFunction (func_obj)))
@@ -5073,8 +4916,6 @@ JSValue JS_Call (JSContext *ctx, JSValue func_obj, JSValue this_obj, int argc, J
   switch (f->kind) {
   case JS_FUNC_KIND_C:
     return js_call_c_function (ctx, func_obj, this_obj, argc, argv);
-  case JS_FUNC_KIND_BYTECODE:
-    return JS_CallInternal (ctx, func_obj, this_obj, argc, argv, JS_CALL_FLAG_COPY_ARGV);
   case JS_FUNC_KIND_REGISTER:
     return JS_CallRegisterVM (ctx, f->u.reg.code, this_obj, argc, argv,
                               f->u.reg.env_record, f->u.reg.outer_frame);
@@ -5271,97 +5112,6 @@ JSValue *build_arg_list (JSContext *ctx, uint32_t *plen, JSValue *parray_arg) {
   return NULL;
 }
 
-/* Error class */
-static JSValue js_error_constructor (JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
-  JSValue obj, msg;
-  JSValue message, options, proto;
-  int arg_index;
-
-  /* Use the appropriate error prototype based on magic */
-  if (magic < 0) {
-    proto = ctx->class_proto[JS_CLASS_ERROR];
-  } else {
-    proto = ctx->native_error_proto[magic];
-  }
-  obj = JS_NewObjectProtoClass (ctx, proto, JS_CLASS_ERROR);
-  if (JS_IsException (obj)) return obj;
-  arg_index = (magic == JS_AGGREGATE_ERROR);
-
-  message = argv[arg_index++];
-  if (!JS_IsNull (message)) {
-    msg = JS_ToString (ctx, message);
-    if (unlikely (JS_IsException (msg))) goto exception;
-    JS_SetPropertyInternal (ctx, obj, JS_KEY_message, msg);
-  }
-
-  if (arg_index < argc) {
-    options = argv[arg_index];
-    if (JS_IsObject (options)) {
-      int present = JS_HasProperty (ctx, options, JS_KEY_cause);
-      if (present < 0) goto exception;
-      if (present) {
-        JSValue cause = JS_GetProperty (ctx, options, JS_KEY_cause);
-        if (JS_IsException (cause)) goto exception;
-        JS_SetPropertyInternal (ctx, obj, JS_KEY_cause, cause);
-      }
-    }
-  }
-
-  if (magic == JS_AGGREGATE_ERROR) {
-    /* Require errors to be an array (no iterator support) */
-    JSValue error_list;
-    if (JS_IsArray (argv[0])) {
-      uint32_t len, i;
-      if (js_get_length32 (ctx, &len, argv[0])) goto exception;
-      error_list = JS_NewArray (ctx);
-      if (JS_IsException (error_list)) goto exception;
-      for (i = 0; i < len; i++) {
-        JSValue item = JS_GetPropertyUint32 (ctx, argv[0], i);
-        if (JS_IsException (item)) {
-          goto exception;
-        }
-        if (JS_SetPropertyUint32 (ctx, error_list, i, item) < 0) {
-          goto exception;
-        }
-      }
-    } else {
-      error_list = JS_NewArray (ctx);
-      if (JS_IsException (error_list)) goto exception;
-    }
-    JS_SetPropertyInternal (ctx, obj, JS_KEY_errors, error_list);
-  }
-
-  /* skip the Error() function in the backtrace */
-  build_backtrace (ctx, obj, NULL, 0, 0, JS_BACKTRACE_FLAG_SKIP_FIRST_LEVEL);
-  return obj;
-exception:
-  return JS_EXCEPTION;
-}
-
-JSValue js_error_toString (JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-  printf ("E TO STR\n");
-  JSValue name, msg;
-
-  if (!JS_IsObject (this_val)) return JS_ThrowTypeErrorNotAnObject (ctx);
-  name = JS_GetProperty (ctx, this_val, JS_KEY_name);
-  if (JS_IsNull (name))
-    name = JS_KEY_Error;
-  else
-    name = JS_ToString (ctx, name);
-  if (JS_IsException (name)) return JS_EXCEPTION;
-
-  msg = JS_GetProperty (ctx, this_val, JS_KEY_message);
-  if (JS_IsNull (msg))
-    msg = JS_KEY_empty;
-  else
-    msg = JS_ToString (ctx, msg);
-  if (JS_IsException (msg)) {
-    return JS_EXCEPTION;
-  }
-  if (!JS_IsEmptyString (name) && !JS_IsEmptyString (msg))
-    name = JS_ConcatString3 (ctx, "", name, ": ");
-  return JS_ConcatString (ctx, name, msg);
-}
 
 static JSValue js_array_includes (JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
   JSValue found = js_cell_array_find (ctx, this_val, argc, argv);
@@ -6078,6 +5828,50 @@ fail:
   return JS_EXCEPTION;
 }
 
+/* Convert a cJSON node to a JSValue */
+static JSValue cjson_to_jsvalue (JSContext *ctx, const cJSON *item) {
+  if (!item || cJSON_IsNull (item)) return JS_NULL;
+  if (cJSON_IsFalse (item)) return JS_FALSE;
+  if (cJSON_IsTrue (item)) return JS_TRUE;
+  if (cJSON_IsNumber (item)) return JS_NewFloat64 (ctx, item->valuedouble);
+  if (cJSON_IsString (item)) return JS_NewString (ctx, item->valuestring);
+  if (cJSON_IsArray (item)) {
+    int n = cJSON_GetArraySize (item);
+    JSValue arr = JS_NewArray (ctx);
+    for (int i = 0; i < n; i++) {
+      cJSON *child = cJSON_GetArrayItem (item, i);
+      JS_SetPropertyUint32 (ctx, arr, i, cjson_to_jsvalue (ctx, child));
+    }
+    return arr;
+  }
+  if (cJSON_IsObject (item)) {
+    JSValue obj = JS_NewObject (ctx);
+    for (cJSON *child = item->child; child; child = child->next) {
+      JS_SetPropertyStr (ctx, obj, child->string, cjson_to_jsvalue (ctx, child));
+    }
+    return obj;
+  }
+  return JS_NULL;
+}
+
+JSValue JS_ParseJSON (JSContext *ctx, const char *buf, size_t buf_len,
+                      const char *filename) {
+  (void)filename;
+  (void)buf_len;
+  cJSON *root = cJSON_Parse (buf);
+  if (!root)
+    return JS_ThrowSyntaxError (ctx, "JSON parse error");
+  JSValue result = cjson_to_jsvalue (ctx, root);
+  cJSON_Delete (root);
+  return result;
+}
+
+JSValue JS_ParseJSON2 (JSContext *ctx, const char *buf, size_t buf_len,
+                       const char *filename, int flags) {
+  (void)flags;
+  return JS_ParseJSON (ctx, buf, buf_len, filename);
+}
+
 static JSValue js_json_parse (JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
   JSValue obj, root;
   JSValue reviver;
@@ -8485,23 +8279,11 @@ static JSValue js_stacktrace (JSContext *ctx, JSValue this_val, int argc, JSValu
   return JS_NULL;
 }
 
-/* ----------------------------------------------------------------------------
- * Bytecode dump function (always available, for debugging)
- * ----------------------------------------------------------------------------
- */
 
-/* Opcode names for bytecode dump */
-static const char *dump_opcode_names[] = {
-#define FMT(f)
-#define DEF(id, size, n_pop, n_push, f) #id,
-#define def(id, size, n_pop, n_push, f)
-#include "quickjs-opcode.h"
-#undef def
-#undef DEF
-#undef FMT
-};
+/* dump_bytecode_opcodes and JS_DumpFunctionBytecode removed — old stack VM deleted */
 
-static void dump_bytecode_opcodes (JSContext *ctx, JSFunctionBytecode *b) {
+#if 0 /* dead code — old bytecode dump */
+static void dump_bytecode_opcodes_DEAD (JSContext *ctx, JSFunctionBytecode *b) {
   const uint8_t *tab = b->byte_code_buf;
   int len = b->byte_code_len;
   const JSValue *cpool = b->cpool;
@@ -8748,6 +8530,7 @@ void JS_DumpFunctionBytecode (JSContext *ctx, JSValue func_val) {
 
   printf ("=== End Bytecode Dump ===\n");
 }
+#endif /* dead code */
 
 /* ----------------------------------------------------------------------------
  * array function and sub-functions
@@ -10578,53 +10361,21 @@ int js_is_blob (JSContext *js, JSValue v) {
  * env: optional stone record for variable bindings (checked first before intrinsics)
  */
 static JSValue js_cell_eval (JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-  const char *str;
-  size_t len;
-  JSValue env = JS_NULL;
-  JSValue result;
-  JSGCRef env_ref;
-
-  if (argc < 1 || !JS_IsText (argv[0])) {
+  (void)this_val;
+  if (argc < 1 || !JS_IsText (argv[0]))
     return JS_ThrowTypeError (ctx, "eval requires a text argument");
-  }
 
-  /* Get optional environment record (must be stone if provided) */
-  if (argc > 1 && !JS_IsNull (argv[1])) {
-    if (!JS_IsRecord (argv[1])) {
-      return JS_ThrowTypeError (ctx, "eval environment must be an object");
-    }
-    JSRecord *rec = (JSRecord *)JS_VALUE_GET_OBJ (argv[1]);
-    if (!objhdr_s (rec->mist_hdr)) {
-      return JS_ThrowTypeError (ctx, "eval environment must be stoned");
-    }
-    env = argv[1];
-  }
+  const char *source = JS_ToCString (ctx, argv[0]);
+  if (!source) return JS_EXCEPTION;
 
-  /* Protect env from GC during compilation */
-  JS_AddGCRef (ctx, &env_ref);
-  env_ref.val = env;
+  cJSON *ast = JS_ASTTree (source, strlen (source), "<eval>");
+  JS_FreeCString (ctx, source);
+  if (!ast)
+    return JS_ThrowSyntaxError (ctx, "eval: failed to parse");
 
-  /* Get text string */
-  str = JS_ToCStringLen (ctx, &len, argv[0]);
-  if (!str) {
-    JS_DeleteGCRef (ctx, &env_ref);
-    return JS_EXCEPTION;
-  }
-
-  /* Compile the text */
-  JSValue fun = JS_Compile (ctx, str, len, "<eval>");
-  JS_FreeCString (ctx, str);
-  if (JS_IsException (fun)) {
-    JS_DeleteGCRef (ctx, &env_ref);
-    return fun;
-  }
-
-  /* Update env from GC ref (may have moved) */
-  env = env_ref.val;
-  JS_DeleteGCRef (ctx, &env_ref);
-
-  /* Integrate with environment */
-  result = JS_Integrate (ctx, fun, env);
+  JSValue env = (argc > 1 && JS_IsObject (argv[1])) ? argv[1] : JS_NULL;
+  JSValue result = JS_RunMachTree (ctx, ast, env);
+  cJSON_Delete (ast);
   return result;
 }
 
@@ -11622,37 +11373,10 @@ static JSValue js_cell_is_proto (JSContext *ctx, JSValue this_val, int argc, JSV
   return JS_FALSE;
 }
 
-static const char *const native_error_name[JS_NATIVE_ERROR_COUNT] = {
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-  "InternalError",
-  "AggregateError",
-};
-
 /* Minimum amount of objects to be able to compile code and display
-   error messages. No JSAtom should be allocated by this function. */
+   error messages. */
 static void JS_AddIntrinsicBasicObjects (JSContext *ctx) {
-  JSGCRef proto_ref;
-  int i;
-
-  JS_PushGCRef (ctx, &proto_ref);
-
   ctx->class_proto[JS_CLASS_OBJECT] = JS_NewObjectProto (ctx, JS_NULL);
-
-  ctx->class_proto[JS_CLASS_ERROR] = JS_NewObject (ctx);
-
-  for (i = 0; i < JS_NATIVE_ERROR_COUNT; i++) {
-    proto_ref.val = JS_NewObjectProto (ctx, ctx->class_proto[JS_CLASS_ERROR]);
-    JS_SetPropertyInternal (ctx, proto_ref.val, JS_KEY_name, JS_NewAtomString (ctx, native_error_name[i]));
-    JS_SetPropertyInternal (ctx, proto_ref.val, JS_KEY_message, JS_KEY_empty);
-    ctx->native_error_proto[i] = proto_ref.val;
-  }
-
-  JS_PopGCRef (ctx, &proto_ref);
 }
 
 /* logical(val) — false for 0/false/"false"/null, true for 1/true/"true", null otherwise */
@@ -11748,24 +11472,6 @@ static void JS_AddIntrinsicBaseObjects (JSContext *ctx) {
   ctx->throw_type_error = JS_NewCFunction (ctx, js_throw_type_error, NULL, 0);
   ctx->global_obj = JS_NewObject (ctx);
 
-  /* Error */
-  obj1 = JS_NewCFunctionMagic (ctx, js_error_constructor, "Error", 1, JS_CFUNC_generic_magic, -1);
-  JS_SetPropertyStr (ctx, ctx->global_obj, "Error", obj1);
-
-  #define REGISTER_ERROR(idx, name) do { \
-    JSValue func_obj = JS_NewCFunctionMagic(ctx, js_error_constructor, name, 1 + ((idx) == JS_AGGREGATE_ERROR), JS_CFUNC_generic_magic, (idx)); \
-    JS_SetPropertyStr(ctx, ctx->global_obj, name, func_obj); \
-  } while(0)
-  REGISTER_ERROR(0, "EvalError");
-  REGISTER_ERROR(1, "RangeError");
-  REGISTER_ERROR(2, "ReferenceError");
-  REGISTER_ERROR(3, "SyntaxError");
-  REGISTER_ERROR(4, "TypeError");
-  REGISTER_ERROR(5, "URIError");
-  REGISTER_ERROR(6, "InternalError");
-  REGISTER_ERROR(7, "AggregateError");
-  #undef REGISTER_ERROR
-
   /* Cell Script global functions: text, number, array, object, fn */
   {
     JSValue text_func = JS_NewCFunction (ctx, js_cell_text, "text", 3);
@@ -11910,24 +11616,9 @@ void js_debug_info (JSContext *js, JSValue fn, js_debug *dbg) {
   JSValue name_key = JS_NULL;
   if (!JS_IsNull (f->name))
     name_key = f->name;
-  else if (f->kind == JS_FUNC_KIND_BYTECODE && f->u.func.function_bytecode)
-    name_key = f->u.func.function_bytecode->func_name;
 
   key_to_buf (js, name_key, dbg->name, sizeof (dbg->name), "<anonymous>");
 
-  if (f->kind == JS_FUNC_KIND_BYTECODE) {
-    JSFunctionBytecode *b = f->u.func.function_bytecode;
-    key_to_buf (js, b->debug.filename, dbg->filename, sizeof (dbg->filename), "unknown");
-    dbg->what = "JS";
-    dbg->closure_n = b->closure_var_count;
-    dbg->param_n = b->arg_count;
-    dbg->vararg = 1;
-    dbg->source = (const uint8_t *)b->debug.source;
-    dbg->srclen = b->debug.source_len;
-    dbg->line = 0; /* see below */
-    return;
-  }
-
   if (f->kind == JS_FUNC_KIND_C || f->kind == JS_FUNC_KIND_C_DATA) {
     strncpy (dbg->filename, "<native C>", sizeof (dbg->filename));
     dbg->filename[sizeof (dbg->filename) - 1] = 0;
@@ -11969,162 +11660,40 @@ JSValue js_debugger_backtrace_fns (JSContext *ctx, const uint8_t *cur_pc) {
 }
 
 JSValue js_debugger_build_backtrace (JSContext *ctx, const uint8_t *cur_pc) {
+  (void)cur_pc;
   JSStackFrame *sf;
-  const char *func_name_str;
-  JSFunction *f;
   JSValue ret = JS_NewArray (ctx);
   uint32_t stack_index = 0;
 
   for (sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
     JSValue current_frame = JS_NewObject (ctx);
-
     uint32_t id = stack_index++;
     JS_SetPropertyStr (ctx, current_frame, "id", JS_NewUint32 (ctx, id));
 
-    func_name_str = get_func_name (ctx, sf->cur_func);
+    const char *func_name_str = get_func_name (ctx, sf->cur_func);
     if (!func_name_str || func_name_str[0] == '\0')
       JS_SetPropertyStr (ctx, current_frame, "name", JS_NewString (ctx, "<anonymous>"));
     else
       JS_SetPropertyStr (ctx, current_frame, "name", JS_NewString (ctx, func_name_str));
     JS_FreeCString (ctx, func_name_str);
 
-    if (JS_VALUE_GET_TAG (sf->cur_func) == JS_TAG_FUNCTION) {
-      f = JS_VALUE_GET_FUNCTION (sf->cur_func);
-      if (f->kind == JS_FUNC_KIND_BYTECODE) {
-        JSFunctionBytecode *b;
-        int line_num1;
-
-        b = f->u.func.function_bytecode;
-        if (b->has_debug) {
-          const uint8_t *pc = sf != ctx->current_stack_frame || !cur_pc
-                                ? sf->cur_pc
-                                : cur_pc;
-          int col_num;
-          line_num1
-            = find_line_num (ctx, b, pc - b->byte_code_buf - 1, &col_num);
-          JS_SetPropertyStr (ctx, current_frame, "filename", b->debug.filename);
-          if (line_num1 != -1)
-            JS_SetPropertyStr (ctx, current_frame, "line", JS_NewUint32 (ctx, line_num1));
-        }
-      } else {
-        JS_SetPropertyStr (ctx, current_frame, "name", JS_NewString (ctx, "(native)"));
-      }
-    } else {
-      JS_SetPropertyStr (ctx, current_frame, "name", JS_NewString (ctx, "(native)"));
-    }
     JS_SetPropertyUint32 (ctx, ret, id, current_frame);
   }
   return ret;
 }
 
 JSValue js_debugger_fn_info (JSContext *ctx, JSValue fn) {
-  JSValue ret = JS_NewObject (ctx);
-  if (!js_is_bytecode_function (fn)) goto done;
-
-  JSFunction *f = JS_VALUE_GET_FUNCTION (fn);
-  JSFunctionBytecode *b = f->u.func.function_bytecode;
-  char atom_buf[KEY_GET_STR_BUF_SIZE];
-  const char *str;
-  int i;
-
-  // Function name
-  if (!JS_IsNull (b->func_name)) {
-    str = JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), b->func_name);
-    JS_SetPropertyStr (ctx, ret, "name", JS_NewString (ctx, str));
-  }
-
-  // File location info
-  if (b->has_debug && !JS_IsNull (b->debug.filename)) {
-    int line_num, col_num;
-    str = JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), b->debug.filename);
-    line_num = find_line_num (ctx, b, -1, &col_num);
-    JS_SetPropertyStr (ctx, ret, "filename", JS_NewString (ctx, str));
-    JS_SetPropertyStr (ctx, ret, "line", JS_NewInt32 (ctx, line_num));
-    JS_SetPropertyStr (ctx, ret, "column", JS_NewInt32 (ctx, col_num));
-  }
-
-  // Arguments
-  if (b->arg_count && b->vardefs) {
-    JSValue args_array = JS_NewArray (ctx);
-    for (i = 0; i < b->arg_count; i++) {
-      str = JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), b->vardefs[i].var_name);
-      JS_SetPropertyUint32 (ctx, args_array, i, JS_NewString (ctx, str));
-    }
-    JS_SetPropertyStr (ctx, ret, "args", args_array);
-  }
-
-  // Local variables
-  if (b->var_count && b->vardefs) {
-    JSValue locals_array = JS_NewArray (ctx);
-    for (i = 0; i < b->var_count; i++) {
-      JSVarDef *vd = &b->vardefs[b->arg_count + i];
-      JSValue local_obj = JS_NewObject (ctx);
-
-      str = JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), vd->var_name);
-      JS_SetPropertyStr (ctx, local_obj, "name", JS_NewString (ctx, str));
-
-      const char *var_type = vd->var_kind == JS_VAR_CATCH ? "catch"
-                             : (vd->var_kind == JS_VAR_FUNCTION_DECL
-                                || vd->var_kind == JS_VAR_NEW_FUNCTION_DECL)
-                               ? "function"
-                             : vd->is_const   ? "const"
-                             : vd->is_lexical ? "let"
-                                              : "var";
-      JS_SetPropertyStr (ctx, local_obj, "type", JS_NewString (ctx, var_type));
-      JS_SetPropertyStr (ctx, local_obj, "index", JS_NewInt32 (ctx, i));
-
-      if (vd->scope_level) {
-        JS_SetPropertyStr (ctx, local_obj, "scope_level", JS_NewInt32 (ctx, vd->scope_level));
-        JS_SetPropertyStr (ctx, local_obj, "scope_next", JS_NewInt32 (ctx, vd->scope_next));
-      }
-
-      JS_SetPropertyUint32 (ctx, locals_array, i, local_obj);
-    }
-    JS_SetPropertyStr (ctx, ret, "locals", locals_array);
-  }
-
-  // Closure variables
-  if (b->closure_var_count) {
-    JSValue closure_array = JS_NewArray (ctx);
-    for (i = 0; i < b->closure_var_count; i++) {
-      JSClosureVar *cv = &b->closure_var[i];
-      JSValue closure_obj = JS_NewObject (ctx);
-
-      str = JS_KeyGetStr (ctx, atom_buf, sizeof (atom_buf), cv->var_name);
-      JS_SetPropertyStr (ctx, closure_obj, "name", JS_NewString (ctx, str));
-      JS_SetPropertyStr (ctx, closure_obj, "is_local", JS_NewBool (ctx, cv->is_local));
-      JS_SetPropertyStr (ctx, closure_obj, "is_arg", JS_NewBool (ctx, cv->is_arg));
-      JS_SetPropertyStr (ctx, closure_obj, "var_idx", JS_NewInt32 (ctx, cv->var_idx));
-
-      const char *var_type = cv->is_const     ? "const"
-                             : cv->is_lexical ? "let"
-                                              : "var";
-      JS_SetPropertyStr (ctx, closure_obj, "type", JS_NewString (ctx, var_type));
-
-      JS_SetPropertyUint32 (ctx, closure_array, i, closure_obj);
-    }
-    JS_SetPropertyStr (ctx, ret, "closure_vars", closure_array);
-  }
-
-  // Stack size
-  JS_SetPropertyStr (ctx, ret, "stack_size", JS_NewInt32 (ctx, b->stack_size));
-
-done:
-  return ret;
+  (void)fn;
+  return JS_NewObject (ctx);
 }
 
-// Opcode names array for debugger
-static const char *opcode_names[] = {
-#define FMT(f)
-#define DEF(id, size, n_pop, n_push, f) #id,
-#define def(id, size, n_pop, n_push, f)
-#include "quickjs-opcode.h"
-#undef def
-#undef DEF
-#undef FMT
-};
-
 JSValue js_debugger_fn_bytecode (JSContext *ctx, JSValue fn) {
+  (void)fn;
+  return JS_NewArray (ctx);
+}
+
+#if 0 /* Old bytecode VM debugger — dead code */
+static JSValue js_debugger_fn_bytecode_OLD (JSContext *ctx, JSValue fn) {
   if (!js_is_bytecode_function (fn)) return JS_NULL;
 
   JSFunction *f = JS_VALUE_GET_FUNCTION (fn);
@@ -12481,54 +12050,11 @@ JSValue js_debugger_fn_bytecode (JSContext *ctx, JSValue fn) {
 
   return ret;
 }
+#endif /* Old bytecode VM debugger */
 
 JSValue js_debugger_local_variables (JSContext *ctx, int stack_index) {
-  JSValue ret = JS_NewObject (ctx);
-
-  JSStackFrame *sf;
-  int cur_index = 0;
-
-  for (sf = ctx->current_stack_frame; sf != NULL; sf = sf->prev_frame) {
-    // this val is one frame up
-    if (cur_index == stack_index - 1) {
-      if (js_is_bytecode_function (sf->cur_func)) {
-        JSFunction *f = JS_VALUE_GET_FUNCTION (sf->cur_func);
-        JSFunctionBytecode *b = f->u.func.function_bytecode;
-
-        JSValue this_obj = sf->var_buf[b->var_count];
-        // only provide a this if it is not the global object.
-        if (JS_VALUE_GET_OBJ (this_obj) != JS_VALUE_GET_OBJ (ctx->global_obj))
-          JS_SetPropertyStr (ctx, ret, "this", this_obj);
-      }
-    }
-
-    if (cur_index < stack_index) {
-      cur_index++;
-      continue;
-    }
-
-    if (!js_is_bytecode_function (sf->cur_func)) goto done;
-    JSFunction *f = JS_VALUE_GET_FUNCTION (sf->cur_func);
-    JSFunctionBytecode *b = f->u.func.function_bytecode;
-
-    for (uint32_t i = 0; i < b->arg_count + b->var_count; i++) {
-      JSValue var_val;
-      if (i < b->arg_count)
-        var_val = sf->arg_buf[i];
-      else
-        var_val = sf->var_buf[i - b->arg_count];
-
-      if (JS_IsUninitialized (var_val)) continue;
-
-      JSVarDef *vd = b->vardefs + i;
-      JS_SetProperty (ctx, ret, vd->var_name, var_val);
-    }
-
-    break;
-  }
-
-done:
-  return ret;
+  (void)stack_index;
+  return JS_NewObject (ctx);
 }
 
 void js_debugger_set_closure_variable (JSContext *ctx, JSValue fn, JSValue var_name, JSValue val) {
@@ -12566,12 +12092,8 @@ static JSValue js_cell_json_decode (JSContext *ctx, JSValue this_val, int argc,
   if (argc < 1)
     return JS_ThrowTypeError (ctx, "json.decode requires at least 1 argument");
 
-  if (!JS_IsText (argv[0])) {
-    JSValue err = JS_NewError (ctx);
-    JS_SetPropertyStr (
-      ctx, err, "message", JS_NewString (ctx, "couldn't parse text: not a string"));
-    return JS_Throw (ctx, err);
-  }
+  if (!JS_IsText (argv[0]))
+    return JS_ThrowTypeError (ctx, "couldn't parse text: not a string");
 
   const char *str = JS_ToCString (ctx, argv[0]);
   if (!str) return JS_EXCEPTION;
diff --git a/source/suite.c b/source/suite.c
index cdf529e2..ad6f3293 100644
--- a/source/suite.c
+++ b/source/suite.c
@@ -1742,9 +1742,12 @@ TEST(has_exception_initially_false) {
   return 1;
 }
 
-TEST(new_error) {
-  JSValue err = JS_NewError(ctx);
-  ASSERT(JS_IsError(ctx, err));
+TEST(throw_and_check_exception) {
+  ASSERT(!JS_HasException(ctx));
+  JS_ThrowTypeError(ctx, "test error");
+  ASSERT(JS_HasException(ctx));
+  JS_GetException(ctx); /* clear it */
+  ASSERT(!JS_HasException(ctx));
   return 1;
 }
 
@@ -2001,138 +2004,6 @@ TEST(wota_encode_blob) {
   return 1;
 }
 
-/* ============================================================================
-   CELL MODULE TESTS - Serialize/Deserialize bytecode
-   ============================================================================ */
-
-TEST(cell_module_compile_basic) {
-  /* Compile simple source to CellModule */
-  const char *source = "1 + 2";
-  CellModule *mod = JS_CompileModule(ctx, source, strlen(source), "<test>");
-  ASSERT_MSG(mod != NULL, "JS_CompileModule returned NULL");
-
-  /* Check module has units */
-  ASSERT_MSG(mod->unit_count > 0, "Module has no units");
-  ASSERT_MSG(mod->units[0].bytecode_len > 0, "Unit has no bytecode");
-
-  cell_module_free(mod);
-  return 1;
-}
-
-TEST(cell_module_write_read) {
-  /* Compile, serialize, deserialize */
-  const char *source = "var x = 10; x * 2";
-  CellModule *mod = JS_CompileModule(ctx, source, strlen(source), "<test>");
-  ASSERT_MSG(mod != NULL, "JS_CompileModule returned NULL");
-
-  /* Serialize */
-  size_t len;
-  uint8_t *buf = cell_module_write(mod, &len);
-  ASSERT_MSG(buf != NULL, "cell_module_write returned NULL");
-  ASSERT_MSG(len > 0, "cell_module_write produced empty buffer");
-
-  /* Deserialize */
-  CellModule *mod2 = cell_module_read(buf, len);
-  free(buf);
-  ASSERT_MSG(mod2 != NULL, "cell_module_read returned NULL");
-
-  /* Verify structure matches */
-  ASSERT_MSG(mod2->unit_count == mod->unit_count, "unit_count mismatch");
-  ASSERT_MSG(mod2->string_count == mod->string_count, "string_count mismatch");
-
-  cell_module_free(mod);
-  cell_module_free(mod2);
-  return 1;
-}
-
-TEST(cell_module_integrate_basic) {
-  /* Compile, then integrate and execute */
-  const char *source = "3 + 4";
-  CellModule *mod = JS_CompileModule(ctx, source, strlen(source), "<test>");
-  ASSERT_MSG(mod != NULL, "JS_CompileModule returned NULL");
-
-  /* Integrate into context */
-  JSValue func = cell_module_integrate(ctx, mod, JS_NULL);
-  if (JS_IsException(func)) {
-    cell_module_free(mod);
-    ASSERT_MSG(0, "cell_module_integrate threw exception");
-  }
-
-  /* Execute */
-  JSValue result = JS_Call(ctx, func, JS_NULL, 0, NULL);
-  JS_FreeValue(ctx, func);
-  cell_module_free(mod);
-
-  if (JS_IsException(result)) {
-    ASSERT_MSG(0, "JS_Call threw exception");
-  }
-
-  ASSERT_INT(result, 7);
-  return 1;
-}
-
-TEST(cell_module_roundtrip_execute) {
-  /* Full round-trip: compile -> write -> read -> integrate -> execute */
-  const char *source = "var a = 5; var b = 3; a * b";
-  CellModule *mod = JS_CompileModule(ctx, source, strlen(source), "<test>");
-  ASSERT_MSG(mod != NULL, "JS_CompileModule returned NULL");
-
-  /* Serialize */
-  size_t len;
-  uint8_t *buf = cell_module_write(mod, &len);
-  cell_module_free(mod);
-  ASSERT_MSG(buf != NULL, "cell_module_write returned NULL");
-
-  /* Deserialize */
-  CellModule *mod2 = cell_module_read(buf, len);
-  free(buf);
-  ASSERT_MSG(mod2 != NULL, "cell_module_read returned NULL");
-
-  /* Integrate and execute */
-  JSValue func = cell_module_integrate(ctx, mod2, JS_NULL);
-  cell_module_free(mod2);
-  if (JS_IsException(func)) {
-    ASSERT_MSG(0, "cell_module_integrate threw exception");
-  }
-
-  JSValue result = JS_Call(ctx, func, JS_NULL, 0, NULL);
-  JS_FreeValue(ctx, func);
-
-  if (JS_IsException(result)) {
-    ASSERT_MSG(0, "JS_Call threw exception");
-  }
-
-  ASSERT_INT(result, 15);
-  return 1;
-}
-
-TEST(cell_module_string_constant) {
-  /* Test string constant handling */
-  const char *source = "'hello' + ' world'";
-  CellModule *mod = JS_CompileModule(ctx, source, strlen(source), "<test>");
-  ASSERT_MSG(mod != NULL, "JS_CompileModule returned NULL");
-
-  /* Verify string table has entries */
-  ASSERT_MSG(mod->string_count > 0, "Module has no strings");
-
-  /* Integrate and execute */
-  JSValue func = cell_module_integrate(ctx, mod, JS_NULL);
-  cell_module_free(mod);
-  if (JS_IsException(func)) {
-    ASSERT_MSG(0, "cell_module_integrate threw exception");
-  }
-
-  JSValue result = JS_Call(ctx, func, JS_NULL, 0, NULL);
-  JS_FreeValue(ctx, func);
-
-  if (JS_IsException(result)) {
-    ASSERT_MSG(0, "JS_Call threw exception");
-  }
-
-  ASSERT_STR(result, "hello world");
-  return 1;
-}
-
 /* ============================================================================
    ERROR RECOVERY TESTS - Helper macros
    ============================================================================ */
@@ -2590,7 +2461,7 @@ int run_c_test_suite(JSContext *ctx)
 
   printf("\nExceptions/Errors:\n");
   RUN_TEST(has_exception_initially_false);
-  RUN_TEST(new_error);
+  RUN_TEST(throw_and_check_exception);
 
   printf("\nFloat Edge Cases:\n");
   RUN_TEST(float_small_positive);
@@ -2622,12 +2493,6 @@ int run_c_test_suite(JSContext *ctx)
   RUN_TEST(wota_encode_nested_array);
   RUN_TEST(wota_encode_blob);
 
-  // CellModule tests
-  RUN_TEST(cell_module_compile_basic);
-  RUN_TEST(cell_module_write_read);
-  RUN_TEST(cell_module_integrate_basic);
-  RUN_TEST(cell_module_roundtrip_execute);
-  RUN_TEST(cell_module_string_constant);
 
   printf("\nTokenizer Errors:\n");
   RUN_TEST(tokenize_unterminated_string);