jseption 0.0.0-stage → 0.0.2

package/dist/builtins/promise.d.ts

@@ -0,0 +1,13 @@
+import { JSContext, JSValue, JSPromiseState } from '../quickjs.ts';
+export declare function JS_PromiseState(ctx: JSContext, promise: JSValue): JSPromiseState | -1;
+export declare function JS_PromiseResult(ctx: JSContext, promise: JSValue): JSValue;
+export declare function check_function(ctx: JSContext, obj: JSValue): number;
+export declare function js_create_resolving_functions(ctx: JSContext, resolving_funcs: [JSValue, JSValue], promise: JSValue): number;
+export declare function js_promise_resolve_function_call(ctx: JSContext, func_obj: JSValue, resolution: JSValue): JSValue;
+export declare function JS_NewPromiseCapability(ctx: JSContext, resolving_funcs: [JSValue, JSValue]): JSValue;
+export declare function js_promise_resolve(ctx: JSContext, this_val: JSValue, argv: JSValue[], magic: number): JSValue;
+export declare function JS_PromiseResolve(ctx: JSContext, ctor: JSValue, value: JSValue): JSValue;
+export declare function perform_promise_then(ctx: JSContext, promise: JSValue, resolve_reject: [JSValue, JSValue], cap_resolving_funcs: [JSValue, JSValue]): number;
+export declare function JS_SpeciesConstructor(ctx: JSContext, obj: JSValue, defaultConstructor: JSValue): JSValue;
+export declare function js_promise_then(ctx: JSContext, this_val: JSValue, argv: JSValue[]): JSValue;
+export declare function JS_AddIntrinsicPromise(ctx: JSContext): void;

package/dist/builtins/promise.js

@@ -0,0 +1,582 @@
+/*
+ * jseption: TypeScript port of QuickJS
+ *
+ * Promise implementation (port of the Promise section of quickjs.c).
+ */
+import * as Q from "../quickjs.js";
+import { JS_EXCEPTION, JS_IsException, JS_IsUndefined, JS_IsObject, JSPromiseData, JSPromiseReactionData, JSPromiseFunctionData, JS_PROP_C_W_E, JS_PROP_CONFIGURABLE, JS_PROP_WRITABLE, JS_PROP_ENUMERABLE, JS_ATOM_then, JS_ATOM_constructor, JS_ATOM_resolve, JS_ATOM_reject, JS_ATOM_promise, JS_ATOM_next, JS_ATOM_status, JS_ATOM_reason, JS_ATOM_value, JS_ATOM_errors, JS_ATOM_Symbol_species, JS_ATOM_Symbol_toStringTag, JS_Throw, JS_GetException, JS_ThrowTypeError, JS_ThrowTypeErrorNotAnObject, JS_NewObject, JS_NewObjectProtoClass, JS_NewArray, JS_NewCFunctionData, JS_NewCFunction2, JS_GetProperty, JS_GetPropertyUint32, JS_SetPropertyUint32, JS_DefinePropertyValue, JS_DefinePropertyValueUint32, JS_Call, JS_CallConstructor, JS_Invoke, JS_IsFunction, JS_IsConstructor, JS_GetOpaque, JS_GetOpaque2, JS_SetOpaque, js_create_from_ctor, js_same_value, JS_ToBoolFree, JS_ToInt32Free, JS_GetIterator, JS_IteratorNext, JS_IteratorClose, JS_EnqueueJob, JS_SetPropertyFunctionList, JS_NewGlobalCConstructor2, JS_CFUNC_DEF, JS_CFUNC_MAGIC_DEF, JS_CGETSET_DEF, JS_PROP_STRING_DEF, } from "../quickjs.js";
+/* ---------------------------------------------------------------------
+   Promise state
+   --------------------------------------------------------------------- */
+export function JS_PromiseState(ctx, promise) {
+    const s = JS_GetOpaque(promise, 45 /* JSClassID.PROMISE */);
+    if (!s)
+        return -1;
+    return s.promise_state;
+}
+export function JS_PromiseResult(ctx, promise) {
+    const s = JS_GetOpaque(promise, 45 /* JSClassID.PROMISE */);
+    if (!s)
+        return undefined;
+    return s.promise_result;
+}
+export function check_function(ctx, obj) {
+    if (JS_IsFunction(ctx, obj))
+        return 0;
+    JS_ThrowTypeError(ctx, 'not a function');
+    return -1;
+}
+/* argv: [resolve, reject, handler, is_reject, arg] */
+function promise_reaction_job(ctx, argv) {
+    const handler = argv[2];
+    let is_reject = JS_ToBoolFree(ctx, argv[3]);
+    const arg = argv[4];
+    let res;
+    if (JS_IsUndefined(handler)) {
+        if (is_reject)
+            res = JS_Throw(ctx, arg);
+        else
+            res = arg;
+    }
+    else {
+        res = JS_Call(ctx, handler, undefined, [arg]);
+    }
+    is_reject = JS_IsException(res);
+    if (is_reject)
+        res = JS_GetException(ctx);
+    const func = argv[is_reject ? 1 : 0];
+    /* as an extension, we support undefined as value to avoid creating a
+       dummy promise in the 'await' implementation of async functions */
+    if (!JS_IsUndefined(func))
+        return JS_Call(ctx, func, undefined, [res]);
+    return undefined;
+}
+function fulfill_or_reject_promise(ctx, promise, value, is_reject) {
+    const s = JS_GetOpaque(promise, 45 /* JSClassID.PROMISE */);
+    if (!s || s.promise_state !== 0 /* JSPromiseState.PENDING */)
+        return; /* should never happen */
+    s.promise_result = value;
+    s.promise_state = is_reject ? 2 /* JSPromiseState.REJECTED */ : 1 /* JSPromiseState.FULFILLED */;
+    if (s.promise_state === 2 /* JSPromiseState.REJECTED */ && !s.is_handled) {
+        const rt = ctx.rt;
+        if (rt.host_promise_rejection_tracker) {
+            rt.host_promise_rejection_tracker(ctx, promise, value, false, rt.host_promise_rejection_tracker_opaque);
+        }
+    }
+    const idx = is_reject ? 1 : 0;
+    for (const rd of s.promise_reactions[idx]) {
+        JS_EnqueueJob(ctx, promise_reaction_job, [rd.resolving_funcs[0], rd.resolving_funcs[1], rd.handler, is_reject, value]);
+    }
+    s.promise_reactions[0] = [];
+    s.promise_reactions[1] = [];
+}
+function reject_promise(ctx, promise, value) {
+    fulfill_or_reject_promise(ctx, promise, value, true);
+}
+/* argv: [promise, thenable, then] */
+function js_promise_resolve_thenable_job(ctx, argv) {
+    const promise = argv[0], thenable = argv[1], then = argv[2];
+    const args = [undefined, undefined];
+    if (js_create_resolving_functions(ctx, args, promise) < 0)
+        return JS_EXCEPTION;
+    let res = JS_Call(ctx, then, thenable, [args[0], args[1]]);
+    if (JS_IsException(res)) {
+        const error = JS_GetException(ctx);
+        res = JS_Call(ctx, args[1], undefined, [error]);
+    }
+    return res;
+}
+export function js_create_resolving_functions(ctx, resolving_funcs, promise) {
+    const sr = { already_resolved: false }; /* must be shared between the two functions */
+    for (let i = 0; i < 2; i++) {
+        let fobj;
+        const impl = (_this_val, _new_target, args) => {
+            js_promise_resolve_function_call(ctx, fobj, args.length > 0 ? args[0] : undefined);
+            return undefined;
+        };
+        fobj = Q.js_new_host_function(ctx, impl, false, '', 1, ctx.function_proto, (46 /* JSClassID.PROMISE_RESOLVE_FUNCTION */ + i));
+        Q.js_meta.get(fobj).u = new JSPromiseFunctionData(promise, sr);
+        resolving_funcs[i] = fobj;
+    }
+    return 0;
+}
+export function js_promise_resolve_function_call(ctx, func_obj, resolution) {
+    const m = Q.js_get_meta(func_obj);
+    const s = m.u;
+    if (!s || s.presolved.already_resolved)
+        return undefined;
+    s.presolved.already_resolved = true;
+    const is_reject = m.class_id === 47 /* JSClassID.PROMISE_REJECT_FUNCTION */;
+    if (is_reject || !JS_IsObject(resolution)) {
+        fulfill_or_reject_promise(ctx, s.promise, resolution, is_reject);
+        return undefined;
+    }
+    if (js_same_value(ctx, resolution, s.promise)) {
+        JS_ThrowTypeError(ctx, 'promise self resolution');
+        const error = JS_GetException(ctx);
+        reject_promise(ctx, s.promise, error);
+        return undefined;
+    }
+    const then = JS_GetProperty(ctx, resolution, JS_ATOM_then);
+    if (JS_IsException(then)) {
+        const error = JS_GetException(ctx);
+        reject_promise(ctx, s.promise, error);
+    }
+    else if (!JS_IsFunction(ctx, then)) {
+        fulfill_or_reject_promise(ctx, s.promise, resolution, is_reject);
+    }
+    else {
+        JS_EnqueueJob(ctx, js_promise_resolve_thenable_job, [s.promise, resolution, then]);
+    }
+    return undefined;
+}
+/* ---------------------------------------------------------------------
+   Promise constructor and capabilities
+   --------------------------------------------------------------------- */
+function js_promise_constructor(ctx, new_target, argv) {
+    const executor = argv[0];
+    if (check_function(ctx, executor))
+        return JS_EXCEPTION;
+    const obj = js_create_from_ctor(ctx, new_target, 45 /* JSClassID.PROMISE */);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    const s = new JSPromiseData();
+    JS_SetOpaque(obj, s);
+    const args = [undefined, undefined];
+    if (js_create_resolving_functions(ctx, args, obj))
+        return JS_EXCEPTION;
+    const ret = JS_Call(ctx, executor, undefined, [args[0], args[1]]);
+    if (JS_IsException(ret)) {
+        const error = JS_GetException(ctx);
+        const ret2 = JS_Call(ctx, args[1], undefined, [error]);
+        if (JS_IsException(ret2))
+            return JS_EXCEPTION;
+    }
+    return obj;
+}
+function js_promise_executor(ctx, this_val, argv, magic, func_data) {
+    for (let i = 0; i < 2; i++) {
+        if (!JS_IsUndefined(func_data[i]))
+            return JS_ThrowTypeError(ctx, 'resolving function already set');
+        func_data[i] = argv[i];
+    }
+    return undefined;
+}
+function js_promise_executor_new(ctx) {
+    return JS_NewCFunctionData(ctx, js_promise_executor, 2, 0, [undefined, undefined]);
+}
+function js_new_promise_capability(ctx, resolving_funcs, ctor) {
+    const executor = js_promise_executor_new(ctx);
+    if (JS_IsException(executor))
+        return executor;
+    let result_promise;
+    if (JS_IsUndefined(ctor)) {
+        result_promise = js_promise_constructor(ctx, ctor, [executor]);
+    }
+    else {
+        result_promise = JS_CallConstructor(ctx, ctor, [executor]);
+    }
+    if (JS_IsException(result_promise))
+        return JS_EXCEPTION;
+    const s = JS_GetOpaque(executor, 15 /* JSClassID.C_FUNCTION_DATA */);
+    for (let i = 0; i < 2; i++) {
+        if (check_function(ctx, s.data[i]))
+            return JS_EXCEPTION;
+    }
+    resolving_funcs[0] = s.data[0];
+    resolving_funcs[1] = s.data[1];
+    return result_promise;
+}
+/* resolving_funcs receives [resolve, reject]; returns the promise */
+export function JS_NewPromiseCapability(ctx, resolving_funcs) {
+    return js_new_promise_capability(ctx, resolving_funcs, undefined);
+}
+/* Promise.resolve / Promise.reject (magic = is_reject) with 'this_val' as constructor */
+export function js_promise_resolve(ctx, this_val, argv, magic) {
+    const is_reject = magic !== 0;
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    if (!is_reject && JS_GetOpaque(argv[0], 45 /* JSClassID.PROMISE */)) {
+        const ctor = JS_GetProperty(ctx, argv[0], JS_ATOM_constructor);
+        if (JS_IsException(ctor))
+            return ctor;
+        if (js_same_value(ctx, ctor, this_val))
+            return argv[0];
+    }
+    const resolving_funcs = [undefined, undefined];
+    const result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
+    if (JS_IsException(result_promise))
+        return result_promise;
+    const ret = JS_Call(ctx, resolving_funcs[is_reject ? 1 : 0], undefined, [argv[0]]);
+    if (JS_IsException(ret))
+        return ret;
+    return result_promise;
+}
+/* PromiseResolve(C, x) */
+export function JS_PromiseResolve(ctx, ctor, value) {
+    return js_promise_resolve(ctx, ctor, [value], 0);
+}
+function js_promise_withResolvers(ctx, this_val, argv) {
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const resolving_funcs = [undefined, undefined];
+    const result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
+    if (JS_IsException(result_promise))
+        return result_promise;
+    const obj = JS_NewObject(ctx);
+    if (JS_IsException(obj))
+        return JS_EXCEPTION;
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_promise, result_promise, JS_PROP_C_W_E);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_resolve, resolving_funcs[0], JS_PROP_C_W_E);
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_reject, resolving_funcs[1], JS_PROP_C_W_E);
+    return obj;
+}
+/* return -1 on exception, else 1 if the counter reached zero, 0 otherwise */
+function remainingElementsCount_add(ctx, resolve_element_env, addend) {
+    const val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
+    if (JS_IsException(val))
+        return -1;
+    const n = JS_ToInt32Free(ctx, val);
+    if (JS_IsException(n))
+        return -1;
+    const remainingElementsCount = n + addend;
+    if (JS_SetPropertyUint32(ctx, resolve_element_env, 0, remainingElementsCount) < 0)
+        return -1;
+    return remainingElementsCount === 0 ? 1 : 0;
+}
+const PROMISE_MAGIC_all = 0;
+const PROMISE_MAGIC_allSettled = 1;
+const PROMISE_MAGIC_any = 2;
+function js_aggregate_error_constructor(ctx, errors) {
+    const obj = JS_NewObjectProtoClass(ctx, ctx.native_error_proto[7 /* JSErrorEnum.AGGREGATE_ERROR */], 3 /* JSClassID.ERROR */);
+    if (JS_IsException(obj))
+        return obj;
+    JS_DefinePropertyValue(ctx, obj, JS_ATOM_errors, errors, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    return obj;
+}
+/* func_data: [alreadyCalled, index, values, resolve, resolve_element_env] */
+function js_promise_all_resolve_element(ctx, this_val, argv, magic, func_data) {
+    const resolve_type = magic & 3;
+    const is_reject = (magic & 4) !== 0;
+    const alreadyCalled = JS_ToBoolFree(ctx, func_data[0]);
+    const values = func_data[2];
+    const resolve = func_data[3];
+    const resolve_element_env = func_data[4];
+    const idx = JS_ToInt32Free(ctx, func_data[1]);
+    if (JS_IsException(idx))
+        return JS_EXCEPTION;
+    if (alreadyCalled)
+        return undefined;
+    func_data[0] = true;
+    let obj;
+    if (resolve_type === PROMISE_MAGIC_allSettled) {
+        obj = JS_NewObject(ctx);
+        if (JS_IsException(obj))
+            return JS_EXCEPTION;
+        if (JS_DefinePropertyValue(ctx, obj, JS_ATOM_status, is_reject ? 'rejected' : 'fulfilled', JS_PROP_C_W_E) < 0)
+            return JS_EXCEPTION;
+        if (JS_DefinePropertyValue(ctx, obj, is_reject ? JS_ATOM_reason : JS_ATOM_value, argv[0], JS_PROP_C_W_E) < 0)
+            return JS_EXCEPTION;
+    }
+    else {
+        obj = argv[0];
+    }
+    if (JS_DefinePropertyValueUint32(ctx, values, idx, obj, JS_PROP_C_W_E) < 0)
+        return JS_EXCEPTION;
+    const is_zero = remainingElementsCount_add(ctx, resolve_element_env, -1);
+    if (is_zero < 0)
+        return JS_EXCEPTION;
+    if (is_zero) {
+        let ret;
+        if (resolve_type === PROMISE_MAGIC_any) {
+            const error = js_aggregate_error_constructor(ctx, values);
+            if (JS_IsException(error))
+                return JS_EXCEPTION;
+            ret = JS_Call(ctx, resolve, undefined, [error]);
+        }
+        else {
+            ret = JS_Call(ctx, resolve, undefined, [values]);
+        }
+        if (JS_IsException(ret))
+            return ret;
+    }
+    return undefined;
+}
+/* magic = 0: Promise.all 1: Promise.allSettled 2: Promise.any */
+function js_promise_all(ctx, this_val, argv, magic) {
+    const is_promise_any = (magic === PROMISE_MAGIC_any);
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const resolving_funcs = [undefined, undefined];
+    const result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
+    if (JS_IsException(result_promise))
+        return result_promise;
+    const fail_reject = () => {
+        const error = JS_GetException(ctx);
+        const ret = JS_Call(ctx, resolving_funcs[1], undefined, [error]);
+        if (JS_IsException(ret))
+            return JS_EXCEPTION;
+        return result_promise;
+    };
+    const promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
+    if (JS_IsException(promise_resolve) || check_function(ctx, promise_resolve))
+        return fail_reject();
+    const iter = JS_GetIterator(ctx, argv[0], false);
+    if (JS_IsException(iter))
+        return fail_reject();
+    const next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(next_method))
+        return fail_reject();
+    const values = JS_NewArray(ctx);
+    if (JS_IsException(values))
+        return fail_reject();
+    const resolve_element_env = JS_NewArray(ctx);
+    if (JS_IsException(resolve_element_env))
+        return fail_reject();
+    /* remainingElementsCount field */
+    if (JS_DefinePropertyValueUint32(ctx, resolve_element_env, 0, 1, JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
+        return fail_reject();
+    const fail_reject1 = () => {
+        JS_IteratorClose(ctx, iter, true);
+        return fail_reject();
+    };
+    let index = 0;
+    const pdone = { done: 0 };
+    for (;;) {
+        /* XXX: conformance: should close the iterator if error on 'done'
+           access, but not on 'value' access */
+        const item = JS_IteratorNext(ctx, iter, next_method, [], pdone);
+        if (JS_IsException(item))
+            return fail_reject();
+        if (pdone.done)
+            break;
+        const next_promise = JS_Call(ctx, promise_resolve, this_val, [item]);
+        if (JS_IsException(next_promise))
+            return fail_reject1();
+        const resolve_element_data = [false, index, values, resolving_funcs[is_promise_any ? 1 : 0], resolve_element_env];
+        let resolve_element = JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1, magic, resolve_element_data);
+        if (JS_IsException(resolve_element))
+            return fail_reject1();
+        /* the data array must be shared between the resolve and reject functions */
+        const shared_data = JS_GetOpaque(resolve_element, 15 /* JSClassID.C_FUNCTION_DATA */).data;
+        let reject_element;
+        if (magic === PROMISE_MAGIC_allSettled) {
+            reject_element = JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1, magic | 4, shared_data);
+            if (JS_IsException(reject_element))
+                return fail_reject1();
+            JS_GetOpaque(reject_element, 15 /* JSClassID.C_FUNCTION_DATA */).data = shared_data;
+        }
+        else if (magic === PROMISE_MAGIC_any) {
+            if (JS_DefinePropertyValueUint32(ctx, values, index, undefined, JS_PROP_C_W_E) < 0)
+                return fail_reject1();
+            reject_element = resolve_element;
+            resolve_element = resolving_funcs[0];
+        }
+        else {
+            reject_element = resolving_funcs[1];
+        }
+        if (remainingElementsCount_add(ctx, resolve_element_env, 1) < 0)
+            return fail_reject1();
+        const ret = JS_Invoke(ctx, next_promise, JS_ATOM_then, [resolve_element, reject_element]);
+        if (JS_IsException(ret))
+            return fail_reject1();
+        index++;
+    }
+    const is_zero = remainingElementsCount_add(ctx, resolve_element_env, -1);
+    if (is_zero < 0)
+        return fail_reject();
+    if (is_zero) {
+        let vals = values;
+        if (magic === PROMISE_MAGIC_any) {
+            const error = js_aggregate_error_constructor(ctx, values);
+            if (JS_IsException(error))
+                return fail_reject();
+            vals = error;
+        }
+        const ret = JS_Call(ctx, resolving_funcs[is_promise_any ? 1 : 0], undefined, [vals]);
+        if (JS_IsException(ret))
+            return fail_reject();
+    }
+    return result_promise;
+}
+function js_promise_race(ctx, this_val, argv) {
+    if (!JS_IsObject(this_val))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const resolving_funcs = [undefined, undefined];
+    const result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
+    if (JS_IsException(result_promise))
+        return result_promise;
+    const fail_reject = () => {
+        const error = JS_GetException(ctx);
+        const ret = JS_Call(ctx, resolving_funcs[1], undefined, [error]);
+        if (JS_IsException(ret))
+            return JS_EXCEPTION;
+        return result_promise;
+    };
+    const promise_resolve = JS_GetProperty(ctx, this_val, JS_ATOM_resolve);
+    if (JS_IsException(promise_resolve) || check_function(ctx, promise_resolve))
+        return fail_reject();
+    const iter = JS_GetIterator(ctx, argv[0], false);
+    if (JS_IsException(iter))
+        return fail_reject();
+    const next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
+    if (JS_IsException(next_method))
+        return fail_reject();
+    const pdone = { done: 0 };
+    for (;;) {
+        const item = JS_IteratorNext(ctx, iter, next_method, [], pdone);
+        if (JS_IsException(item))
+            return fail_reject();
+        if (pdone.done)
+            break;
+        const next_promise = JS_Call(ctx, promise_resolve, this_val, [item]);
+        if (JS_IsException(next_promise)) {
+            JS_IteratorClose(ctx, iter, true);
+            return fail_reject();
+        }
+        const ret = JS_Invoke(ctx, next_promise, JS_ATOM_then, [resolving_funcs[0], resolving_funcs[1]]);
+        if (JS_IsException(ret)) {
+            JS_IteratorClose(ctx, iter, true);
+            return fail_reject();
+        }
+    }
+    return result_promise;
+}
+/* PerformPromiseThen: resolve_reject = [onFulfilled, onRejected],
+   cap_resolving_funcs = [resolve, reject] of the derived promise (may be undefined) */
+export function perform_promise_then(ctx, promise, resolve_reject, cap_resolving_funcs) {
+    const s = JS_GetOpaque(promise, 45 /* JSClassID.PROMISE */);
+    const rd_array = [];
+    for (let i = 0; i < 2; i++) {
+        let handler = resolve_reject[i];
+        if (!JS_IsFunction(ctx, handler))
+            handler = undefined;
+        rd_array.push(new JSPromiseReactionData([cap_resolving_funcs[0], cap_resolving_funcs[1]], handler));
+    }
+    if (s.promise_state === 0 /* JSPromiseState.PENDING */) {
+        s.promise_reactions[0].push(rd_array[0]);
+        s.promise_reactions[1].push(rd_array[1]);
+    }
+    else {
+        if (s.promise_state === 2 /* JSPromiseState.REJECTED */ && !s.is_handled) {
+            const rt = ctx.rt;
+            if (rt.host_promise_rejection_tracker) {
+                rt.host_promise_rejection_tracker(ctx, promise, s.promise_result, true, rt.host_promise_rejection_tracker_opaque);
+            }
+        }
+        const i = s.promise_state === 2 /* JSPromiseState.REJECTED */ ? 1 : 0;
+        const rd = rd_array[i];
+        JS_EnqueueJob(ctx, promise_reaction_job, [rd.resolving_funcs[0], rd.resolving_funcs[1], rd.handler, i !== 0, s.promise_result]);
+    }
+    s.is_handled = true;
+    return 0;
+}
+export function JS_SpeciesConstructor(ctx, obj, defaultConstructor) {
+    if (!JS_IsObject(obj))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const ctor = JS_GetProperty(ctx, obj, JS_ATOM_constructor);
+    if (JS_IsException(ctor))
+        return ctor;
+    if (JS_IsUndefined(ctor))
+        return defaultConstructor;
+    if (!JS_IsObject(ctor))
+        return JS_ThrowTypeErrorNotAnObject(ctx);
+    const species = JS_GetProperty(ctx, ctor, JS_ATOM_Symbol_species);
+    if (JS_IsException(species))
+        return species;
+    if (species === undefined || species === null)
+        return defaultConstructor;
+    if (!JS_IsConstructor(ctx, species))
+        return JS_ThrowTypeError(ctx, 'not a constructor');
+    return species;
+}
+export function js_promise_then(ctx, this_val, argv) {
+    const s = JS_GetOpaque2(ctx, this_val, 45 /* JSClassID.PROMISE */);
+    if (!s)
+        return JS_EXCEPTION;
+    const ctor = JS_SpeciesConstructor(ctx, this_val, ctx.promise_ctor ?? undefined);
+    if (JS_IsException(ctor))
+        return ctor;
+    const resolving_funcs = [undefined, undefined];
+    const result_promise = js_new_promise_capability(ctx, resolving_funcs, ctor);
+    if (JS_IsException(result_promise))
+        return result_promise;
+    if (perform_promise_then(ctx, this_val, [argv[0], argv[1]], resolving_funcs))
+        return JS_EXCEPTION;
+    return result_promise;
+}
+function js_promise_catch(ctx, this_val, argv) {
+    return JS_Invoke(ctx, this_val, JS_ATOM_then, [undefined, argv[0]]);
+}
+function js_promise_finally_value_thunk(ctx, this_val, argv, magic, func_data) {
+    return func_data[0];
+}
+function js_promise_finally_thrower(ctx, this_val, argv, magic, func_data) {
+    return JS_Throw(ctx, func_data[0]);
+}
+function js_promise_then_finally_func(ctx, this_val, argv, magic, func_data) {
+    const ctor = func_data[0];
+    const onFinally = func_data[1];
+    const res = JS_Call(ctx, onFinally, undefined, []);
+    if (JS_IsException(res))
+        return res;
+    const promise = js_promise_resolve(ctx, ctor, [res], 0);
+    if (JS_IsException(promise))
+        return promise;
+    let then_func;
+    if (magic === 0)
+        then_func = JS_NewCFunctionData(ctx, js_promise_finally_value_thunk, 0, 0, [argv[0]]);
+    else
+        then_func = JS_NewCFunctionData(ctx, js_promise_finally_thrower, 0, 0, [argv[0]]);
+    if (JS_IsException(then_func))
+        return then_func;
+    return JS_Invoke(ctx, promise, JS_ATOM_then, [then_func]);
+}
+function js_promise_finally(ctx, this_val, argv) {
+    const onFinally = argv[0];
+    const ctor = JS_SpeciesConstructor(ctx, this_val, ctx.promise_ctor ?? undefined);
+    if (JS_IsException(ctor))
+        return ctor;
+    const then_funcs = [];
+    if (!JS_IsFunction(ctx, onFinally)) {
+        then_funcs.push(onFinally, onFinally);
+    }
+    else {
+        for (let i = 0; i < 2; i++) {
+            const f = JS_NewCFunctionData(ctx, js_promise_then_finally_func, 1, i, [ctor, onFinally]);
+            if (JS_IsException(f))
+                return JS_EXCEPTION;
+            then_funcs.push(f);
+        }
+    }
+    return JS_Invoke(ctx, this_val, JS_ATOM_then, then_funcs);
+}
+function js_get_this(ctx, this_val) { return this_val; }
+const js_promise_funcs = [
+    JS_CFUNC_MAGIC_DEF('resolve', 1, js_promise_resolve, 0),
+    JS_CFUNC_MAGIC_DEF('reject', 1, js_promise_resolve, 1),
+    JS_CFUNC_MAGIC_DEF('all', 1, js_promise_all, PROMISE_MAGIC_all),
+    JS_CFUNC_MAGIC_DEF('allSettled', 1, js_promise_all, PROMISE_MAGIC_allSettled),
+    JS_CFUNC_MAGIC_DEF('any', 1, js_promise_all, PROMISE_MAGIC_any),
+    JS_CFUNC_DEF('race', 1, js_promise_race),
+    JS_CFUNC_DEF('withResolvers', 0, js_promise_withResolvers),
+    JS_CGETSET_DEF(JS_ATOM_Symbol_species, js_get_this, null),
+];
+const js_promise_proto_funcs = [
+    JS_CFUNC_DEF('then', 2, js_promise_then),
+    JS_CFUNC_DEF('catch', 1, js_promise_catch),
+    JS_CFUNC_DEF('finally', 1, js_promise_finally),
+    JS_PROP_STRING_DEF(JS_ATOM_Symbol_toStringTag, 'Promise', JS_PROP_CONFIGURABLE),
+];
+/* Promise constructor and prototype (the AsyncFunction / AsyncGenerator
+   prototypes are installed by the interpreter module) */
+export function JS_AddIntrinsicPromise(ctx) {
+    const proto = JS_NewObject(ctx);
+    ctx.class_proto[45 /* JSClassID.PROMISE */] = proto;
+    JS_SetPropertyFunctionList(ctx, proto, js_promise_proto_funcs);
+    const obj1 = JS_NewCFunction2(ctx, js_promise_constructor, 'Promise', 1, 2 /* JSCFunctionEnum.constructor */, 0);
+    ctx.promise_ctor = obj1;
+    JS_SetPropertyFunctionList(ctx, obj1, js_promise_funcs);
+    JS_NewGlobalCConstructor2(ctx, obj1, 'Promise', proto);
+}
+//# sourceMappingURL=promise.js.map