#ifndef QUICKJS_H

#define QUICKJS_H

#include <stdbool.h>

#include <stdio.h>

#include <stdint.h>

#include <string.h>

#include <math.h>

#ifdef __cplusplus

extern "C" {

#if defined(__GNUC__) || defined(__clang__)

#define js_force_inline inline __attribute__((always_inline))

#define JS_EXTERN __attribute__((visibility("default")))

#define js_force_inline inline

#define JS_EXTERN /* nothing */

#ifndef JS_PRINTF_FORMAT

#ifdef _MSC_VER

#include <sal.h>

#define JS_PRINTF_FORMAT _Printf_format_string_

#define JS_PRINTF_FORMAT_ATTR(format_param, dots_param)

#define JS_PRINTF_FORMAT

#if !defined(__clang__) && defined(__GNUC__)

#define JS_PRINTF_FORMAT_ATTR(format_param, dots_param) \

__attribute__((format(gnu_printf, format_param, dots_param)))

#define JS_PRINTF_FORMAT_ATTR(format_param, dots_param) \

__attribute__((format(printf, format_param, dots_param)))

typedef struct JSRuntime JSRuntime;

typedef struct JSContext JSContext;

typedef struct JSObject JSObject;

typedef struct JSClass JSClass;

typedef uint32_t JSClassID;

typedef uint32_t JSAtom;

#ifndef JS_NAN_BOXING

#if INTPTR_MAX < INT64_MAX

#define JS_NAN_BOXING 1 /* Use NAN boxing for 32bit builds. */

enum {

/* all tags with a reference count are negative */

JS_TAG_FIRST = -9, /* first negative tag */

JS_TAG_BIG_INT = -9,

JS_TAG_SYMBOL = -8,

JS_TAG_STRING = -7,

JS_TAG_MODULE = -3, /* used internally */

JS_TAG_FUNCTION_BYTECODE = -2, /* used internally */

JS_TAG_OBJECT = -1,

JS_TAG_INT = 0,

JS_TAG_BOOL = 1,

JS_TAG_NULL = 2,

JS_TAG_UNDEFINED = 3,

JS_TAG_UNINITIALIZED = 4,

JS_TAG_CATCH_OFFSET = 5,

JS_TAG_EXCEPTION = 6,

JS_TAG_FLOAT64 = 7,

/* any larger tag is FLOAT64 if JS_NAN_BOXING */

};

#define JS_FLOAT64_NAN NAN

#define JSValueConst JSValue /* For backwards compatibility. */

#if defined(JS_NAN_BOXING) && JS_NAN_BOXING

typedef uint64_t JSValue;

#define JS_VALUE_GET_TAG(v) (int)((v) >> 32)

#define JS_VALUE_GET_INT(v) (int)(v)

#define JS_VALUE_GET_BOOL(v) (int)(v)

#define JS_VALUE_GET_PTR(v) (void *)(intptr_t)(v)

#define JS_MKVAL(tag, val) (((uint64_t)(tag) << 32) | (uint32_t)(val))

#define JS_MKPTR(tag, ptr) (((uint64_t)(tag) << 32) | (uintptr_t)(ptr))

#define JS_FLOAT64_TAG_ADDEND (0x7ff80000 - JS_TAG_FIRST + 1) /* quiet NaN encoding */

static inline double JS_VALUE_GET_FLOAT64(JSValue v)

{

union {

JSValue v;

double d;

} u;

u.v = v;

u.v += (uint64_t)JS_FLOAT64_TAG_ADDEND << 32;

return u.d;

}

#define JS_NAN (0x7ff8000000000000 - ((uint64_t)JS_FLOAT64_TAG_ADDEND << 32))

static inline JSValue __JS_NewFloat64(double d)

{

union {

double d;

uint64_t u64;

} u;

JSValue v;

u.d = d;

/* normalize NaN */

if ((u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000)

v = JS_NAN;

else

v = u.u64 - ((uint64_t)JS_FLOAT64_TAG_ADDEND << 32);

return v;

}

#define JS_TAG_IS_FLOAT64(tag) ((unsigned)((tag) - JS_TAG_FIRST) >= (JS_TAG_FLOAT64 - JS_TAG_FIRST))

static inline int JS_VALUE_GET_NORM_TAG(JSValue v)

{

uint32_t tag;

tag = JS_VALUE_GET_TAG(v);

if (JS_TAG_IS_FLOAT64(tag))

return JS_TAG_FLOAT64;

else

return tag;

}

static inline bool JS_VALUE_IS_NAN(JSValue v)

{

uint32_t tag;

tag = JS_VALUE_GET_TAG(v);

return tag == (JS_NAN >> 32);

}

#else /* !JS_NAN_BOXING */

typedef union JSValueUnion {

int32_t int32;

double float64;

void *ptr;

} JSValueUnion;

typedef struct JSValue {

JSValueUnion u;

int64_t tag;

} JSValue;

#define JS_VALUE_GET_TAG(v) ((int32_t)(v).tag)

#define JS_VALUE_GET_NORM_TAG(v) JS_VALUE_GET_TAG(v)

#define JS_VALUE_GET_INT(v) ((v).u.int32)

#define JS_VALUE_GET_BOOL(v) ((v).u.int32)

#define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)

#define JS_VALUE_GET_PTR(v) ((v).u.ptr)

#ifdef __cplusplus

static inline JSValue JS_MKPTR(int64_t tag, void *ptr)

{

JSValue v;

v.u.ptr = ptr;

v.tag = tag;

return v;

}

static inline JSValue JS_MKVAL(int64_t tag, int32_t int32)

{

JSValue v;

v.u.int32 = int32;

v.tag = tag;

return v;

}

static inline JSValue JS_MKNAN(void)

{

JSValue v;

v.u.float64 = JS_FLOAT64_NAN;

v.tag = JS_TAG_FLOAT64;

return v;

}

#define JS_MKPTR(tag, ptr) JS_MKPTR(tag, ptr)

#define JS_MKVAL(tag, val) JS_MKVAL(tag, val)

#define JS_NAN JS_MKNAN() /* alas, not a constant expression */

#define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }

#define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }

#define JS_NAN (JSValue){ (JSValueUnion){ .float64 = JS_FLOAT64_NAN }, JS_TAG_FLOAT64 }

#define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)

static inline JSValue __JS_NewFloat64(double d)

{

JSValue v;

v.tag = JS_TAG_FLOAT64;

v.u.float64 = d;

return v;

}

static inline bool JS_VALUE_IS_NAN(JSValue v)

{

union {

double d;

uint64_t u64;

} u;

if (v.tag != JS_TAG_FLOAT64)

return 0;

u.d = v.u.float64;

return (u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000;

}

#endif /* !JS_NAN_BOXING */

#define JS_VALUE_IS_BOTH_INT(v1, v2) ((JS_VALUE_GET_TAG(v1) | JS_VALUE_GET_TAG(v2)) == 0)

#define JS_VALUE_IS_BOTH_FLOAT(v1, v2) (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v1)) && JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v2)))

#define JS_VALUE_GET_OBJ(v) ((JSObject *)JS_VALUE_GET_PTR(v))

#define JS_VALUE_HAS_REF_COUNT(v) ((unsigned)JS_VALUE_GET_TAG(v) >= (unsigned)JS_TAG_FIRST)

#define JS_NULL JS_MKVAL(JS_TAG_NULL, 0)

#define JS_UNDEFINED JS_MKVAL(JS_TAG_UNDEFINED, 0)

#define JS_FALSE JS_MKVAL(JS_TAG_BOOL, 0)

#define JS_TRUE JS_MKVAL(JS_TAG_BOOL, 1)

#define JS_EXCEPTION JS_MKVAL(JS_TAG_EXCEPTION, 0)

#define JS_UNINITIALIZED JS_MKVAL(JS_TAG_UNINITIALIZED, 0)

#define JS_PROP_CONFIGURABLE (1 << 0)

#define JS_PROP_WRITABLE (1 << 1)

#define JS_PROP_ENUMERABLE (1 << 2)

#define JS_PROP_C_W_E (JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE | JS_PROP_ENUMERABLE)

#define JS_PROP_LENGTH (1 << 3) /* used internally in Arrays */

#define JS_PROP_TMASK (3 << 4) /* mask for NORMAL, GETSET, VARREF, AUTOINIT */

#define JS_PROP_NORMAL (0 << 4)

#define JS_PROP_GETSET (1 << 4)

#define JS_PROP_VARREF (2 << 4) /* used internally */

#define JS_PROP_AUTOINIT (3 << 4) /* used internally */

#define JS_PROP_HAS_SHIFT 8

#define JS_PROP_HAS_CONFIGURABLE (1 << 8)

#define JS_PROP_HAS_WRITABLE (1 << 9)

#define JS_PROP_HAS_ENUMERABLE (1 << 10)

#define JS_PROP_HAS_GET (1 << 11)

#define JS_PROP_HAS_SET (1 << 12)

#define JS_PROP_HAS_VALUE (1 << 13)

#define JS_PROP_THROW (1 << 14)

#define JS_PROP_THROW_STRICT (1 << 15)

#define JS_PROP_NO_ADD (1 << 16) /* internal use */

#define JS_PROP_NO_EXOTIC (1 << 17) /* internal use */

#define JS_PROP_DEFINE_PROPERTY (1 << 18) /* internal use */

#define JS_PROP_REFLECT_DEFINE_PROPERTY (1 << 19) /* internal use */

#ifndef JS_DEFAULT_STACK_SIZE

#define JS_DEFAULT_STACK_SIZE (1024 * 1024)

#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_UNUSED (1 << 4) /* unused */

#define JS_EVAL_FLAG_COMPILE_ONLY (1 << 5)

#define JS_EVAL_FLAG_COMPILE_ONLY_NO_RESOLVE JS_EVAL_FLAG_UNUSED

#define JS_EVAL_FLAG_BACKTRACE_BARRIER (1 << 6)

#define JS_EVAL_FLAG_ASYNC (1 << 7)

typedef JSValue JSCFunction(JSContext *ctx, JSValue this_val, int argc, JSValue *argv);

typedef JSValue JSCFunctionMagic(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic);

typedef JSValue JSCFunctionData(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic, JSValue *func_data);

typedef struct JSMallocFunctions {

} JSMallocFunctions;

#define JS_DUMP_BYTECODE_FINAL 0x01 /* dump pass 3 final byte code */

#define JS_DUMP_BYTECODE_PASS2 0x02 /* dump pass 2 code */

#define JS_DUMP_BYTECODE_PASS1 0x04 /* dump pass 1 code */

#define JS_DUMP_BYTECODE_HEX 0x10 /* dump bytecode in hex */

#define JS_DUMP_BYTECODE_PC2LINE 0x20 /* dump line number table */

#define JS_DUMP_BYTECODE_STACK 0x40 /* dump compute_stack_size */

#define JS_DUMP_BYTECODE_STEP 0x80 /* dump executed bytecode */

#define JS_DUMP_READ_OBJECT 0x100 /* dump the marshalled objects at load time */

#define JS_DUMP_FREE 0x200 /* dump every object free */

#define JS_DUMP_GC 0x400 /* dump the occurrence of the automatic GC */

#define JS_DUMP_GC_FREE 0x800 /* dump objects freed by the GC */

#define JS_DUMP_MODULE_RESOLVE 0x1000 /* dump module resolution steps */

#define JS_DUMP_PROMISE 0x2000 /* dump promise steps */

#define JS_DUMP_LEAKS 0x4000 /* dump leaked objects and strings in JS_FreeRuntime */

#define JS_DUMP_ATOM_LEAKS 0x8000 /* dump leaked atoms in JS_FreeRuntime */

#define JS_DUMP_MEM 0x10000 /* dump memory usage in JS_FreeRuntime */

#define JS_DUMP_OBJECTS 0x20000 /* dump objects in JS_FreeRuntime */

#define JS_DUMP_ATOMS 0x40000 /* dump atoms in JS_FreeRuntime */

#define JS_DUMP_SHAPES 0x80000 /* dump shapes in JS_FreeRuntime */

typedef void JSRuntimeFinalizer(JSRuntime *rt, void *arg);

typedef struct JSGCObjectHeader JSGCObjectHeader;

JS_EXTERN JSRuntime *JS_NewRuntime(void);

JS_EXTERN void JS_SetRuntimeInfo(JSRuntime *rt, const char *info);

JS_EXTERN void JS_SetMemoryLimit(JSRuntime *rt, size_t limit);

JS_EXTERN void JS_SetDumpFlags(JSRuntime *rt, uint64_t flags);

JS_EXTERN uint64_t JS_GetDumpFlags(JSRuntime *rt);

JS_EXTERN size_t JS_GetGCThreshold(JSRuntime *rt);

JS_EXTERN void JS_SetGCThreshold(JSRuntime *rt, size_t gc_threshold);

JS_EXTERN void JS_SetMaxStackSize(JSRuntime *rt, size_t stack_size);

JS_EXTERN void JS_UpdateStackTop(JSRuntime *rt);

JS_EXTERN JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque);

JS_EXTERN void JS_FreeRuntime(JSRuntime *rt);

JS_EXTERN void *JS_GetRuntimeOpaque(JSRuntime *rt);

JS_EXTERN void JS_SetRuntimeOpaque(JSRuntime *rt, void *opaque);

JS_EXTERN int JS_AddRuntimeFinalizer(JSRuntime *rt,

JSRuntimeFinalizer *finalizer, void *arg);

typedef void JS_MarkFunc(JSRuntime *rt, JSGCObjectHeader *gp);

JS_EXTERN void JS_MarkValue(JSRuntime *rt, JSValue val, JS_MarkFunc *mark_func);

JS_EXTERN void JS_RunGC(JSRuntime *rt);

JS_EXTERN bool JS_IsLiveObject(JSRuntime *rt, JSValue obj);

JS_EXTERN JSContext *JS_NewContext(JSRuntime *rt);

JS_EXTERN void JS_FreeContext(JSContext *s);

JS_EXTERN JSContext *JS_DupContext(JSContext *ctx);

JS_EXTERN void *JS_GetContextOpaque(JSContext *ctx);

JS_EXTERN void JS_SetContextOpaque(JSContext *ctx, void *opaque);

JS_EXTERN JSRuntime *JS_GetRuntime(JSContext *ctx);

JS_EXTERN void JS_SetClassProto(JSContext *ctx, JSClassID class_id, JSValue obj);

JS_EXTERN JSValue JS_GetClassProto(JSContext *ctx, JSClassID class_id);

JS_EXTERN JSValue JS_GetFunctionProto(JSContext *ctx);

JS_EXTERN JSContext *JS_NewContextRaw(JSRuntime *rt);

JS_EXTERN void JS_AddIntrinsicBaseObjects(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicDate(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicEval(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicRegExpCompiler(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicRegExp(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicJSON(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicProxy(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicMapSet(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicTypedArrays(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicPromise(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicBigInt(JSContext *ctx);

JS_EXTERN void JS_AddIntrinsicWeakRef(JSContext *ctx);

JS_EXTERN void JS_AddPerformance(JSContext *ctx);

JS_EXTERN int JS_IsEqual(JSContext *ctx, JSValue op1, JSValue op2);

JS_EXTERN bool JS_IsStrictEqual(JSContext *ctx, JSValue op1, JSValue op2);

JS_EXTERN bool JS_IsSameValue(JSContext *ctx, JSValue op1, JSValue op2);

JS_EXTERN bool JS_IsSameValueZero(JSContext *ctx, JSValue op1, JSValue op2);

JS_EXTERN JSValue js_string_codePointRange(JSContext *ctx, JSValue this_val,

int argc, JSValue *argv);

JS_EXTERN void *js_calloc_rt(JSRuntime *rt, size_t count, size_t size);

JS_EXTERN void *js_malloc_rt(JSRuntime *rt, size_t size);

JS_EXTERN void js_free_rt(JSRuntime *rt, void *ptr);

JS_EXTERN void *js_realloc_rt(JSRuntime *rt, void *ptr, size_t size);

JS_EXTERN size_t js_malloc_usable_size_rt(JSRuntime *rt, const void *ptr);

JS_EXTERN void *js_mallocz_rt(JSRuntime *rt, size_t size);

JS_EXTERN void *js_calloc(JSContext *ctx, size_t count, size_t size);

JS_EXTERN void *js_malloc(JSContext *ctx, size_t size);

JS_EXTERN void js_free(JSContext *ctx, void *ptr);

JS_EXTERN void *js_realloc(JSContext *ctx, void *ptr, size_t size);

JS_EXTERN size_t js_malloc_usable_size(JSContext *ctx, const void *ptr);

JS_EXTERN void *js_realloc2(JSContext *ctx, void *ptr, size_t size, size_t *pslack);

JS_EXTERN void *js_mallocz(JSContext *ctx, size_t size);

JS_EXTERN char *js_strdup(JSContext *ctx, const char *str);

JS_EXTERN char *js_strndup(JSContext *ctx, const char *s, size_t n);

typedef struct JSMemoryUsage {

} JSMemoryUsage;

JS_EXTERN void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s);

JS_EXTERN void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt);

#define JS_ATOM_NULL 0

JS_EXTERN JSAtom JS_NewAtomLen(JSContext *ctx, const char *str, size_t len);

JS_EXTERN JSAtom JS_NewAtom(JSContext *ctx, const char *str);

JS_EXTERN JSAtom JS_NewAtomUInt32(JSContext *ctx, uint32_t n);

JS_EXTERN JSAtom JS_DupAtom(JSContext *ctx, JSAtom v);

JS_EXTERN void JS_FreeAtom(JSContext *ctx, JSAtom v);

JS_EXTERN void JS_FreeAtomRT(JSRuntime *rt, JSAtom v);

JS_EXTERN JSValue JS_AtomToValue(JSContext *ctx, JSAtom atom);

JS_EXTERN JSValue JS_AtomToString(JSContext *ctx, JSAtom atom);

JS_EXTERN const char *JS_AtomToCString(JSContext *ctx, JSAtom atom);

JS_EXTERN JSAtom JS_ValueToAtom(JSContext *ctx, JSValue val);

typedef struct JSPropertyEnum {

bool is_enumerable;

JSAtom atom;

} JSPropertyEnum;

typedef struct JSPropertyDescriptor {

} JSPropertyDescriptor;

typedef struct JSClassExoticMethods {

} JSClassExoticMethods;

typedef void JSClassFinalizer(JSRuntime *rt, JSValue val);

typedef void JSClassGCMark(JSRuntime *rt, JSValue val,

JS_MarkFunc *mark_func);

#define JS_CALL_FLAG_CONSTRUCTOR (1 << 0)

typedef JSValue JSClassCall(JSContext *ctx, JSValue func_obj,

JSValue this_val, int argc, JSValue *argv,

int flags);

typedef struct JSClassDef {

} JSClassDef;

#define JS_INVALID_CLASS_ID 0

JS_EXTERN JSClassID JS_NewClassID(JSRuntime *rt, JSClassID *pclass_id);

JS_EXTERN JSClassID JS_GetClassID(JSValue v);

JS_EXTERN int JS_NewClass(JSRuntime *rt, JSClassID class_id, const JSClassDef *class_def);

JS_EXTERN bool JS_IsRegisteredClass(JSRuntime *rt, JSClassID class_id);

static js_force_inline JSValue JS_NewBool(JSContext *ctx, bool val)

{

(void)&ctx;

return JS_MKVAL(JS_TAG_BOOL, (val != 0));

}

static js_force_inline JSValue JS_NewInt32(JSContext *ctx, int32_t val)

{

(void)&ctx;

return JS_MKVAL(JS_TAG_INT, val);

}

static js_force_inline JSValue JS_NewFloat64(JSContext *ctx, double val)

{

(void)&ctx;

return __JS_NewFloat64(val);

}

static js_force_inline JSValue JS_NewCatchOffset(JSContext *ctx, int32_t val)

{

(void)&ctx;

return JS_MKVAL(JS_TAG_CATCH_OFFSET, val);

}

static js_force_inline JSValue JS_NewInt64(JSContext *ctx, int64_t val)

{

JSValue v;

if (val >= INT32_MIN && val <= INT32_MAX) {

v = JS_NewInt32(ctx, (int32_t)val);

} else {

v = JS_NewFloat64(ctx, (double)val);

}

return v;

}

static js_force_inline JSValue JS_NewUint32(JSContext *ctx, uint32_t val)

{

JSValue v;

if (val <= INT32_MAX) {

v = JS_NewInt32(ctx, (int32_t)val);

} else {

v = JS_NewFloat64(ctx, (double)val);

}

return v;

}

JS_EXTERN JSValue JS_NewNumber(JSContext *ctx, double d);

JS_EXTERN JSValue JS_NewBigInt64(JSContext *ctx, int64_t v);

JS_EXTERN JSValue JS_NewBigUint64(JSContext *ctx, uint64_t v);

static inline bool JS_IsNumber(JSValue v)

{

int tag = JS_VALUE_GET_TAG(v);

return tag == JS_TAG_INT || JS_TAG_IS_FLOAT64(tag);

}

static inline bool JS_IsBigInt(JSContext *ctx, JSValue v)

{

(void)&ctx;

return JS_VALUE_GET_TAG(v) == JS_TAG_BIG_INT;

}

static inline bool JS_IsBool(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_BOOL;

}

static inline bool JS_IsNull(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_NULL;

}

static inline bool JS_IsUndefined(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_UNDEFINED;

}

static inline bool JS_IsException(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_EXCEPTION;

}

static inline bool JS_IsUninitialized(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_UNINITIALIZED;

}

static inline bool JS_IsString(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_STRING;

}

static inline bool JS_IsSymbol(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_SYMBOL;

}

static inline bool JS_IsObject(JSValue v)

{

return JS_VALUE_GET_TAG(v) == JS_TAG_OBJECT;

}

JS_EXTERN JSValue JS_Throw(JSContext *ctx, JSValue obj);

JS_EXTERN JSValue JS_GetException(JSContext *ctx);

JS_EXTERN bool JS_HasException(JSContext *ctx);

JS_EXTERN bool JS_IsError(JSContext *ctx, JSValue val);

JS_EXTERN bool JS_IsUncatchableError(JSContext* ctx, JSValue val);

JS_EXTERN void JS_SetUncatchableError(JSContext *ctx, JSValue val);

JS_EXTERN void JS_ClearUncatchableError(JSContext *ctx, JSValue val);

JS_EXTERN void JS_ResetUncatchableError(JSContext *ctx);

JS_EXTERN JSValue JS_NewError(JSContext *ctx);

JS_EXTERN JSValue JS_PRINTF_FORMAT_ATTR(2, 3) JS_ThrowPlainError(JSContext *ctx, JS_PRINTF_FORMAT const char *fmt, ...);

JS_EXTERN JSValue JS_PRINTF_FORMAT_ATTR(2, 3) JS_ThrowSyntaxError(JSContext *ctx, JS_PRINTF_FORMAT const char *fmt, ...);

JS_EXTERN JSValue JS_PRINTF_FORMAT_ATTR(2, 3) JS_ThrowTypeError(JSContext *ctx, JS_PRINTF_FORMAT const char *fmt, ...);

JS_EXTERN JSValue JS_PRINTF_FORMAT_ATTR(2, 3) JS_ThrowReferenceError(JSContext *ctx, JS_PRINTF_FORMAT const char *fmt, ...);

JS_EXTERN JSValue JS_PRINTF_FORMAT_ATTR(2, 3) JS_ThrowRangeError(JSContext *ctx, JS_PRINTF_FORMAT const char *fmt, ...);

JS_EXTERN JSValue JS_PRINTF_FORMAT_ATTR(2, 3) JS_ThrowInternalError(JSContext *ctx, JS_PRINTF_FORMAT const char *fmt, ...);

JS_EXTERN JSValue JS_ThrowOutOfMemory(JSContext *ctx);

JS_EXTERN void JS_FreeValue(JSContext *ctx, JSValue v);

JS_EXTERN void JS_FreeValueRT(JSRuntime *rt, JSValue v);

JS_EXTERN JSValue JS_DupValue(JSContext *ctx, JSValue v);

JS_EXTERN JSValue JS_DupValueRT(JSRuntime *rt, JSValue v);

JS_EXTERN int JS_ToBool(JSContext *ctx, JSValue val); /* return -1 for JS_EXCEPTION */

static inline JSValue JS_ToBoolean(JSContext *ctx, JSValue val)

{

return JS_NewBool(ctx, JS_ToBool(ctx, val));

}

JS_EXTERN JSValue JS_ToNumber(JSContext *ctx, JSValue val);

JS_EXTERN int JS_ToInt32(JSContext *ctx, int32_t *pres, JSValue val);

static inline int JS_ToUint32(JSContext *ctx, uint32_t *pres, JSValue val)

{

return JS_ToInt32(ctx, (int32_t*)pres, val);

}

JS_EXTERN int JS_ToInt64(JSContext *ctx, int64_t *pres, JSValue val);

JS_EXTERN int JS_ToIndex(JSContext *ctx, uint64_t *plen, JSValue val);

JS_EXTERN int JS_ToFloat64(JSContext *ctx, double *pres, JSValue val);

JS_EXTERN int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValue val);

JS_EXTERN int JS_ToBigUint64(JSContext *ctx, uint64_t *pres, JSValue val);

JS_EXTERN int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValue val);

JS_EXTERN JSValue JS_NewStringLen(JSContext *ctx, const char *str1, size_t len1);

static inline JSValue JS_NewString(JSContext *ctx, const char *str) {

return JS_NewStringLen(ctx, str, strlen(str));

}

JS_EXTERN JSValue JS_NewAtomString(JSContext *ctx, const char *str);

JS_EXTERN JSValue JS_ToString(JSContext *ctx, JSValue val);

JS_EXTERN JSValue JS_ToPropertyKey(JSContext *ctx, JSValue val);

JS_EXTERN const char *JS_ToCStringLen2(JSContext *ctx, size_t *plen, JSValue val1, bool cesu8);

static inline const char *JS_ToCStringLen(JSContext *ctx, size_t *plen, JSValue val1)

{

return JS_ToCStringLen2(ctx, plen, val1, 0);

}

static inline const char *JS_ToCString(JSContext *ctx, JSValue val1)

{

return JS_ToCStringLen2(ctx, NULL, val1, 0);

}

JS_EXTERN void JS_FreeCString(JSContext *ctx, const char *ptr);

JS_EXTERN JSValue JS_NewObjectProtoClass(JSContext *ctx, JSValue proto, JSClassID class_id);

JS_EXTERN JSValue JS_NewObjectClass(JSContext *ctx, int class_id);

JS_EXTERN JSValue JS_NewObjectProto(JSContext *ctx, JSValue proto);

JS_EXTERN JSValue JS_NewObject(JSContext *ctx);

JS_EXTERN JSValue JS_ToObject(JSContext *ctx, JSValue val);

JS_EXTERN JSValue JS_ToObjectString(JSContext *ctx, JSValue val);

JS_EXTERN bool JS_IsFunction(JSContext* ctx, JSValue val);

JS_EXTERN bool JS_IsConstructor(JSContext* ctx, JSValue val);

JS_EXTERN bool JS_SetConstructorBit(JSContext *ctx, JSValue func_obj, bool val);

JS_EXTERN bool JS_IsRegExp(JSValue val);

JS_EXTERN bool JS_IsMap(JSValue val);

JS_EXTERN JSValue JS_NewArray(JSContext *ctx);

JS_EXTERN int JS_IsArray(JSContext *ctx, JSValue val);

JS_EXTERN JSValue JS_NewDate(JSContext *ctx, double epoch_ms);

JS_EXTERN bool JS_IsDate(JSValue v);

JS_EXTERN JSValue JS_GetProperty(JSContext *ctx, JSValue this_obj, JSAtom prop);

JS_EXTERN JSValue JS_GetPropertyUint32(JSContext *ctx, JSValue this_obj,

uint32_t idx);

JS_EXTERN JSValue JS_GetPropertyInt64(JSContext *ctx, JSValue this_obj,

int64_t idx);

JS_EXTERN JSValue JS_GetPropertyStr(JSContext *ctx, JSValue this_obj,

const char *prop);

JS_EXTERN int JS_SetProperty(JSContext *ctx, JSValue this_obj,

JSAtom prop, JSValue val);

JS_EXTERN int JS_SetPropertyUint32(JSContext *ctx, JSValue this_obj,

uint32_t idx, JSValue val);

JS_EXTERN int JS_SetPropertyInt64(JSContext *ctx, JSValue this_obj,

int64_t idx, JSValue val);

JS_EXTERN int JS_SetPropertyStr(JSContext *ctx, JSValue this_obj,

const char *prop, JSValue val);

JS_EXTERN int JS_HasProperty(JSContext *ctx, JSValue this_obj, JSAtom prop);

JS_EXTERN int JS_IsExtensible(JSContext *ctx, JSValue obj);

JS_EXTERN int JS_PreventExtensions(JSContext *ctx, JSValue obj);

JS_EXTERN int JS_DeleteProperty(JSContext *ctx, JSValue obj, JSAtom prop, int flags);

JS_EXTERN int JS_SetPrototype(JSContext *ctx, JSValue obj, JSValue proto_val);

JS_EXTERN JSValue JS_GetPrototype(JSContext *ctx, JSValue val);

JS_EXTERN int JS_GetLength(JSContext *ctx, JSValue obj, int64_t *pres);

JS_EXTERN int JS_SetLength(JSContext *ctx, JSValue obj, int64_t len);

JS_EXTERN int JS_SealObject(JSContext *ctx, JSValue obj);

JS_EXTERN int JS_FreezeObject(JSContext *ctx, JSValue obj);

#define JS_GPN_STRING_MASK (1 << 0)

#define JS_GPN_SYMBOL_MASK (1 << 1)

#define JS_GPN_PRIVATE_MASK (1 << 2)

#define JS_GPN_ENUM_ONLY (1 << 4)

#define JS_GPN_SET_ENUM (1 << 5)

JS_EXTERN int JS_GetOwnPropertyNames(JSContext *ctx, JSPropertyEnum **ptab,

uint32_t *plen, JSValue obj, int flags);

JS_EXTERN int JS_GetOwnProperty(JSContext *ctx, JSPropertyDescriptor *desc,

JSValue obj, JSAtom prop);

JS_EXTERN void JS_FreePropertyEnum(JSContext *ctx, JSPropertyEnum *tab,

uint32_t len);

JS_EXTERN JSValue JS_Call(JSContext *ctx, JSValue func_obj, JSValue this_obj,

int argc, JSValue *argv);

JS_EXTERN JSValue JS_Invoke(JSContext *ctx, JSValue this_val, JSAtom atom,

int argc, JSValue *argv);

JS_EXTERN JSValue JS_CallConstructor(JSContext *ctx, JSValue func_obj,

int argc, JSValue *argv);

JS_EXTERN JSValue JS_CallConstructor2(JSContext *ctx, JSValue func_obj,

JSValue new_target,

int argc, JSValue *argv);

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

JS_EXTERN JSValue JS_Eval(JSContext *ctx, const char *input, size_t input_len,

const char *filename, int eval_flags);

JS_EXTERN JSValue JS_EvalThis(JSContext *ctx, JSValue this_obj,

const char *input, size_t input_len,

const char *filename, int eval_flags);

JS_EXTERN JSValue JS_GetGlobalObject(JSContext *ctx);

JS_EXTERN int JS_IsInstanceOf(JSContext *ctx, JSValue val, JSValue obj);

JS_EXTERN int JS_DefineProperty(JSContext *ctx, JSValue this_obj,

JSAtom prop, JSValue val,

JSValue getter, JSValue setter, int flags);

JS_EXTERN int JS_DefinePropertyValue(JSContext *ctx, JSValue this_obj,

JSAtom prop, JSValue val, int flags);

JS_EXTERN int JS_DefinePropertyValueUint32(JSContext *ctx, JSValue this_obj,

uint32_t idx, JSValue val, int flags);

JS_EXTERN int JS_DefinePropertyValueStr(JSContext *ctx, JSValue this_obj,

const char *prop, JSValue val, int flags);

JS_EXTERN int JS_DefinePropertyGetSet(JSContext *ctx, JSValue this_obj,

JSAtom prop, JSValue getter, JSValue setter,

int flags);

JS_EXTERN int JS_SetOpaque(JSValue obj, void *opaque);

JS_EXTERN void *JS_GetOpaque(JSValue obj, JSClassID class_id);

JS_EXTERN void *JS_GetOpaque2(JSContext *ctx, JSValue obj, JSClassID class_id);

JS_EXTERN void *JS_GetAnyOpaque(JSValue obj, JSClassID *class_id);

JS_EXTERN JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,

const char *filename);

JS_EXTERN JSValue JS_JSONStringify(JSContext *ctx, JSValue obj,

JSValue replacer, JSValue space0);

typedef void JSFreeArrayBufferDataFunc(JSRuntime *rt, void *opaque, void *ptr);

JS_EXTERN JSValue JS_NewArrayBuffer(JSContext *ctx, uint8_t *buf, size_t len,

JSFreeArrayBufferDataFunc *free_func, void *opaque,

bool is_shared);

JS_EXTERN JSValue JS_NewArrayBufferCopy(JSContext *ctx, const uint8_t *buf, size_t len);

JS_EXTERN void JS_DetachArrayBuffer(JSContext *ctx, JSValue obj);

JS_EXTERN uint8_t *JS_GetArrayBuffer(JSContext *ctx, size_t *psize, JSValue obj);

JS_EXTERN bool JS_IsArrayBuffer(JSValue obj);

JS_EXTERN uint8_t *JS_GetUint8Array(JSContext *ctx, size_t *psize, JSValue obj);

typedef enum JSTypedArrayEnum {

} JSTypedArrayEnum;

JS_EXTERN JSValue JS_NewTypedArray(JSContext *ctx, int argc, JSValue *argv,

JSTypedArrayEnum array_type);

JS_EXTERN JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValue obj,

size_t *pbyte_offset,

size_t *pbyte_length,

size_t *pbytes_per_element);

JS_EXTERN JSValue JS_NewUint8Array(JSContext *ctx, uint8_t *buf, size_t len,

JSFreeArrayBufferDataFunc *free_func, void *opaque,

bool is_shared);

JS_EXTERN int JS_GetTypedArrayType(JSValue obj);

JS_EXTERN JSValue JS_NewUint8ArrayCopy(JSContext *ctx, const uint8_t *buf, size_t len);

typedef struct {

void *(*sab_alloc)(void *opaque, size_t size);

void (*sab_free)(void *opaque, void *ptr);

void (*sab_dup)(void *opaque, void *ptr);

void *sab_opaque;

} JSSharedArrayBufferFunctions;

JS_EXTERN void JS_SetSharedArrayBufferFunctions(JSRuntime *rt, const JSSharedArrayBufferFunctions *sf);

typedef enum JSPromiseStateEnum {

} JSPromiseStateEnum;

JS_EXTERN JSValue JS_NewPromiseCapability(JSContext *ctx, JSValue *resolving_funcs);

JS_EXTERN JSPromiseStateEnum JS_PromiseState(JSContext *ctx, JSValue promise);

JS_EXTERN JSValue JS_PromiseResult(JSContext *ctx, JSValue promise);

JS_EXTERN bool JS_IsPromise(JSValue val);

JS_EXTERN JSValue JS_NewSymbol(JSContext *ctx, const char *description, bool is_global);

typedef void JSHostPromiseRejectionTracker(JSContext *ctx, JSValue promise,

JSValue reason,

bool is_handled, void *opaque);

JS_EXTERN void JS_SetHostPromiseRejectionTracker(JSRuntime *rt, JSHostPromiseRejectionTracker *cb, void *opaque);

typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);

JS_EXTERN void JS_SetInterruptHandler(JSRuntime *rt, JSInterruptHandler *cb, void *opaque);

JS_EXTERN void JS_SetCanBlock(JSRuntime *rt, bool can_block);

JS_EXTERN void JS_SetIsHTMLDDA(JSContext *ctx, JSValue obj);

typedef struct JSModuleDef JSModuleDef;

typedef char *JSModuleNormalizeFunc(JSContext *ctx,

const char *module_base_name,

const char *module_name, void *opaque);

typedef JSModuleDef *JSModuleLoaderFunc(JSContext *ctx,

const char *module_name, void *opaque);

JS_EXTERN void JS_SetModuleLoaderFunc(JSRuntime *rt,

JSModuleNormalizeFunc *module_normalize,

JSModuleLoaderFunc *module_loader, void *opaque);

JS_EXTERN JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m);

JS_EXTERN JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m);

JS_EXTERN JSValue JS_GetModuleNamespace(JSContext *ctx, JSModuleDef *m);

typedef JSValue JSJobFunc(JSContext *ctx, int argc, JSValue *argv);

JS_EXTERN int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func, int argc, JSValue *argv);

JS_EXTERN bool JS_IsJobPending(JSRuntime *rt);

JS_EXTERN int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx);

typedef struct JSSABTab {

uint8_t **tab;

size_t len;

} JSSABTab;

#define JS_WRITE_OBJ_BYTECODE (1 << 0) /* allow function/module */

#define JS_WRITE_OBJ_BSWAP (0) /* byte swapped output (obsolete, handled transparently) */

#define JS_WRITE_OBJ_SAB (1 << 2) /* allow SharedArrayBuffer */

#define JS_WRITE_OBJ_REFERENCE (1 << 3) /* allow object references to encode arbitrary object graph */

#define JS_WRITE_OBJ_STRIP_SOURCE (1 << 4) /* do not write source code information */

#define JS_WRITE_OBJ_STRIP_DEBUG (1 << 5) /* do not write debug information */

JS_EXTERN uint8_t *JS_WriteObject(JSContext *ctx, size_t *psize, JSValue obj, int flags);

JS_EXTERN uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValue obj,

int flags, JSSABTab *psab_tab);

