@nktkas/hyperliquid 0.13.1 → 0.13.2

package/script/src/transports/websocket/reconnecting_websocket.js

@@ -1,374 +1,384 @@
-"use strict";
 // deno-lint-ignore-file no-explicit-any
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReconnectingWebSocket = void 0;
-/**
- * Simple FIFO (First In, First Out) buffer implementation.
- */
-class FIFOMessageBuffer {
-    constructor() {
-        Object.defineProperty(this, "messages", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-    }
-    push(data) {
-        this.messages.push(data);
-    }
-    shift() {
-        return this.messages.shift();
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
     }
-    clear() {
-        this.messages = [];
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
     }
-}
-/**
- * A WebSocket that automatically reconnects when disconnected.
- * Fully compatible with standard WebSocket API.
- */
-class ReconnectingWebSocket {
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ReconnectingWebSocket = void 0;
     /**
-     * Creates a new reconnecting WebSocket.
-     * @param url - The WebSocket URL to connect to.
-     * @param protocols - The WebSocket protocols to use.
-     * @param options - The configuration options.
+     * Simple FIFO (First In, First Out) buffer implementation.
      */
-    constructor(url, protocols, options) {
-        /** Controller for handling connection termination */
-        Object.defineProperty(this, "terminationController", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new AbortController()
-        });
-        /** WebSocket protocols */
-        Object.defineProperty(this, "protocols", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The underlying WebSocket instance */
-        Object.defineProperty(this, "socket", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Current number of reconnection attempts */
-        Object.defineProperty(this, "reconnectCount", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        /** Array of registered event listeners */
-        Object.defineProperty(this, "eventListeners", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        /** Configuration options */
-        Object.defineProperty(this, "reconnectOptions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** An AbortSignal that is triggered when the connection is permanently closed */
-        Object.defineProperty(this, "terminationSignal", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.terminationController.signal
-        });
-        Object.defineProperty(this, "CLOSED", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: WebSocket.CLOSED
-        });
-        Object.defineProperty(this, "CLOSING", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: WebSocket.CLOSING
-        });
-        Object.defineProperty(this, "CONNECTING", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: WebSocket.CONNECTING
-        });
-        Object.defineProperty(this, "OPEN", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: WebSocket.OPEN
-        });
-        this.reconnectOptions = {
-            maxRetries: options?.maxRetries ?? 3,
-            connectionTimeout: options?.connectionTimeout === undefined ? 10_000 : options.connectionTimeout,
-            connectionDelay: options?.connectionDelay ?? ((attempt) => Math.min(~~(1 << attempt) * 150, 10_000)),
-            shouldReconnect: options?.shouldReconnect ?? (() => true),
-            messageBuffer: options?.messageBuffer ?? new FIFOMessageBuffer(),
-            WebSocketConstructor: options?.WebSocketConstructor ?? WebSocket,
-        };
-        this.protocols = protocols;
-        this.socket = this.reconnectOptions.connectionTimeout
-            ? this.connectWithTimeout(url, this.protocols, this.reconnectOptions.connectionTimeout)
-            : new this.reconnectOptions.WebSocketConstructor(url, this.protocols);
-        this.initEventListeners();
-    }
-    /**
-     * Creates a WebSocket connection with timeout.
-     * @param url - The WebSocket URL to connect to.
-     * @param protocols - The WebSocket protocols to use.
-     * @param timeout - The connection timeout in ms.
-     * @returns A new WebSocket instance.
-     */
-    connectWithTimeout(url, protocols, timeout) {
-        const socket = new this.reconnectOptions.WebSocketConstructor(url, protocols);
-        const timeoutId = setTimeout(() => {
-            socket.removeEventListener("open", openHandler);
-            socket.removeEventListener("close", closeHandler);
-            socket.close(3008, "Timeout"); // https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
-        }, timeout);
-        const openHandler = () => {
-            socket.removeEventListener("close", closeHandler);
-            clearTimeout(timeoutId);
-        };
-        const closeHandler = () => {
-            socket.removeEventListener("open", openHandler);
-            clearTimeout(timeoutId);
-        };
-        socket.addEventListener("open", openHandler, { once: true });
-        socket.addEventListener("close", closeHandler, { once: true });
-        return socket;
+    class FIFOMessageBuffer {
+        constructor() {
+            Object.defineProperty(this, "messages", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: []
+            });
+        }
+        push(data) {
+            this.messages.push(data);
+        }
+        shift() {
+            return this.messages.shift();
+        }
+        clear() {
+            this.messages = [];
+        }
     }
     /**
-     * Initializes the internal event listeners for the WebSocket.
+     * A WebSocket that automatically reconnects when disconnected.
+     * Fully compatible with standard WebSocket API.
      */
-    initEventListeners() {
-        this.socket.addEventListener("open", () => {
-            // Reset reconnection count
-            this.reconnectCount = 0;
-            // Send all buffered messages
-            let message;
-            while ((message = this.reconnectOptions.messageBuffer.shift()) !== undefined) {
-                this.socket.send(message);
-            }
-        }, { once: true });
-        this.socket.addEventListener("close", async (event) => {
-            try {
-                // If the termination signal is already aborted, do not attempt to reconnect
-                if (this.terminationSignal.aborted)
-                    return;
-                // Check if reconnection should be attempted
-                if (++this.reconnectCount > this.reconnectOptions.maxRetries) {
-                    this.cleanup(new Error("RECONNECTION_LIMIT_REACHED", { cause: event }));
-                    return;
+    class ReconnectingWebSocket {
+        /**
+         * Creates a new reconnecting WebSocket.
+         * @param url - The WebSocket URL to connect to.
+         * @param protocols - The WebSocket protocols to use.
+         * @param options - The configuration options.
+         */
+        constructor(url, protocols, options) {
+            /** Controller for handling connection termination */
+            Object.defineProperty(this, "terminationController", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: new AbortController()
+            });
+            /** WebSocket protocols */
+            Object.defineProperty(this, "protocols", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            /** The underlying WebSocket instance */
+            Object.defineProperty(this, "socket", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            /** Current number of reconnection attempts */
+            Object.defineProperty(this, "reconnectCount", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 0
+            });
+            /** Array of registered event listeners */
+            Object.defineProperty(this, "eventListeners", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: []
+            });
+            /** Configuration options */
+            Object.defineProperty(this, "reconnectOptions", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            /** An AbortSignal that is triggered when the connection is permanently closed */
+            Object.defineProperty(this, "terminationSignal", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: this.terminationController.signal
+            });
+            Object.defineProperty(this, "CLOSED", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.CLOSED
+            });
+            Object.defineProperty(this, "CLOSING", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.CLOSING
+            });
+            Object.defineProperty(this, "CONNECTING", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.CONNECTING
+            });
+            Object.defineProperty(this, "OPEN", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: WebSocket.OPEN
+            });
+            this.reconnectOptions = {
+                maxRetries: options?.maxRetries ?? 3,
+                connectionTimeout: options?.connectionTimeout === undefined ? 10_000 : options.connectionTimeout,
+                connectionDelay: options?.connectionDelay ?? ((attempt) => Math.min(~~(1 << attempt) * 150, 10_000)),
+                shouldReconnect: options?.shouldReconnect ?? (() => true),
+                messageBuffer: options?.messageBuffer ?? new FIFOMessageBuffer(),
+                WebSocketConstructor: options?.WebSocketConstructor ?? WebSocket,
+            };
+            this.protocols = protocols;
+            this.socket = this.reconnectOptions.connectionTimeout
+                ? this.connectWithTimeout(url, this.protocols, this.reconnectOptions.connectionTimeout)
+                : new this.reconnectOptions.WebSocketConstructor(url, this.protocols);
+            this.initEventListeners();
+        }
+        /**
+         * Creates a WebSocket connection with timeout.
+         * @param url - The WebSocket URL to connect to.
+         * @param protocols - The WebSocket protocols to use.
+         * @param timeout - The connection timeout in ms.
+         * @returns A new WebSocket instance.
+         */
+        connectWithTimeout(url, protocols, timeout) {
+            const socket = new this.reconnectOptions.WebSocketConstructor(url, protocols);
+            const timeoutId = setTimeout(() => {
+                socket.removeEventListener("open", openHandler);
+                socket.removeEventListener("close", closeHandler);
+                socket.close(3008, "Timeout"); // https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
+            }, timeout);
+            const openHandler = () => {
+                socket.removeEventListener("close", closeHandler);
+                clearTimeout(timeoutId);
+            };
+            const closeHandler = () => {
+                socket.removeEventListener("open", openHandler);
+                clearTimeout(timeoutId);
+            };
+            socket.addEventListener("open", openHandler, { once: true });
+            socket.addEventListener("close", closeHandler, { once: true });
+            return socket;
+        }
+        /**
+         * Initializes the internal event listeners for the WebSocket.
+         */
+        initEventListeners() {
+            this.socket.addEventListener("open", () => {
+                // Reset reconnection count
+                this.reconnectCount = 0;
+                // Send all buffered messages
+                let message;
+                while ((message = this.reconnectOptions.messageBuffer.shift()) !== undefined) {
+                    this.socket.send(message);
+                }
+            }, { once: true });
+            this.socket.addEventListener("close", async (event) => {
+                try {
+                    // If the termination signal is already aborted, do not attempt to reconnect
+                    if (this.terminationSignal.aborted)
+                        return;
+                    // Check if reconnection should be attempted
+                    if (++this.reconnectCount > this.reconnectOptions.maxRetries) {
+                        this.cleanup(new Error("RECONNECTION_LIMIT_REACHED", { cause: event }));
+                        return;
+                    }
+                    const userDecision = await this.reconnectOptions.shouldReconnect(event);
+                    if (this.terminationSignal.aborted)
+                        return; // Check again after the await
+                    if (!userDecision) {
+                        this.cleanup(new Error("RECONNECTION_STOPPED_BY_USER", { cause: event }));
+                        return;
+                    }
+                    // Delay before reconnecting
+                    const delay = typeof this.reconnectOptions.connectionDelay === "number"
+                        ? this.reconnectOptions.connectionDelay
+                        : await this.reconnectOptions.connectionDelay(this.reconnectCount);
+                    if (this.terminationSignal.aborted)
+                        return; // Check again after the await
+                    await sleep(delay, this.terminationSignal);
+                    // Reconnect the socket
+                    this.socket = this.reconnectOptions.connectionTimeout
+                        ? this.connectWithTimeout(this.url, this.protocols, this.reconnectOptions.connectionTimeout)
+                        : new this.reconnectOptions.WebSocketConstructor(this.url, this.protocols);
+                    // Reconnect all listeners
+                    this.initEventListeners();
+                    this.eventListeners.forEach(({ type, listenerProxy, options }) => {
+                        this.socket.addEventListener(type, listenerProxy, options);
+                    });
                 }
-                const userDecision = await this.reconnectOptions.shouldReconnect(event);
-                if (this.terminationSignal.aborted)
-                    return; // Check again after the await
-                if (!userDecision) {
-                    this.cleanup(new Error("RECONNECTION_STOPPED_BY_USER", { cause: event }));
-                    return;
+                catch (error) {
+                    this.cleanup(new Error("RECONNECTION_ERROR", { cause: { error, event } }));
                 }
-                // Delay before reconnecting
-                const delay = typeof this.reconnectOptions.connectionDelay === "number"
-                    ? this.reconnectOptions.connectionDelay
-                    : await this.reconnectOptions.connectionDelay(this.reconnectCount);
-                if (this.terminationSignal.aborted)
-                    return; // Check again after the await
-                await sleep(delay, this.terminationSignal);
-                // Reconnect the socket
-                this.socket = this.reconnectOptions.connectionTimeout
-                    ? this.connectWithTimeout(this.url, this.protocols, this.reconnectOptions.connectionTimeout)
-                    : new this.reconnectOptions.WebSocketConstructor(this.url, this.protocols);
-                // Reconnect all listeners
-                this.initEventListeners();
-                this.eventListeners.forEach(({ type, listenerProxy, options }) => {
-                    this.socket.addEventListener(type, listenerProxy, options);
-                });
+            }, { once: true });
+        }
+        /**
+         * Clean up internal resources.
+         * @param reason - The reason for cleanup.
+         */
+        cleanup(reason) {
+            this.terminationController.abort(reason);
+            this.reconnectOptions.messageBuffer.clear();
+            this.eventListeners = [];
+        }
+        /**
+         * Check if two event listeners are the same (just like EventTarget).
+         * @param a - First event listener configuration.
+         * @param b - Second event listener configuration.
+         * @returns True if the listeners match.
+         */
+        isListenerMatch(a, b) {
+            const aCapture = Boolean(typeof a.options === "object" ? a.options.capture : a.options);
+            const bCapture = Boolean(typeof b.options === "object" ? b.options.capture : b.options);
+            return a.type === b.type && a.listener === b.listener && aCapture === bCapture;
+        }
+        // WebSocket property implementations
+        get url() {
+            return this.socket.url;
+        }
+        get readyState() {
+            return this.socket.readyState;
+        }
+        get bufferedAmount() {
+            return this.socket.bufferedAmount;
+        }
+        get extensions() {
+            return this.socket.extensions;
+        }
+        get protocol() {
+            return this.socket.protocol;
+        }
+        get binaryType() {
+            return this.socket.binaryType;
+        }
+        set binaryType(value) {
+            this.socket.binaryType = value;
+        }
+        get onclose() {
+            return this.socket.onclose;
+        }
+        set onclose(value) {
+            this.socket.onclose = value;
+        }
+        get onerror() {
+            return this.socket.onerror;
+        }
+        set onerror(value) {
+            this.socket.onerror = value;
+        }
+        get onmessage() {
+            return this.socket.onmessage;
+        }
+        set onmessage(value) {
+            this.socket.onmessage = value;
+        }
+        get onopen() {
+            return this.socket.onopen;
+        }
+        set onopen(value) {
+            this.socket.onopen = value;
+        }
+        /**
+         * @param permanently - If true, the connection will be permanently closed. Default is true.
+         */
+        close(code, reason, permanently = true) {
+            if (permanently)
+                this.cleanup(new Error("USER_INITIATED_CLOSE"));
+            this.socket.close(code, reason);
+        }
+        /**
+         * @note If the connection is not open, the data will be buffered and sent when the connection is established.
+         */
+        send(data) {
+            if (this.socket.readyState !== WebSocket.OPEN && !this.terminationSignal.aborted) {
+                this.reconnectOptions.messageBuffer.push(data);
             }
-            catch (error) {
-                this.cleanup(new Error("RECONNECTION_ERROR", { cause: { error, event } }));
+            else {
+                this.socket.send(data);
             }
-        }, { once: true });
-    }
-    /**
-     * Clean up internal resources.
-     * @param reason - The reason for cleanup.
-     */
-    cleanup(reason) {
-        this.terminationController.abort(reason);
-        this.reconnectOptions.messageBuffer.clear();
-        this.eventListeners = [];
-    }
-    /**
-     * Check if two event listeners are the same (just like EventTarget).
-     * @param a - First event listener configuration.
-     * @param b - Second event listener configuration.
-     * @returns True if the listeners match.
-     */
-    isListenerMatch(a, b) {
-        const aCapture = Boolean(typeof a.options === "object" ? a.options.capture : a.options);
-        const bCapture = Boolean(typeof b.options === "object" ? b.options.capture : b.options);
-        return a.type === b.type && a.listener === b.listener && aCapture === bCapture;
-    }
-    // WebSocket property implementations
-    get url() {
-        return this.socket.url;
-    }
-    get readyState() {
-        return this.socket.readyState;
-    }
-    get bufferedAmount() {
-        return this.socket.bufferedAmount;
-    }
-    get extensions() {
-        return this.socket.extensions;
-    }
-    get protocol() {
-        return this.socket.protocol;
-    }
-    get binaryType() {
-        return this.socket.binaryType;
-    }
-    set binaryType(value) {
-        this.socket.binaryType = value;
-    }
-    get onclose() {
-        return this.socket.onclose;
-    }
-    set onclose(value) {
-        this.socket.onclose = value;
-    }
-    get onerror() {
-        return this.socket.onerror;
-    }
-    set onerror(value) {
-        this.socket.onerror = value;
-    }
-    get onmessage() {
-        return this.socket.onmessage;
-    }
-    set onmessage(value) {
-        this.socket.onmessage = value;
-    }
-    get onopen() {
-        return this.socket.onopen;
-    }
-    set onopen(value) {
-        this.socket.onopen = value;
-    }
-    /**
-     * @param permanently - If true, the connection will be permanently closed. Default is true.
-     */
-    close(code, reason, permanently = true) {
-        if (permanently)
-            this.cleanup(new Error("USER_INITIATED_CLOSE"));
-        this.socket.close(code, reason);
-    }
-    /**
-     * @note If the connection is not open, the data will be buffered and sent when the connection is established.
-     */
-    send(data) {
-        if (this.socket.readyState !== WebSocket.OPEN && !this.terminationSignal.aborted) {
-            this.reconnectOptions.messageBuffer.push(data);
-        }
-        else {
-            this.socket.send(data);
         }
-    }
-    addEventListener(type, listener, options) {
-        // Check if the listener is already added
-        const exists = this.eventListeners.some((e) => this.isListenerMatch(e, { type, listener, options }));
-        if (exists)
-            return;
-        // Wrap the original listener to follow the once option when reconnecting
-        const listenerProxy = (event) => {
-            try {
-                if (typeof listener === "function") {
-                    listener.call(this, event);
-                }
-                else {
-                    listener.handleEvent(event);
+        addEventListener(type, listener, options) {
+            // Check if the listener is already added
+            const exists = this.eventListeners.some((e) => this.isListenerMatch(e, { type, listener, options }));
+            if (exists)
+                return;
+            // Wrap the original listener to follow the once option when reconnecting
+            const listenerProxy = (event) => {
+                try {
+                    if (typeof listener === "function") {
+                        listener.call(this, event);
+                    }
+                    else {
+                        listener.handleEvent(event);
+                    }
                 }
-            }
-            finally {
-                if (typeof options === "object" && options.once === true) {
-                    const index = this.eventListeners.findIndex((e) => this.isListenerMatch(e, { type, listener, options }));
-                    if (index !== -1)
-                        this.eventListeners.splice(index, 1);
+                finally {
+                    if (typeof options === "object" && options.once === true) {
+                        const index = this.eventListeners.findIndex((e) => this.isListenerMatch(e, { type, listener, options }));
+                        if (index !== -1)
+                            this.eventListeners.splice(index, 1);
+                    }
                 }
+            };
+            this.eventListeners.push({ type, listener, options, listenerProxy });
+            this.socket.addEventListener(type, listenerProxy, options);
+        }
+        removeEventListener(type, listener, options) {
+            const index = this.eventListeners.findIndex((e) => this.isListenerMatch(e, { type, listener, options }));
+            if (index !== -1) {
+                const { listenerProxy } = this.eventListeners[index];
+                this.socket.removeEventListener(type, listenerProxy, options);
+                this.eventListeners.splice(index, 1);
             }
-        };
-        this.eventListeners.push({ type, listener, options, listenerProxy });
-        this.socket.addEventListener(type, listenerProxy, options);
-    }
-    removeEventListener(type, listener, options) {
-        const index = this.eventListeners.findIndex((e) => this.isListenerMatch(e, { type, listener, options }));
-        if (index !== -1) {
-            const { listenerProxy } = this.eventListeners[index];
-            this.socket.removeEventListener(type, listenerProxy, options);
-            this.eventListeners.splice(index, 1);
+        }
+        dispatchEvent(event) {
+            return this.socket.dispatchEvent(event);
         }
     }
-    dispatchEvent(event) {
-        return this.socket.dispatchEvent(event);
+    exports.ReconnectingWebSocket = ReconnectingWebSocket;
+    Object.defineProperty(ReconnectingWebSocket, "CLOSED", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.CLOSED
+    });
+    Object.defineProperty(ReconnectingWebSocket, "CLOSING", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.CLOSING
+    });
+    Object.defineProperty(ReconnectingWebSocket, "CONNECTING", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.CONNECTING
+    });
+    Object.defineProperty(ReconnectingWebSocket, "OPEN", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: WebSocket.OPEN
+    });
+    /**
+     * Returns a promise that resolves after the specified number of ms,
+     * or rejects as soon as the given signal is aborted.
+     * @param ms - The number of ms to sleep.
+     * @param signal - An optional abort signal.
+     * @returns A promise that resolves after the specified delay.
+     */
+    function sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                return reject(signal.reason);
+            }
+            const onAbort = function () {
+                clearTimeout(timer);
+                reject(this.reason);
+            };
+            const timer = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
     }
-}
-exports.ReconnectingWebSocket = ReconnectingWebSocket;
-Object.defineProperty(ReconnectingWebSocket, "CLOSED", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: WebSocket.CLOSED
 });
-Object.defineProperty(ReconnectingWebSocket, "CLOSING", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: WebSocket.CLOSING
-});
-Object.defineProperty(ReconnectingWebSocket, "CONNECTING", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: WebSocket.CONNECTING
-});
-Object.defineProperty(ReconnectingWebSocket, "OPEN", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: WebSocket.OPEN
-});
-/**
- * Returns a promise that resolves after the specified number of ms,
- * or rejects as soon as the given signal is aborted.
- * @param ms - The number of ms to sleep.
- * @param signal - An optional abort signal.
- * @returns A promise that resolves after the specified delay.
- */
-function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            return reject(signal.reason);
-        }
-        const onAbort = function () {
-            clearTimeout(timer);
-            reject(this.reason);
-        };
-        const timer = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}