JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,
               const char *filename, int eval_flags);

/* JS_Eval() flags */
#define JS_EVAL_TYPE_GLOBAL   (0 << 0) /* global code (default) */
#define JS_EVAL_TYPE_MODULE   (1 << 0) /* module code */
#define JS_EVAL_TYPE_DIRECT   (2 << 0) /* direct call (internal use) */
#define JS_EVAL_TYPE_INDIRECT (3 << 0) /* indirect call (internal use) */
#define JS_EVAL_TYPE_MASK     (3 << 0)

#define JS_EVAL_FLAG_STRICT   (1 << 3) /* force 'strict' mode */
#define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5) /* compile but do not run */
#define JS_EVAL_FLAG_BACKTRACE_BARRIER (1 << 6) /* don't include previous frames */
#define JS_EVAL_FLAG_ASYNC (1 << 7) /* allow top-level await (returns promise) */

const char *code = "2 + 2";
JSValue result = JS_Eval(ctx, code, strlen(code), "<eval>", JS_EVAL_TYPE_GLOBAL);

if (JS_IsException(result)) {
    js_std_dump_error(ctx);
} else {
    int32_t value;
    JS_ToInt32(ctx, &value, result);
    printf("Result: %d\n", value);  // prints: Result: 4
}

JS_FreeValue(ctx, result);

const char *module_code = 
    "import { PI } from 'math';\n"
    "export const area = (r) => PI * r * r;";

JSValue result = JS_Eval(ctx, module_code, strlen(module_code),
                         "circle.js", JS_EVAL_TYPE_MODULE);

if (JS_IsException(result)) {
    js_std_dump_error(ctx);
}

JS_FreeValue(ctx, result);

const char *code = "x = 10;";
JSValue result = JS_Eval(ctx, code, strlen(code), "<eval>",
                         JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_STRICT);

// This will throw a ReferenceError in strict mode
if (JS_IsException(result)) {
    js_std_dump_error(ctx);  // ReferenceError: x is not defined
}

JS_FreeValue(ctx, result);

const char *code = "function greet() { return 'Hello'; }";
JSValue bytecode = JS_Eval(ctx, code, strlen(code), "greet.js",
                           JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_COMPILE_ONLY);

if (!JS_IsException(bytecode)) {
    // bytecode has JS_TAG_FUNCTION_BYTECODE tag
    // Execute it later with JS_EvalFunction()
    JSValue result = JS_EvalFunction(ctx, bytecode);
    JS_FreeValue(ctx, result);
}

JSValue JS_Eval2(JSContext *ctx, const char *input, size_t input_len,
                JSEvalOptions *options);

#define JS_EVAL_OPTIONS_VERSION 1

typedef struct JSEvalOptions {
    int version;          // must be JS_EVAL_OPTIONS_VERSION
    int eval_flags;
    const char *filename;
    int line_num;
} JSEvalOptions;

JSEvalOptions options = {
    .version = JS_EVAL_OPTIONS_VERSION,
    .eval_flags = JS_EVAL_TYPE_GLOBAL,
    .filename = "user-script.js",
    .line_num = 1
};

const char *code = "console.log('Hello');";
JSValue result = JS_Eval2(ctx, code, strlen(code), &options);
JS_FreeValue(ctx, result);

JSValue JS_EvalThis(JSContext *ctx, JSValueConst this_obj,
                   const char *input, size_t input_len,
                   const char *filename, int eval_flags);

JSValue obj = JS_NewObject(ctx);
JS_SetPropertyStr(ctx, obj, "name", JS_NewString(ctx, "QuickJS"));

const char *code = "this.name";
JSValue result = JS_EvalThis(ctx, obj, code, strlen(code),
                             "<eval>", JS_EVAL_TYPE_GLOBAL);

const char *name = JS_ToCString(ctx, result);
printf("%s\n", name);  // prints: QuickJS
JS_FreeCString(ctx, name);

JS_FreeValue(ctx, result);
JS_FreeValue(ctx, obj);

JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj);

const char *code = "21 * 2";
JSValue bytecode = JS_Eval(ctx, code, strlen(code), "calc.js",
                           JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_COMPILE_ONLY);

if (!JS_IsException(bytecode)) {
    JSValue result = JS_EvalFunction(ctx, bytecode);
    int32_t value;
    JS_ToInt32(ctx, &value, result);
    printf("%d\n", value);  // prints: 42
    JS_FreeValue(ctx, result);
}

bool JS_DetectModule(const char *input, size_t input_len);

const char *code = "import foo from 'bar'; export default 123;";
if (JS_DetectModule(code, strlen(code))) {
    printf("This looks like a module\n");
}