1
const PENDING = "PENDING";
2
const FULFILLED = "FULFILLED";
3
const REJECTED = "REJECTED";
4

5
function isObject(value) {
6
    const type = typeof value;
7
    return value !== null && (type === "function" || type === "object");
8
}
9

10
function resolvePromise(promise, x, resolve, reject) {
11
    if (promise === x) {
12
        reject(new TypeError("Chaining cycle detected the promise #<Promise>"));
13
    }
14

15
    if (isObject(x)) {
16
        var then;
17

18
        try {
19
            then = x.then;
20
        } catch (error) {
21
            reject(error);
22
        }
23

24
        if (typeof then === "function") {
25
            var called = false;
26

27
            try {
28
                then.call(
29
                    x,
30
                    (y) => {
31
                        if (called) return;
32
                        called = true;
33
                        resolvePromise(promise, y, resolve, reject);
34
                    },
35
                    (r) => {
36
                        if (called) return;
37
                        called = true;
38
                        reject(r);
39
                    }
40
                );
41
            } catch (error) {
42
                if (called) return;
43
                called = true;
44
                reject(error);
45
            }
46
        } else {
47
            resolve(x);
48
        }
49
    } else {
50
        resolve(x);
51
    }
52
}
53

54
class MyPromise {
55
    status = PENDING;
56
    data = null;
57
    #onFulfilledCallbacks = [];
58
    #onRejectedCallbacks = [];
59

60
    #resolve = (value) => {
61
        if (this.status === PENDING) {
62
            this.status = FULFILLED;
63
            this.data = value;
64
            while (this.#onFulfilledCallbacks.length) {
65
                this.#onFulfilledCallbacks.shift()(value);
66
            }
67
        }
68
    };
69

70
    #reject = (reason) => {
71
        if (this.status === PENDING) {
72
            this.status = REJECTED;
73
            this.data = reason;
74
            while (this.#onRejectedCallbacks.length) {
75
                this.#onRejectedCallbacks.shift()(reason);
76
            }
77
        }
78
    };
79

80
    constructor(executor) {
81
        try {
82
            executor(this.#resolve, this.#reject);
83
        } catch (error) {
84
            this.#reject(error);
85
        }
86
    }
87

88
    then(onFulfilled, onRejected) {
89
        onFulfilled =
90
            typeof onFulfilled === "function" ? onFulfilled : (value) => value;
91
        onRejected =
92
            typeof onRejected === "function"
93
                ? onRejected
94
                : (reason) => {
95
                    throw reason;
96
                };
97

98
        const promise = new MyPromise((resolve, reject) => {
99
            const resolved = () => {
100
                queueMicrotask(() => {
101
                    try {
102
                        const x = onFulfilled(this.data);
103
                        resolvePromise(promise, x, resolve, reject);
104
                    } catch (error) {
105
                        reject(error);
106
                    }
107
                });
108
            };
109

110
            const rejected = () => {
111
                queueMicrotask(() => {
112
                    try {
113
                        const x = onRejected(this.data);
114
                        resolvePromise(promise, x, resolve, reject);
115
                    } catch (error) {
116
                        reject(error);
117
                    }
118
                });
119
            };
120

121
            if (this.status === PENDING) {
122
                this.#onFulfilledCallbacks.push(resolved);
123
                this.#onRejectedCallbacks.push(rejected);
124
            }
125

126
            if (this.status === FULFILLED) {
127
                resolved();
128
            }
129

130
            if (this.status === REJECTED) {
131
                rejected();
132
            }
133
        });
134

135
        return promise;
136
    }
137

138
    catch(onRejected) {
139
        return this.then(undefined, onRejected);
140
    }
141

142
    finally(onFinally) {
143
        return this.then(
144
            (value) => MyPromise.resolve(onFinally()).then(() => value),
145
            (reason) =>
146
                MyPromise.resolve(onFinally()).then(() => {
147
                    throw reason;
148
                })
149
        );
150
    }
151

152
    static resolve(value) {
153
        return new MyPromise((resolve, reject) => {
154
            value instanceof MyPromise ? value.then(resolve, reject) : resolve(value);
155
        });
156
    }
157

158
    static reject(reason) {
159
        return new MyPromise((resolve, reject) => {
160
            reject(reason);
161
        });
162
    }
163

164
    static withResolver() {
165
        const result = {};
166
        result.promise = new MyPromise(($$resolve, $$reject) => {
167
            result.resolve = $$resolve;
168
            result.reject = $$reject;
169
        });
170
        return result;
171
    }
172
}