@oscarpalmer/timer 0.48.0 → 0.50.0

package/dist/constants.d.mts

@@ -3,21 +3,21 @@ import { TimerName, TimerStates, WorkHandlerType } from "./models.mjs";
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
  */
-declare const BUFFER_INTERVAL = 5;
-declare const DEFAULT_TIMEOUT = 30000;
-declare const GLOBAL_NAME = "_oscarpalmer_timers";
+export declare const BUFFER_INTERVAL = 5;
+export declare const DEFAULT_TIMEOUT = 30000;
+export declare const GLOBAL_NAME = "_oscarpalmer_timers";
 /**
  * Message to show when a when-timer is started
  */
-declare const MESSAGE_STARTED = "Timer has already been started";
-declare const STATES: TimerStates;
-declare const TYPE_REPEAT: TimerName;
-declare const TYPE_WAIT: TimerName;
-declare const TYPE_WHEN: TimerName;
-declare const WORK_CONTINUE: WorkHandlerType;
-declare const WORK_PAUSE: WorkHandlerType;
-declare const WORK_RESTART: WorkHandlerType;
-declare const WORK_START: WorkHandlerType;
-declare const WORK_STOP: WorkHandlerType;
-//#endregion
-export { BUFFER_INTERVAL, DEFAULT_TIMEOUT, GLOBAL_NAME, MESSAGE_STARTED, STATES, TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP };
+export declare const MESSAGE_STARTED = "Timer has already been started";
+export declare const STATES: TimerStates;
+export declare const SYMBOL: unique symbol;
+export declare const TYPE_REPEAT: TimerName;
+export declare const TYPE_WAIT: TimerName;
+export declare const TYPE_WHEN: TimerName;
+export declare const WORK_CONTINUE: WorkHandlerType;
+export declare const WORK_PAUSE: WorkHandlerType;
+export declare const WORK_RESTART: WorkHandlerType;
+export declare const WORK_START: WorkHandlerType;
+export declare const WORK_STOP: WorkHandlerType;
+//#endregion

package/dist/constants.mjs

@@ -13,6 +13,7 @@ const STATES = {
 	active: /* @__PURE__ */ new Set(),
 	hidden: /* @__PURE__ */ new Set()
 };
+const SYMBOL = Symbol("timer");
 const TYPE_REPEAT = "repeat";
 const TYPE_WAIT = "wait";
 const TYPE_WHEN = "when";
@@ -22,4 +23,4 @@ const WORK_RESTART = "restart";
 const WORK_START = "start";
 const WORK_STOP = "stop";
 //#endregion
-export { BUFFER_INTERVAL, DEFAULT_TIMEOUT, GLOBAL_NAME, MESSAGE_STARTED, STATES, TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP };
+export { BUFFER_INTERVAL, DEFAULT_TIMEOUT, GLOBAL_NAME, MESSAGE_STARTED, STATES, SYMBOL, TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP };

package/dist/global.d.mts

@@ -6,4 +6,5 @@ declare global {
    * All active timers _(or `undefined` if debugging is not enabled)_
    */
   var _oscarpalmer_timers: Timer[] | undefined;
-}
+}
+//#endregion

package/dist/global.mjs

@@ -5,6 +5,7 @@ import { onVisibilityChange } from "./misc.mjs";
 if (!("_oscarpalmer_timers" in globalThis)) Object.defineProperty(globalThis, GLOBAL_NAME, { get() {
 	return globalThis._oscarpalmer_timer_debug ? [...STATES.active].map((state) => state.timer) : [];
 } });
-document.addEventListener("visibilitychange", onVisibilityChange);
+/* istanbul ignore next */
+if ("document" in globalThis) document.addEventListener("visibilitychange", onVisibilityChange);
 //#endregion
 export {};

package/dist/index.d.mts

