@oscarpalmer/timer 0.37.0 → 0.38.1

package/dist/timer.full.js

@@ -1,83 +1,66 @@
 function calculate$1() {
-    return new Promise(resolve => {
-        const values = [];
-        let last;
-        function step(now) {
-            if (last != null) {
-                values.push(now - last);
-            }
-            last = now;
-            if (values.length >= 10) {
-                const median = values
-                    .sort()
-                    .slice(2, -2)
-                    .reduce((first, second) => first + second, 0) /
-                    (values.length - 4);
-                resolve(median);
-            }
-            else {
-                requestAnimationFrame(step);
-            }
-        }
-        requestAnimationFrame(step);
-    });
+	return new Promise((resolve) => {
+		const values = [];
+		let last;
+		function step(now) {
+			if (last != null) values.push(now - last);
+			last = now;
+			if (values.length >= 10) resolve(values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - 4));
+			else requestAnimationFrame(step);
+		}
+		requestAnimationFrame(step);
+	});
 }
-//
-const defaultTimeout = 30_000;
 /**
- * A set of all active timers
- */
-const activeTimers = new Set();
+* Buffer value to use when evaluating if a specific time is within a certain range
+*/
+const BUFFER_INTERVAL = 5;
+const DEFAULT_TIMEOUT = 3e4;
 /**
- * Buffer value to use when evaluating if a specific time is within a certain range
- */
-const intervalBuffer = 5;
+* Message to show when a when-timer is destroyed
+*/
+const MESSAGE_DESTROYED = "Timer has already been destroyed";
 /**
- * Message to show when a when-timer is destroyed
- */
-const destroyedMessage = 'Timer has already been destroyed';
+* Message to show when a when-timer is started
+*/
+const MESSAGE_STARTED = "Timer has already been started";
 /**
- * A set of timers that were paused due to the document being hidden
- */
-const hiddenTimers = new Set();
+* A set of all active timers
+*/
+const TIMERS_ACTIVE = /* @__PURE__ */ new Set();
 /**
- * Message to show when a when-timer is started
- */
-const startedMessage = 'Timer has already been started';
-const TYPE_REPEAT = 'repeat';
-const TYPE_WAIT = 'wait';
-const TYPE_WHEN = 'when';
-const WORK_CONTINUE = 'continue';
-const WORK_PAUSE = 'pause';
-const WORK_RESTART = 'restart';
-const WORK_START = 'start';
-const WORK_STOP = 'stop';
-//
+* A set of timers that were paused due to the document being hidden
+*/
+const TIMERS_HIDDEN = /* @__PURE__ */ new Set();
+const TYPE_REPEAT = "repeat";
+const TYPE_WAIT = "wait";
+const TYPE_WHEN = "when";
+const WORK_CONTINUE = "continue";
+const WORK_PAUSE = "pause";
+const WORK_RESTART = "restart";
+const WORK_START = "start";
+const WORK_STOP = "stop";
 /**
- * A calculated average of the refresh rate of the display _(in milliseconds)_
- */
-let milliseconds = 1000 / 60;
-calculate$1().then(value => {
-    milliseconds = value;
+* A calculated average of the refresh rate of the display _(in milliseconds)_
+*/
+let MILLISECONDS = 1e3 / 60;
+calculate$1().then((value) => {
+	MILLISECONDS = value;
 });
 
-if (globalThis._oscarpalmer_timers == null) {
-    Object.defineProperty(globalThis, '_oscarpalmer_timers', {
-        get() {
-            return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
-        },
-    });
-}
+if (globalThis._oscarpalmer_timers == null) Object.defineProperty(globalThis, "_oscarpalmer_timers", { get() {
+	return globalThis._oscarpalmer_timer_debug ? [...TIMERS_ACTIVE] : [];
+} });
 /* istanbul ignore next */
-document.addEventListener('visibilitychange', () => {
-    const from = document.hidden ? activeTimers : hiddenTimers;
-    const method = document.hidden ? WORK_PAUSE : WORK_CONTINUE;
-    const to = document.hidden ? hiddenTimers : activeTimers;
-    for (const timer of from) {
-        timer[method]();
-        to.add(timer);
-    }
-    from.clear();
+document.addEventListener("visibilitychange", () => {
+	const from = document.hidden ? TIMERS_ACTIVE : TIMERS_HIDDEN;
+	const method = document.hidden ? WORK_PAUSE : WORK_CONTINUE;
+	const to = document.hidden ? TIMERS_HIDDEN : TIMERS_ACTIVE;
+	for (const timer of from) {
+		timer[method]();
+		to.add(timer);
+	}
+	from.clear();
 });
 
 function calculate() {
@@ -87,446 +70,448 @@ function calculate() {
 		function step(now) {
 			if (last != null) values.push(now - last);
 			last = now;
-			if (values.length >= 10) {
-				const median = values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - 4);
-				resolve(median);
-			} else requestAnimationFrame(step);
+			if (values.length >= CALCULATION_TOTAL) resolve(values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - CALCULATION_TRIM));
+			else requestAnimationFrame(step);
 		}
 		requestAnimationFrame(step);
 	});
 }
 function noop() {}
+var CALCULATION_TOTAL = 10;
+var CALCULATION_TRIM = 4;
+let milliseconds = 1e3 / 60;
 calculate().then((value) => {
+	milliseconds = value;
 });
 
+var TYPED_ARRAYS = new Set([
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	BigInt64Array,
+	BigUint64Array
+]);
+
 function getCallback(value) {
-    return typeof value === 'function' ? value : noop;
+	return typeof value === "function" ? value : noop;
 }
 function getValidTimeout(value) {
-    return typeof value === 'number' && value > 0 ? value : defaultTimeout;
+	return typeof value === "number" && value > 0 ? value : DEFAULT_TIMEOUT;
 }
 function getValidNumber(value, defaultValue) {
-    const actualDefault = defaultValue ?? 0;
-    return typeof value === 'number' && value > actualDefault
-        ? value
-        : actualDefault;
+	const actualDefault = defaultValue ?? 0;
+	return typeof value === "number" && value > actualDefault ? value : actualDefault;
 }
 
 /**
- * Create a delayed promise that resolves after a certain amount of time _(in milliseconds; defaults to screen refresh rate)_
- */
+* Create a delayed promise that resolves after a certain amount of time
+* @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
+* @returns A promise that resolves after the delay
+*/
 function delay(time) {
-    return new Promise(resolve => {
-        const interval = getValidNumber(time, milliseconds);
-        let start;
-        function step(now) {
-            start ??= now;
-            if (interval === milliseconds ||
-                now - start >= interval - intervalBuffer) {
-                resolve();
-            }
-            else {
-                requestAnimationFrame(step);
-            }
-        }
-        requestAnimationFrame(step);
-    });
+	return new Promise((resolve) => {
+		const interval = getValidNumber(time, MILLISECONDS);
+		let start;
+		function step(now) {
+			start ??= now;
+			if (interval === MILLISECONDS || now - start >= interval - BUFFER_INTERVAL) resolve();
+			else requestAnimationFrame(step);
+		}
+		requestAnimationFrame(step);
+	});
 }
 
 function is(names, value) {
-    return names.includes(value?.$timer);
+	return names.includes(value?.$timer);
 }
 /**
- * Is the value a repeating timer?
- */
+* Is the value a repeating timer?
+* @param value Value to check
+* @returns `true` if the value is a repeating timer
+*/
 function isRepeated(value) {
-    return is([TYPE_REPEAT], value);
+	return is([TYPE_REPEAT], value);
 }
 /**
- * Is the value a timer?
- */
+* Is the value a timer?
+* @param value Value to check
+* @returns `true` if the value is a timer
+*/
 function isTimer(value) {
-    return is([TYPE_REPEAT, TYPE_WAIT], value);
+	return is([TYPE_REPEAT, TYPE_WAIT], value);
 }
 /**
- * Is the value a waiting timer?
- */
+* Is the value a waiting timer?
+* @param value Value to check
+* @returns `true` if the value is a waiting timer
+*/
 function isWaited(value) {
-    return is([TYPE_WAIT], value);
+	return is([TYPE_WAIT], value);
 }
 /**
- * Is the value a conditional timer?
- */
+* Is the value a conditional timer?
+* @param value Value to check
+* @returns `true` if the value is a conditional timer
+*/
 function isWhen(value) {
-    return is([TYPE_WHEN], value) && typeof value.then === 'function';
+	return is([TYPE_WHEN], value) && typeof value.then === "function";
 }
 
-class TimerTrace extends Error {
-    constructor() {
-        super();
-        this.name = 'TimerTrace';
-    }
-}
+var TimerTrace = class extends Error {
+	constructor() {
+		super();
+		this.name = "TimerTrace";
+	}
+};
 
 function finish(timer, state, options, success) {
-    cancelAnimationFrame(state.frame);
-    activeTimers.delete(timer.instance);
-    state.active = false;
-    state.elapsed = 0;
-    state.frame = undefined;
-    if (timer.type === TYPE_WAIT) {
-        state.callback();
-    }
-    else {
-        options.onAfter?.(success);
-    }
+	cancelAnimationFrame(state.frame);
+	TIMERS_ACTIVE.delete(timer.instance);
+	state.active = false;
+	state.elapsed = 0;
+	state.frame = void 0;
+	if (timer.type === TYPE_WAIT) state.callback();
+	else options.onAfter?.(success);
 }
 function ignore(type, state) {
-    if (state.destroyed) {
-        return type !== WORK_STOP;
-    }
-    if (state.paused) {
-        return type === WORK_PAUSE || type === WORK_START;
-    }
-    return state.active && type === WORK_START;
+	if (state.destroyed) return type !== WORK_STOP;
+	if (state.paused) return type === WORK_PAUSE || type === WORK_START;
+	return state.active && type === WORK_START;
 }
 function pause(timer, state) {
-    cancelAnimationFrame(state.frame);
-    state.frame = undefined;
-    return timer.instance;
+	cancelAnimationFrame(state.frame);
+	state.frame = void 0;
+	return timer.instance;
 }
 function run(timer, state, options) {
-    let last;
-    return function step(now) {
-        if (!state.active) {
-            return;
-        }
-        last ??= now;
-        const difference = now - last;
-        state.elapsed += difference;
-        state.total += difference;
-        last = now;
-        if (options.timeout > 0 && state.total >= options.timeout) {
-            options.onError?.();
-            finish(timer, state, options, false);
-            return;
-        }
-        if (options.interval === milliseconds ||
-            state.elapsed >= options.interval - intervalBuffer) {
-            if (options.count > -1) {
-                state.callback(state.index);
-            }
-            state.elapsed = 0;
-            state.index += 1;
-            if (options.count === -1 ||
-                (options.count > 0 && state.index >= options.count)) {
-                finish(timer, state, options, true);
-                return;
-            }
-        }
-        state.frame = requestAnimationFrame(step);
-    };
+	let last;
+	let start;
+	return function step(now) {
+		if (!state.active) return;
+		last ??= now;
+		start ??= now;
+		const difference = now - last;
+		state.elapsed += difference;
+		state.total += difference;
+		last = now;
+		if (options.timeout > 0 && state.total >= options.timeout) {
+			options.onError?.();
+			finish(timer, state, options, false);
+			return;
+		}
+		if (options.interval === MILLISECONDS || state.elapsed >= options.interval - BUFFER_INTERVAL) {
+			if (options.count > -1) state.callback(state.index);
+			start = now;
+			state.elapsed = 0;
+			state.index += 1;
+			if (options.count === -1 || options.count > 0 && state.index >= options.count) {
+				finish(timer, state, options, true);
+				return;
+			}
+		}
+		state.frame = requestAnimationFrame(step);
+	};
 }
 function setState(type, state) {
-    const pausable = type === WORK_CONTINUE || type === WORK_PAUSE;
-    state.elapsed = pausable ? state.elapsed : 0;
-    state.index = pausable ? state.index : 0;
-    state.total = pausable ? state.total : 0;
+	const pausable = type === WORK_CONTINUE || type === WORK_PAUSE;
+	state.elapsed = pausable ? state.elapsed : 0;
+	state.index = pausable ? state.index : 0;
+	state.total = pausable ? state.total : 0;
 }
 function stop(timer, state, options) {
-    cancelAnimationFrame(state.frame);
-    activeTimers.delete(timer.instance);
-    options.onAfter?.(false);
-    state.active = !stop;
-    state.frame = undefined;
-    state.paused = false;
-    return timer.instance;
+	cancelAnimationFrame(state.frame);
+	TIMERS_ACTIVE.delete(timer.instance);
+	options.onAfter?.(false);
+	state.active = !stop;
+	state.frame = void 0;
+	state.paused = false;
+	return timer.instance;
 }
 function work(type, timer, state, options) {
-    if (ignore(type, state)) {
-        return timer.instance;
-    }
-    setState(type, state);
-    if (type === WORK_STOP) {
-        return stop(timer, state, options);
-    }
-    if (type === WORK_PAUSE || type === WORK_RESTART) {
-        cancelAnimationFrame(state.frame);
-        state.frame = undefined;
-    }
-    state.active = true;
-    state.paused = type === WORK_PAUSE;
-    if (state.paused) {
-        return pause(timer, state);
-    }
-    activeTimers.add(timer.instance);
-    const runner = run(timer, state, options);
-    state.frame = requestAnimationFrame(runner);
-    return timer.instance;
+	if (ignore(type, state)) return timer.instance;
+	setState(type, state);
+	if (type === WORK_STOP) return stop(timer, state, options);
+	if (type === WORK_PAUSE || type === WORK_RESTART) {
+		cancelAnimationFrame(state.frame);
+		state.frame = void 0;
+	}
+	state.active = true;
+	state.paused = type === WORK_PAUSE;
+	if (state.paused) return pause(timer, state);
+	TIMERS_ACTIVE.add(timer.instance);
+	const runner = run(timer, state, options);
+	state.frame = requestAnimationFrame(runner);
+	return timer.instance;
 }
 
-class Timer {
-    options;
-    state;
-    /**
-     * Is the timer active?
-     */
-    get active() {
-        return this.state.active;
-    }
-    /**
-     * Is the timer destroyed?
-     */
-    get destroyed() {
-        return this.state.destroyed;
-    }
-    /**
-     * Is the timer paused?
-     */
-    get paused() {
-        return this.state.paused;
-    }
-    /**
-     * Get the timer's origin _(if debugging is enabled)_
-     */
-    get trace() {
-        return (globalThis._oscarpalmer_timer_debug ?? false)
-            ? this.state.trace
-            : undefined;
-    }
-    constructor(type, state, options, start) {
-        this.options = options;
-        this.$timer = type;
-        this.state = {
-            ...state,
-            active: false,
-            destroyed: false,
-            elapsed: 0,
-            frame: undefined,
-            index: 0,
-            paused: false,
-            total: 0,
-        };
-        if (start) {
-            this.start();
-        }
-    }
-    /**
-     * Continue running the timer _(if it's paused)_
-     */
-    continue() {
-        return this.#work(WORK_CONTINUE);
-    }
-    /**
-     * Destroy the timer
-     */
-    destroy() {
-        this.state.destroyed = true;
-        this.options.onAfter = noop;
-        this.options.onError = noop;
-        this.state.callback = noop;
-        if (!globalThis._oscarpalmer_timer_debug) {
-            this.state.trace = undefined;
-        }
-        stop({
-            instance: this,
-            type: this.$timer,
-        }, this.state, this.options);
-    }
-    /**
-     * Pause the timer _(if it's running)_
-     */
-    pause() {
-        return this.#work(WORK_PAUSE);
-    }
-    /**
-     * Restart the timer _(or start it, if it's not running)_
-     */
-    restart() {
-        return this.#work(WORK_RESTART);
-    }
-    /**
-     * Start the timer _(if it's not running)_
-     */
-    start() {
-        return this.#work(WORK_START);
-    }
-    /**
-     * Stop the timer _(if it's running)_
-     */
-    stop() {
-        return this.#work(WORK_STOP);
-    }
-    #work(type) {
-        return work(type, {
-            instance: this,
-            type: this.$timer,
-        }, this.state, this.options);
-    }
-}
+var Timer = class {
+	state;
+	/**
+	* Is the timer active?
+	*/
+	get active() {
+		return this.state.active;
+	}
+	/**
+	* Is the timer destroyed?
+	*/
+	get destroyed() {
+		return this.state.destroyed;
+	}
+	/**
+	* Is the timer paused?
+	*/
+	get paused() {
+		return this.state.paused;
+	}
+	/**
+	* Get the timer's origin _(if debugging is enabled)_
+	*/
+	get trace() {
+		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.trace : void 0;
+	}
+	constructor(type, state, options, start) {
+		this.options = options;
+		this.$timer = type;
+		this.state = {
+			...state,
+			active: false,
+			destroyed: false,
+			elapsed: 0,
+			frame: void 0,
+			index: 0,
+			paused: false,
+			total: 0
+		};
+		if (start) this.start();
+	}
+	/**
+	* Continue running the timer _(if it's paused)_
+	*/
+	continue() {
+		return this.#work(WORK_CONTINUE);
+	}
+	/**
+	* Destroy the timer
+	*/
+	destroy() {
+		this.state.destroyed = true;
+		this.options.onAfter = noop;
+		this.options.onError = noop;
+		this.state.callback = noop;
+		if (!globalThis._oscarpalmer_timer_debug) this.state.trace = void 0;
+		stop({
+			instance: this,
+			type: this.$timer
+		}, this.state, this.options);
+	}
+	/**
+	* Pause the timer _(if it's running)_
+	*/
+	pause() {
+		return this.#work(WORK_PAUSE);
+	}
+	/**
+	* Restart the timer _(or start it, if it's not running)_
+	*/
+	restart() {
+		return this.#work(WORK_RESTART);
+	}
+	/**
+	* Start the timer _(if it's not running)_
+	*/
+	start() {
+		return this.#work(WORK_START);
+	}
+	/**
+	* Stop the timer _(if it's running)_
+	*/
+	stop() {
+		return this.#work(WORK_STOP);
+	}
+	#work(type) {
+		return work(type, {
+			instance: this,
+			type: this.$timer
+		}, this.state, this.options);
+	}
+};
 
 /**
- * Create a repeating timer
- */
+* Create a repeating timer
+* @param callback Callback to run on each interval
+* @param options Timer options
+* @returns Timer instance
+*/
 function repeat(callback, options) {
-    return new Timer(TYPE_REPEAT, {
-        callback: getCallback(callback),
-        trace: new TimerTrace().stack,
-    }, {
-        onAfter: getCallback(options?.onAfter),
-        onError: getCallback(options?.onTimeout),
-        count: getValidNumber(options?.count),
-        interval: getValidNumber(options?.interval, milliseconds),
-        timeout: getValidNumber(options?.timeout),
-    }, true);
+	return new Timer(TYPE_REPEAT, {
+		callback: getCallback(callback),
+		trace: new TimerTrace().stack
+	}, {
+		onAfter: getCallback(options?.onAfter),
+		onError: getCallback(options?.onTimeout),
+		count: getValidNumber(options?.count),
+		interval: getValidNumber(options?.interval, MILLISECONDS),
+		timeout: getValidNumber(options?.timeout)
+	}, true);
 }
 
 /**
- * Create a waiting timer
- * @param callback Callback to run when the timer has finished
- * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
- */
+* Create a waiting timer
+* @param callback Callback to run when the timer has finished
+* @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
+*/
 function wait(callback, time) {
-    return new Timer(TYPE_WAIT, {
-        callback: getCallback(callback),
-        trace: new TimerTrace().stack,
-    }, {
-        onAfter: undefined,
-        onError: undefined,
-        count: -1,
-        interval: getValidNumber(time, milliseconds),
-        timeout: 0,
-    }, true);
+	return new Timer(TYPE_WAIT, {
+		callback: getCallback(callback),
+		trace: new TimerTrace().stack
+	}, {
+		onAfter: void 0,
+		onError: void 0,
+		count: -1,
+		interval: getValidNumber(time, MILLISECONDS),
+		timeout: 0
+	}, true);
 }
 