#define JS_READ_OBJ_BYTECODE (1 << 0) /* allow function/module */

#define JS_READ_OBJ_ROM_DATA (0) /* avoid duplicating 'buf' data (obsolete, broken by ICs) */

#define JS_READ_OBJ_SAB (1 << 2) /* allow SharedArrayBuffer */

#define JS_READ_OBJ_REFERENCE (1 << 3) /* allow object references */

JS_EXTERN JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len, int flags);

JS_EXTERN JSValue JS_ReadObject2(JSContext *ctx, const uint8_t *buf, size_t buf_len,

int flags, JSSABTab *psab_tab);

JS_EXTERN JSValue JS_EvalFunction(JSContext *ctx, JSValue fun_obj);

JS_EXTERN int JS_ResolveModule(JSContext *ctx, JSValue obj);

JS_EXTERN JSAtom JS_GetScriptOrModuleName(JSContext *ctx, int n_stack_levels);

JS_EXTERN JSValue JS_LoadModule(JSContext *ctx, const char *basename,

const char *filename);

typedef enum JSCFunctionEnum { /* XXX: should rename for namespace isolation */

} JSCFunctionEnum;

typedef union JSCFunctionType {

JSCFunction *generic;

JSValue (*generic_magic)(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic);

JSCFunction *constructor;

JSValue (*constructor_magic)(JSContext *ctx, JSValue new_target, int argc, JSValue *argv, int magic);

JSCFunction *constructor_or_func;

double (*f_f)(double);

double (*f_f_f)(double, double);

JSValue (*getter)(JSContext *ctx, JSValue this_val);