@@ -200,6 +200,7 @@ export declare function repeat(callback: (index: number) => void, options?: Part
 export declare function wait(callback: () => void, time?: number): Timer;
 //#endregion
 //#region src/when.d.ts
+declare function When(this: any, condition: () => boolean, options: WhenOptions): void;
 /**
  * Create a conditional timer
  * @param condition Condition to check

package/dist/index.mjs

@@ -9,6 +9,7 @@ const STATES = {
 	active: /* @__PURE__ */ new Set(),
 	hidden: /* @__PURE__ */ new Set()
 };
+const SYMBOL = Symbol("timer");
 const TYPE_REPEAT = "repeat";
 const TYPE_WAIT = "wait";
 const TYPE_WHEN = "when";
@@ -27,7 +28,7 @@ function noop() {}
 //#region src/work.ts
 function finish(state, success) {
 	updateStates(state);
-	cancelAnimationFrame(state.frame);
+	stopTimer$1(state.frame);
 	state.active = false;
 	state.elapsed = 0;
 	state.frame = void 0;
@@ -40,8 +41,9 @@ function ignore(type, state) {
 }
 function run(state) {
 	let last;
-	return function step(now) {
+	return function step() {
 		if (!state.active) return;
+		const now = performance.now();
 		last ??= now;
 		const difference = now - last;
 		state.elapsed += difference;
@@ -61,7 +63,7 @@ function run(state) {
 				return;
 			}
 		}
-		state.frame = requestAnimationFrame(step);
+		state.frame = startTimer$1(step);
 	};
 }
 function setState(type, state) {
@@ -72,7 +74,7 @@ function setState(type, state) {
 }
 function stop(state) {
 	updateStates(state);
-	cancelAnimationFrame(state.frame);
+	stopTimer$1(state.frame);
 	state.options.onAfter?.(false);
 	state.active = false;
 	state.frame = void 0;
@@ -84,7 +86,7 @@ function work(type, state, hide) {
 	setState(type, state);
 	if (type === "stop") return stop(state);
 	if (type === "pause" || type === "restart") {
-		cancelAnimationFrame(state.frame);
+		stopTimer$1(state.frame);
 		state.frame = void 0;
 	}
 	state.active = true;
@@ -92,7 +94,7 @@ function work(type, state, hide) {
 	updateStates(state, state.paused ? hide : false);
 	if (state.paused) return state.timer;
 	const runner = run(state);
-	state.frame = requestAnimationFrame(runner);
+	state.frame = startTimer$1(runner);
 	return state.timer;
 }
 //#endregion
@@ -128,53 +130,58 @@ function updateStates(state, hide) {
 		STATES.hidden.add(state.reference);
 	} else STATES.active.add(state);
 }
+/* istanbul ignore next */
+const startTimer$1 = "requestAnimationFrame" in globalThis ? requestAnimationFrame : setTimeout;
+/* istanbul ignore next */
+const stopTimer$1 = "cancelAnimationFrame" in globalThis ? cancelAnimationFrame : clearTimeout;
 //#endregion
 //#region src/global.ts
 /* istanbul ignore next */
 if (!("_oscarpalmer_timers" in globalThis)) Object.defineProperty(globalThis, GLOBAL_NAME, { get() {
 	return globalThis._oscarpalmer_timer_debug ? [...STATES.active].map((state) => state.timer) : [];
 } });
-document.addEventListener("visibilitychange", onVisibilityChange);
+/* istanbul ignore next */
+if ("document" in globalThis) document.addEventListener("visibilitychange", onVisibilityChange);
 //#endregion
 //#region src/is.ts
-function is(names, value) {
-	return names.includes(value?.$timer);
+function isInstance(names, value) {
+	return typeof value === "object" && value !== null && SYMBOL in value && names.includes(value[SYMBOL].name);
 }
 /**
 * Is the value a repeating timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a repeating timer, otherwise `false`
 */
 function isRepeated(value) {
-	return is([TYPE_REPEAT], value);
+	return isInstance([TYPE_REPEAT], value);
 }
 /**
 * Is the value a timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a timer, otherwise `false`
 */
 function isTimer(value) {
-	return is([TYPE_REPEAT, TYPE_WAIT], value);
+	return isInstance([TYPE_REPEAT, TYPE_WAIT], value);
 }
 /**
 * Is the value a waiting timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a waiting timer, otherwise `false`
 */
 function isWaited(value) {
-	return is([TYPE_WAIT], value);
+	return isInstance([TYPE_WAIT], value);
 }
 /**
 * Is the value a conditional timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a conditional timer, otherwise `false`
 */
 function isWhen(value) {
-	return is(["when"], value) && typeof value.start === "function";
+	return isInstance(["when"], value) && typeof value.start === "function";
 }
 //#endregion
 //#region src/models.ts
@@ -186,9 +193,9 @@ var TimerTrace = class extends Error {
 };
 //#endregion
 //#region src/timer.ts
-function createTimer(name, pick, options, start) {
-	const state = {
-		...pick,
+function Timer(name, state, options, start) {
+	this[SYMBOL] = {
+		...state,
 		name,
 		options,
 		active: false,
@@ -200,39 +207,53 @@ function createTimer(name, pick, options, start) {
 		timer: void 0,
 		total: 0
 	};
-	const instance = {
-		continue: () => work(WORK_CONTINUE, state),
-		destroy: noop,
-		pause: () => work(WORK_PAUSE, state),
-		restart: () => work(WORK_RESTART, state),
-		start: () => work(WORK_START, state),
-		stop: () => work(WORK_STOP, state)
-	};
-	Object.defineProperties(instance, {
-		$timer: {
-			enumerable: false,
-			value: name
-		},
-		active: {
-			enumerable: true,
-			get: () => state.active && !state.paused
-		},
-		destroyed: {
-			enumerable: true,
-			value: false
-		},
-		paused: {
-			enumerable: true,
-			get: () => state.paused
-		},
-		trace: {
-			enumerable: true,
-			get: () => globalThis._oscarpalmer_timer_debug ?? false ? state.trace : void 0
-		}
-	});
-	state.timer = Object.freeze(instance);
-	if (start) state.timer.start();
-	return state.timer;
+	if (start) startTimer.call(this);
+}
+Timer.prototype.continue = continueTimer;
+Timer.prototype.pause = pauseTimer;
+Timer.prototype.restart = restartTimer;
+Timer.prototype.start = startTimer;
+Timer.prototype.stop = stopTimer;
+Object.defineProperties(Timer.prototype, {
+	active: {
+		enumerable: true,
+		get: getTimerActive
+	},
+	paused: {
+		enumerable: true,
+		get: getTimerPaused
+	},
+	trace: {
+		enumerable: true,
+		get: getTimerTrace
+	}
+});
+function continueTimer() {
+	return work(WORK_CONTINUE, this[SYMBOL]);
+}
+function createTimer(name, state, options, start) {
+	return new Timer(name, state, options, start);
+}
+function getTimerActive() {
+	return this[SYMBOL].active && !this[SYMBOL].paused;
+}
+function getTimerPaused() {
+	return this[SYMBOL].paused;
+}
+function getTimerTrace() {
+	return globalThis._oscarpalmer_timer_debug ?? false ? this[SYMBOL].trace : void 0;
+}
+function pauseTimer() {
+	return work(WORK_PAUSE, this[SYMBOL]);
+}
+function restartTimer() {
+	return work(WORK_RESTART, this[SYMBOL]);
+}
+function startTimer() {
+	return work(WORK_START, this[SYMBOL]);
+}
+function stopTimer() {
+	return work(WORK_STOP, this[SYMBOL]);
 }
 //#endregion
 //#region src/repeat.ts
@@ -278,6 +299,57 @@ function wait(callback, time) {
 }
 //#endregion
 //#region src/when.ts
+function When(condition, options) {
+	const state = {
+		name: TYPE_WHEN,
+		promise: void 0,
+		result: false,
+		started: false,
+		timer: void 0
+	};
+	this[SYMBOL] = state;
+	state.promise = new Promise((resolve, reject) => {
+		state.resolver = resolve;
+		state.rejecter = reject;
+	});
+	state.timer = createTimer(TYPE_WHEN, {
+		callback: () => onCallback(condition, state),
+		trace: new TimerTrace().stack
+	}, {
+		...options,
+		onAfter: () => onAfter(state),
+		onError: () => state.rejecter?.()
+	}, false);
+}
+When.prototype.continue = continueWhen;
+When.prototype.pause = pauseWhen;
+When.prototype.start = startWhen;
+When.prototype.stop = stopWhen;
+Object.defineProperties(When.prototype, {
+	active: { get: getWhenActive },
+	paused: { get: getWhenPaused },
+	trace: { get: getWhenTrace }
+});
+function continueWhen() {
+	return onWhen(WORK_CONTINUE, this, this[SYMBOL]);
+}
+function getWhenOptions(input) {
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		count: getValidNumber(options?.count),
+		interval: getValidNumber(options?.interval),
+		timeout: getValidTimeout(options?.timeout)
+	};
+}
+function getWhenActive() {
+	return this[SYMBOL].timer.active;
+}
+function getWhenPaused() {
+	return this[SYMBOL].timer.paused;
+}
+function getWhenTrace() {
+	return globalThis._oscarpalmer_timer_debug ?? false ? this[SYMBOL].timer?.trace : void 0;
+}
 function onAfter(state) {
 	if (state.result) state.resolver?.();
 	else state.rejecter?.();
@@ -296,12 +368,19 @@ function onWhen(type, instance, state) {
 	state.timer?.[type]?.();
 	return instance;
 }
-function startWhen(state, resolve) {
+function pauseWhen() {
+	return onWhen(WORK_PAUSE, this, this[SYMBOL]);
+}
+function startWhen(resolve) {
+	const state = this[SYMBOL];
 	if (state.started) throw new Error(MESSAGE_STARTED);
 	state.started = true;
 	state.timer.start();
 	return state.promise.then(resolve);
 }
+function stopWhen() {
+	return onWhen(WORK_STOP, this, this[SYMBOL]);
+}
 /**
 * Create a conditional timer
 * @param condition Condition to check
@@ -309,57 +388,7 @@ function startWhen(state, resolve) {
 * @returns Timer instance
 */
 function when(condition, options) {
-	const state = {
-		promise: void 0,
-		result: false,
-		started: false,
-		timer: void 0
-	};
-	let instance;
-	state.promise = new Promise((resolve, reject) => {
-		state.resolver = resolve;
-		state.rejecter = reject;
-	});
-	state.timer = createTimer(TYPE_WHEN, {
-		callback: () => onCallback(condition, state),
-		trace: new TimerTrace().stack
-	}, {
-		onAfter: () => onAfter(state),
-		onError: () => state.rejecter?.(),
-		count: getValidNumber(options?.count),
-		interval: getValidNumber(options?.interval),
-		timeout: getValidTimeout(options?.timeout)
-	}, false);
-	instance = {
-		continue: () => onWhen(WORK_CONTINUE, instance, state),
-		destroy: noop,
-		pause: () => onWhen(WORK_PAUSE, instance, state),
-		start: (resolve) => startWhen(state, resolve),
-		stop: () => onWhen(WORK_STOP, instance, state)
-	};
-	Object.defineProperties(instance, {
-		$timer: {
-			enumerable: false,
-			value: TYPE_WHEN
-		},
-		active: {
-			enumerable: true,
-			get: () => state.timer.active
-		},
-		destroyed: {
-			enumerable: true,
-			value: false
-		},
-		paused: {
-			enumerable: true,
-			get: () => state.timer.paused
-		},
-		trace: {
-			enumerable: true,
-			get: () => globalThis._oscarpalmer_timer_debug ?? false ? state.timer?.trace : void 0
-		}
-	});
-	return Object.freeze(instance);
+	return new When(condition, getWhenOptions(options));
 }
 //#endregion
 export { isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };

package/dist/is.d.mts

@@ -6,27 +6,26 @@ import { Timer, When } from "./models.mjs";
  * @param value Value to check
  * @returns `true` if the value is a repeating timer, otherwise `false`
  */
-declare function isRepeated(value: unknown): value is Timer;
+export declare function isRepeated(value: unknown): value is Timer;
 /**
  * Is the value a timer?
  *
  * @param value Value to check
  * @returns `true` if the value is a timer, otherwise `false`
  */
-declare function isTimer(value: unknown): value is Timer;
+export declare function isTimer(value: unknown): value is Timer;
 /**
  * Is the value a waiting timer?
  *
  * @param value Value to check
  * @returns `true` if the value is a waiting timer, otherwise `false`
  */
-declare function isWaited(value: unknown): value is Timer;
+export declare function isWaited(value: unknown): value is Timer;
 /**
  * Is the value a conditional timer?
  *
  * @param value Value to check
  * @returns `true` if the value is a conditional timer, otherwise `false`
  */
-declare function isWhen(value: unknown): value is When;
-//#endregion
-export { isRepeated, isTimer, isWaited, isWhen };
+export declare function isWhen(value: unknown): value is When;
+//#endregion

package/dist/is.mjs

@@ -1,43 +1,43 @@
-import { TYPE_REPEAT, TYPE_WAIT } from "./constants.mjs";
+import { SYMBOL, TYPE_REPEAT, TYPE_WAIT } from "./constants.mjs";
 //#region src/is.ts
-function is(names, value) {
-	return names.includes(value?.$timer);
+function isInstance(names, value) {
+	return typeof value === "object" && value !== null && SYMBOL in value && names.includes(value[SYMBOL].name);
 }
 /**
 * Is the value a repeating timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a repeating timer, otherwise `false`
 */
 function isRepeated(value) {
-	return is([TYPE_REPEAT], value);
+	return isInstance([TYPE_REPEAT], value);
 }
 /**
 * Is the value a timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a timer, otherwise `false`
 */
 function isTimer(value) {
-	return is([TYPE_REPEAT, TYPE_WAIT], value);
+	return isInstance([TYPE_REPEAT, TYPE_WAIT], value);
 }
 /**
 * Is the value a waiting timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a waiting timer, otherwise `false`
 */
 function isWaited(value) {
-	return is([TYPE_WAIT], value);
+	return isInstance([TYPE_WAIT], value);
 }
 /**
 * Is the value a conditional timer?
-* 
+*
 * @param value Value to check
 * @returns `true` if the value is a conditional timer, otherwise `false`
 */
 function isWhen(value) {
-	return is(["when"], value) && typeof value.start === "function";
+	return isInstance(["when"], value) && typeof value.start === "function";
 }
 //#endregion
 export { isRepeated, isTimer, isWaited, isWhen };

package/dist/misc.d.mts

@@ -1,10 +1,11 @@
 import { TimerState } from "./models.mjs";
 import { GenericCallback } from "@oscarpalmer/atoms/models";
 //#region src/misc.d.ts
-declare function getCallback(value: unknown): GenericCallback;
-declare function getValidNumber(value: unknown, defaultValue?: number): number;
-declare function getValidTimeout(value: unknown): number;
-declare function onVisibilityChange(): void;
-declare function updateStates(state: TimerState, hide?: boolean): void;
-//#endregion
-export { getCallback, getValidNumber, getValidTimeout, onVisibilityChange, updateStates };
+export declare function getCallback(value: unknown): GenericCallback;
+export declare function getValidNumber(value: unknown, defaultValue?: number): number;
+export declare function getValidTimeout(value: unknown): number;
+export declare function onVisibilityChange(): void;
+export declare function updateStates(state: TimerState, hide?: boolean): void;
+export declare const startTimer: typeof requestAnimationFrame | typeof setTimeout;
+export declare const stopTimer: typeof cancelAnimationFrame;
+//#endregion

package/dist/misc.mjs

@@ -33,5 +33,9 @@ function updateStates(state, hide) {
 		STATES.hidden.add(state.reference);
 	} else STATES.active.add(state);
 }
+/* istanbul ignore next */
+const startTimer = "requestAnimationFrame" in globalThis ? requestAnimationFrame : setTimeout;
+/* istanbul ignore next */
+const stopTimer = "cancelAnimationFrame" in globalThis ? cancelAnimationFrame : clearTimeout;
 //#endregion
-export { getCallback, getValidNumber, getValidTimeout, onVisibilityChange, updateStates };
+export { getCallback, getValidNumber, getValidTimeout, onVisibilityChange, startTimer, stopTimer, updateStates };

package/dist/models.d.mts

@@ -2,7 +2,7 @@
 /**
  * Options for a repeating timer
  */
-type RepeatOptions = {
+export type RepeatOptions = {
   /**
    * Callback to be called when the timer has stopped, either manually or by completing its work
    */
@@ -24,7 +24,7 @@ type RepeatOptions = {
    */
   timeout: number;
 };
-type Timer = {
+export type Timer = {
   /**
    * Is the timer active?
    */
@@ -70,15 +70,15 @@ type Timer = {
    */
   stop(): Timer;
 };
-type TimerName = 'repeat' | 'wait' | 'when';
-type TimerOptions = {
+export type TimerName = 'repeat' | 'wait' | 'when';
+export type TimerOptions = {
   onAfter: ((finished: boolean) => void) | undefined;
   onError: (() => void) | undefined;
   count: number;
   interval: number;
   timeout: number;
 };
-type TimerState = {
+export type TimerState = {
   active: boolean;
   callback: () => void;
   destroyed: boolean;
@@ -93,7 +93,7 @@ type TimerState = {
   total: number;
   trace?: string;
 };
-type TimerStates = {
+export type TimerStates = {
   /**
    * A set of all active timers
    */
@@ -103,10 +103,10 @@ type TimerStates = {
    */
   hidden: Set<WeakRef<TimerState>>;
 };
-declare class TimerTrace extends Error {
+export declare class TimerTrace extends Error {
   constructor();
 }
-type When = {
+export type When = {
   /**
    * Is the timer active?
    */
@@ -154,7 +154,7 @@ type When = {
 /**
  * Options for a conditional timer
  */
-type WhenOptions = {
+export type WhenOptions = {
   /**
    * How many times the timer should check the condition
    */
@@ -168,7 +168,8 @@ type WhenOptions = {
    */
   timeout: number;
 };
-type WhenState = {
+export type WhenState = {
+  name: TimerName;
   promise: Promise<void>;
   rejecter?: () => void;
   resolver?: () => void;
@@ -176,11 +177,10 @@ type WhenState = {
   started: boolean;
   timer: Timer;
 };
-type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
-type WorkHandlerTimer = {
+export type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
+export type WorkHandlerTimer = {
   instance: Timer;
   name: TimerName;
 };
-type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
-//#endregion
-export { RepeatOptions, Timer, TimerName, TimerOptions, TimerState, TimerStates, TimerTrace, When, WhenOptions, WhenState, WorkHandler, WorkHandlerTimer, WorkHandlerType };
+export type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
+//#endregion

package/dist/repeat.d.mts

@@ -8,6 +8,5 @@ import "./global.mjs";
  * @param options Timer options
  * @returns Repeating timer
  */
-declare function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer;
-//#endregion
-export { repeat };
+export declare function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer;
+//#endregion

package/dist/timer.d.mts

@@ -1,5 +1,5 @@
 import { Timer, TimerName, TimerOptions, TimerState } from "./models.mjs";
 //#region src/timer.d.ts
-declare function createTimer(name: TimerName, pick: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean): Timer;
-//#endregion
-export { createTimer };
+declare function Timer(this: any, name: TimerName, state: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean): void;
+export declare function createTimer(name: TimerName, state: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean): Timer;
+//#endregion