-class When {
-    $timer = TYPE_WHEN;
-    state = {
-        promise: undefined,
-        rejecter: undefined,
-        resolver: undefined,
-        started: false,
-        timer: undefined,
-    };
-    /**
-     * Is the timer active?
-     */
-    get active() {
-        return this.state.timer?.active ?? false;
-    }
-    /**
-     * Is the timer destroyed?
-     */
-    get destroyed() {
-        return this.state.timer == null;
-    }
-    /**
-     * Is the timer paused?
-     */
-    get paused() {
-        return this.state.timer?.paused ?? false;
-    }
-    /**
-     * Get the timer's origin _(if debugging is enabled)_
-     */
-    get trace() {
-        return (globalThis._oscarpalmer_timer_debug ?? false)
-            ? this.state.timer?.trace
-            : undefined;
-    }
-    constructor(condition, options) {
-        const { state } = this;
-        state.promise = new Promise((resolve, reject) => {
-            state.resolver = resolve;
-            state.rejecter = reject;
-        });
-        let result = false;
-        this.state.timer = new Timer(TYPE_WHEN, {
-            callback() {
-                try {
-                    if (condition()) {
-                        result = true;
-                        state.timer.stop();
-                    }
-                }
-                catch {
-                    state.timer.stop();
-                }
-            },
-            trace: new TimerTrace().stack,
-        }, {
-            onAfter: () => {
-                if (result) {
-                    state.resolver?.();
-                }
-                else {
-                    state.rejecter?.();
-                }
-                this.destroy();
-            },
-            onError: () => {
-                state.rejecter?.();
-                this.destroy();
-            },
-            count: getValidNumber(options?.count),
-            interval: getValidNumber(options?.interval, milliseconds),
-            timeout: getValidTimeout(options?.timeout),
-        }, false);
-    }
-    /**
-     * Continues the timer _(if it was paused)_
-     */
-    continue() {
-        this.state.timer?.continue();
-        return this;
-    }
-    /**
-     * Destroys the timer _(and stops it,if it was running)_
-     */
-    destroy() {
-        const { state } = this;
-        state.timer?.destroy();
-        state.promise = undefined;
-        state.resolver = noop;
-        state.rejecter = noop;
-        state.timer = undefined;
-    }
-    /**
-     * Pauses the timer _(if it was running)_
-     */
-    pause() {
-        this.state.timer?.pause();
-        return this;
-    }
-    /**
-     * Stops the timer _(if it was running)_
-     */
-    stop() {
-        this.state.timer?.stop();
-        return this;
-    }
-    /**
-     * Starts the timer and returns a promise that resolves when the condition is met
-     */
-    // biome-ignore lint/suspicious/noThenProperty: returning a promise-like object, so it's ok ;)
-    then(resolve, reject) {
-        const { state } = this;
-        if (state.timer == null) {
-            throw new Error(destroyedMessage);
-        }
-        if (state.started) {
-            throw new Error(startedMessage);
-        }
-        state.started = true;
-        state.timer.start();
-        return state.promise.then(resolve ?? noop, reject ?? noop);
-    }
-}
+var When = class {
+	$timer = TYPE_WHEN;
+	state = {
+		promise: void 0,
+		rejecter: void 0,
+		resolver: void 0,
+		started: false,
+		timer: void 0
+	};
+	/**
+	* Is the timer active?
+	*/
+	get active() {
+		return this.state.timer?.active ?? false;
+	}
+	/**
+	* Is the timer destroyed?
+	*/
+	get destroyed() {
+		return this.state.timer == null;
+	}
+	/**
+	* Is the timer paused?
+	*/
+	get paused() {
+		return this.state.timer?.paused ?? false;
+	}
+	/**
+	* Get the timer's origin _(if debugging is enabled)_
+	*/
+	get trace() {
+		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
+	}
+	constructor(condition, options) {
+		const { state } = this;
+		state.promise = new Promise((resolve, reject) => {
+			state.resolver = resolve;
+			state.rejecter = reject;
+		});
+		let result = false;
+		this.state.timer = new Timer(TYPE_WHEN, {
+			callback() {
+				try {
+					if (condition()) {
+						result = true;
+						state.timer.stop();
+					}
+				} catch {
+					state.timer.stop();
+				}
+			},
+			trace: new TimerTrace().stack
+		}, {
+			onAfter: () => {
+				if (result) state.resolver?.();
+				else state.rejecter?.();
+				this.destroy();
+			},
+			onError: () => {
+				state.rejecter?.();
+				this.destroy();
+			},
+			count: getValidNumber(options?.count),
+			interval: getValidNumber(options?.interval, MILLISECONDS),
+			timeout: getValidTimeout(options?.timeout)
+		}, false);
+	}
+	/**
+	* Continues the timer _(if it was paused)_
+	*/
+	continue() {
+		this.state.timer?.continue();
+		return this;
+	}
+	/**
+	* Destroys the timer _(and stops it,if it was running)_
+	*/
+	destroy() {
+		const { state } = this;
+		state.timer?.destroy();
+		state.promise = void 0;
+		state.resolver = noop;
+		state.rejecter = noop;
+		state.timer = void 0;
+	}
+	/**
+	* Pauses the timer _(if it was running)_
+	*/
+	pause() {
+		this.state.timer?.pause();
+		return this;
+	}
+	/**
+	* Start the timer
+	* @param resolve Optional resolve callback
+	* @param reject Optional reject callback
+	* @returns Promise that resolves when the condition is met
+	*/
+	start(resolve, reject) {
+		const { state } = this;
+		if (state.timer == null) throw new Error(MESSAGE_DESTROYED);
+		if (state.started) throw new Error(MESSAGE_STARTED);
+		state.started = true;
+		state.timer.start();
+		return state.promise.then(resolve ?? noop, reject ?? noop);
+	}
+	/**
+	* Stops the timer _(if it was running)_
+	*/
+	stop() {
+		this.state.timer?.stop();
+		return this;
+	}
+	/**
+	* Start the timer
+	* @deprecated Use `start()` instead
+	* @param resolve Optional resolve callback
+	* @param reject Optional reject callback
+	* @returns Promise that resolves when the condition is met
+	*/
+	then(resolve, reject) {
+		return this.start(resolve, reject);
+	}
+};
 /**
- * Create a conditional timer
- */
+* Create a conditional timer
+* @param condition Condition to check
+* @param options Timer options
+* @returns Timer instance
+*/
 function when(condition, options) {
-    return new When(condition, options);
+	return new When(condition, options);
 }
 
-export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };
+export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };