@nktkas/hyperliquid/script/deps/jsr.io/@std/async/1.0.13/delay.js

Unofficial Hyperliquid API SDK for all major JS runtimes, written in TypeScript and provided with tests

// Copyright 2018-2025 the Deno authors. MIT license.
// This module is browser compatible.
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.delay = delay;
    /**
     * Resolve a {@linkcode Promise} after a given amount of milliseconds.
     *
     * @throws {DOMException} If the optional signal is aborted before the delay
     * duration, and `signal.reason` is undefined.
     * @param ms Duration in milliseconds for how long the delay should last.
     * @param options Additional options.
     *
     * @example Basic usage
     * ```ts no-assert
     * import { delay } from "@std/async/delay";
     *
     * // ...
     * const delayedPromise = delay(100);
     * const result = await delayedPromise;
     * // ...
     * ```
     *
     * @example Disable persistence
     *
     * Setting `persistent` to `false` will allow the process to continue to run as
     * long as the timer exists.
     *
     * ```ts no-assert ignore
     * import { delay } from "@std/async/delay";
     *
     * // ...
     * await delay(100, { persistent: false });
     * // ...
     * ```
     */
    function delay(ms, options = {}) {
        const { signal, persistent = true } = options;
        if (signal?.aborted)
            return Promise.reject(signal.reason);
        return new Promise((resolve, reject) => {
            const abort = () => {
                clearTimeout(i);
                reject(signal?.reason);
            };
            const done = () => {
                signal?.removeEventListener("abort", abort);
                resolve();
            };
            const i = setTimeout(done, ms);
            signal?.addEventListener("abort", abort, { once: true });
            if (persistent === false) {
                try {
                    // @ts-ignore For browser compatibility
                    Deno.unrefTimer(i);
                }
                catch (error) {
                    if (!(error instanceof ReferenceError)) {
                        throw error;
                    }
                    // deno-lint-ignore no-console
                    console.error("`persistent` option is only available in Deno");
                }
            }
        });
    }
});