vitest 5.0.0-beta.2 → 5.0.0-beta.3

package/dist/chunks/{index.D_7-4CaB.js → index.ukHtlBbI.js}

@@ -2529,12 +2529,12 @@ function requireFakeTimersSrc () {
 	if (typeof __vitest_required__ !== 'undefined') {
 	    try {
 	        timersModule = __vitest_required__.timers;
-	    } catch (e) {
+	    } catch {
 	        // ignored
 	    }
 	    try {
 	        timersPromisesModule = __vitest_required__.timersPromises;
-	    } catch (e) {
+	    } catch {
 	        // ignored
 	    }
 	}
@@ -2545,18 +2545,18 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * @typedef {object} NextAsyncTickMode
-	 * @property {"nextAsync"} mode
+	 * @property {"nextAsync"} mode - runs timers one macrotask at a time
 	 */
 
 	/**
 	 * @typedef {object} ManualTickMode
-	 * @property {"manual"} mode
+	 * @property {"manual"} mode - advances only when the caller explicitly ticks
 	 */
 
 	/**
 	 * @typedef {object} IntervalTickMode
-	 * @property {"interval"} mode
-	 * @property {number} [delta]
+	 * @property {"interval"} mode - advances automatically on a native interval
+	 * @property {number} [delta] - interval duration in milliseconds
 	 */
 
 	/**
@@ -2564,134 +2564,447 @@ function requireFakeTimersSrc () {
 	 */
 
 	/**
-	 * @typedef {object} IdleDeadline
-	 * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
-	 * @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period
+	 * @callback FakeTimersFunction
+	 * @param {...unknown[]} args
+	 * @returns {unknown}
 	 */
 
 	/**
-	 * Queues a function to be called during a browser's idle periods
-	 * @callback RequestIdleCallback
-	 * @param {function(IdleDeadline)} callback
-	 * @param {{timeout: number}} options - an options object
-	 * @returns {number} the id
+	 * @callback VoidVarArgsFunc
+	 * @param {...unknown[]} args - optional arguments to call the callback with
+	 * @returns {void}
 	 */
 
 	/**
 	 * @callback NextTick
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} args - optional arguments to call the callback with
+	 * @param {...unknown[]} args - optional arguments to call the callback with
 	 * @returns {void}
 	 */
 
 	/**
 	 * @callback SetImmediate
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} args - optional arguments to call the callback with
+	 * @param {...unknown[]} args - optional arguments to call the callback with
 	 * @returns {NodeImmediate}
 	 */
 
 	/**
-	 * @callback VoidVarArgsFunc
-	 * @param {...*} callback - the callback to run
+	 * @callback SetTimeout
+	 * @param {VoidVarArgsFunc} callback - the callback to run
+	 * @param {number} [delay] - optional delay in milliseconds
+	 * @param {...unknown[]} args - optional arguments to call the callback with
+	 * @returns {TimerId} - the timeout identifier
+	 */
+
+	/**
+	 * @callback ClearTimeout
+	 * @param {TimerId} [id] - the timeout identifier to clear
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback SetInterval
+	 * @param {VoidVarArgsFunc} callback - the callback to run
+	 * @param {number} [delay] - optional delay in milliseconds
+	 * @param {...unknown[]} args - optional arguments to call the callback with
+	 * @returns {TimerId} - the interval identifier
+	 */
+
+	/**
+	 * @callback ClearInterval
+	 * @param {TimerId} [id] - the interval identifier to clear
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback QueueMicrotask
+	 * @param {VoidVarArgsFunc} callback - the callback to run
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback TimeRemaining
+	 * @returns {number}
+	 */
+
+	/**
+	 * @typedef {object} IdleDeadline
+	 * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
+	 * @property {TimeRemaining} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period
+	 */
+
+	/**
+	 * @callback RequestIdleCallbackCallback
+	 * @param {IdleDeadline} deadline
+	 */
+
+	/**
+	 * Queues a function to be called during a browser's idle periods
+	 * @callback RequestIdleCallback
+	 * @param {RequestIdleCallbackCallback} callback
+	 * @param {{timeout?: number}} [options] - an options object
+	 * @returns {number} the id
+	 */
+
+	/**
+	 * @callback AnimationFrameCallback
+	 * @param {number} timestamp
+	 */
+
+	/**
+	 * @callback RequestAnimationFrame
+	 * @param {AnimationFrameCallback} callback
+	 * @returns {TimerId} - the request id
+	 */
+
+	/**
+	 * @callback CancelAnimationFrame
+	 * @param {TimerId} id - cancels a frame callback
 	 * @returns {void}
 	 */
 
 	/**
-	 * @typedef RequestAnimationFrame
-	 * @property {function(number):void} requestAnimationFrame
-	 * @returns {number} - the id
+	 * @callback CancelIdleCallback
+	 * @param {TimerId} id - cancels a scheduled idle callback
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback ClearImmediate
+	 * @param {NodeImmediate} id - faked `clearImmediate`
+	 * @returns {void}
 	 */
 
 	/**
-	 * @typedef Performance
-	 * @property {function(): number} now
+	 * @callback CountTimers
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunMicrotasks
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback Tick
+	 * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	 * @returns {number} will return the new `now` value
+	 */
+
+	/**
+	 * @callback TickAsync
+	 * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback Next
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback NextAsync
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback RunAll
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunToFrame
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunAllAsync
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback RunToLast
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback RunToLastAsync
+	 * @returns {Promise<number>}
+	 */
+
+	/**
+	 * @callback Reset
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback SetSystemTime
+	 * @param {number|Date} [now] initial mocked time, as milliseconds since epoch or a Date
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback Jump
+	 * @param {number|string} tickValue milliseconds or a human-readable value like "01:11:15"
+	 * @returns {number}
+	 */
+
+	/**
+	 * @callback Uninstall
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback SetTickMode
+	 * @param {SetTickModeConfig} tickModeConfig - The new configuration for how the clock should tick.
+	 * @returns {void}
+	 */
+
+	/**
+	 * @callback Hrtime
+	 * @param {Array<number>} [prev]
+	 * @returns {Array<number>}
+	 */
+
+	/**
+	 * @callback WithGlobal
+	 * @param {object} _global Namespace to mock (e.g. `window`)
+	 * @returns {FakeTimers}
+	 */
+
+	/**
+	 * @typedef {"setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask"} FakeMethod
+	 */
+
+	/**
+	 * @typedef {number | NodeImmediate | Timer} TimerId
+	 */
+
+	/* eslint-disable jsdoc/reject-any-type */
+	/**
+	 * @typedef {Record<string, any> & {
+	 *   setTimeout?: SetTimeout,
+	 *   clearTimeout?: ClearTimeout,
+	 *   setInterval?: SetInterval,
+	 *   clearInterval?: ClearInterval,
+	 *   setImmediate?: SetImmediate,
+	 *   clearImmediate?: ClearImmediate,
+	 *   queueMicrotask?: QueueMicrotask,
+	 *   requestAnimationFrame?: RequestAnimationFrame,
+	 *   cancelAnimationFrame?: CancelAnimationFrame,
+	 *   requestIdleCallback?: RequestIdleCallback,
+	 *   cancelIdleCallback?: CancelIdleCallback,
+	 *   process?: any,
+	 *   performance?: any,
+	 *   Performance?: any,
+	 *   Intl?: any,
+	 *   Promise?: typeof Promise,
+	 *   Date: typeof Date & { isFake?: boolean, toSource?: () => string, clock?: any }
+	 * }} GlobalObject
+	 */
+
+	/**
+	 * @typedef {object} TimerHeap
+	 * @property {Timer[]} timers - the heap-ordered timers
+	 * @property {() => Timer | undefined} peek - returns the next timer without removing it
+	 * @property {(timer: Timer) => void} push - adds a timer to the heap
+	 * @property {() => Timer | undefined} pop - removes and returns the next timer
+	 * @property {(timer: Timer) => void} remove - removes a specific timer
+	 */
+
+	/**
+	 * @typedef {object} ClockTickMode
+	 * @property {TickMode} mode - active tick mode
+	 * @property {number} counter - increments whenever the mode changes
+	 * @property {number} [delta] - interval length in milliseconds
+	 */
+
+	/**
+	 * @typedef {object} SetTickModeConfig
+	 * @property {TickMode} mode - desired tick mode
+	 * @property {number} [delta] - interval length in milliseconds
+	 */
+
+	/**
+	 * @typedef {Record<string, any> & { clock: Clock }} IntlWithClock
+	 */
+
+	/**
+	 * @typedef {object} Timers
+	 * @property {SetTimeout} setTimeout - native `setTimeout`
+	 * @property {ClearTimeout} clearTimeout - native `clearTimeout`
+	 * @property {SetInterval} setInterval - native `setInterval`
+	 * @property {ClearInterval} clearInterval - native `clearInterval`
+	 * @property {typeof Date} Date - native `Date`
+	 * @property {typeof Intl} [Intl] - native `Intl`
+	 * @property {SetImmediate} [setImmediate] - native `setImmediate`, if available
+	 * @property {ClearImmediate} [clearImmediate] - native `clearImmediate`, if available
+	 * @property {Hrtime} [hrtime] - native `process.hrtime`, if available
+	 * @property {NextTick} [nextTick] - native `process.nextTick`, if available
+	 * @property {Performance} [performance] - native `performance`, if available
+	 * @property {RequestAnimationFrame} [requestAnimationFrame] - native `requestAnimationFrame`, if available
+	 * @property {QueueMicrotask} [queueMicrotask] - whether `queueMicrotask` exists
+	 * @property {CancelAnimationFrame} [cancelAnimationFrame] - native `cancelAnimationFrame`, if available
+	 * @property {RequestIdleCallback} [requestIdleCallback] - native `requestIdleCallback`, if available
+	 * @property {CancelIdleCallback} [cancelIdleCallback] - native `cancelIdleCallback`, if available
+	 */
+
+	/**
+	 * @typedef {object} ClockState
+	 * @property {number} tickFrom - lower bound of the current tick range
+	 * @property {number} tickTo - upper bound of the current tick range
+	 * @property {number} [previous] - previous timer time used during ticking
+	 * @property {number | null} [oldNow] - previous value of `now`
+	 * @property {Timer} [timer] - timer currently being processed
+	 * @property {unknown} [firstException] - first exception raised while processing timers
+	 * @property {number} [nanosTotal] - accumulated nanoseconds from fractional ticks
+	 * @property {number} [msFloat] - accumulated fractional milliseconds
+	 * @property {number} [ms] - accumulated whole milliseconds
+	 */
+
+	/**
+	 * @typedef {object} TimerInitialProps
+	 * @property {VoidVarArgsFunc} func - callback or string to execute
+	 * @property {unknown[]} [args] - arguments passed to the callback
+	 * @property {'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback'} [type] - timer kind
+	 * @property {number} [delay] - requested delay in milliseconds
+	 * @property {number} [callAt] - scheduled execution time
+	 * @property {number} [createdAt] - time at which the timer was created
+	 * @property {boolean} [immediate] - whether this timer should run before non-immediate timers at the same time
+	 * @property {number} [id] - unique timer identifier
+	 * @property {Error} [error] - captured stack for loop diagnostics
+	 * @property {number} [interval] - interval for repeated timers
+	 * @property {boolean} [animation] - whether this is an animation frame timer
+	 * @property {boolean} [requestIdleCallback] - whether this is an idle callback timer
+	 * @property {number} [order] - execution order for timers at the same time
+	 * @property {number} [heapIndex] - index in the timer heap
+	 */
+
+	/**
+	 * @callback CreateClockCallback
+	 * @param {number|Date} [start] initial mocked time, as milliseconds since epoch or a Date
+	 * @param {number} [loopLimit] maximum number of timers run before aborting with an infinite-loop error
+	 * @returns {Clock}
+	 */
+
+	/**
+	 * @callback InstallCallback
+	 * @param {Config} [config] Optional config
+	 * @returns {Clock}
+	 */
+
+	/**
+	 * @typedef {object} FakeTimers
+	 * @property {Timers} timers - the native timer APIs saved for later restoration
+	 * @property {CreateClockCallback} createClock - creates a new fake clock
+	 * @property {InstallCallback} install - installs the fake timers onto the default global object
+	 * @property {WithGlobal} withGlobal - creates a fake-timers instance for a provided global object
 	 */
 
-	/* eslint-disable jsdoc/require-property-description */
 	/**
 	 * @typedef {object} Clock
-	 * @property {number} now - the current time
-	 * @property {Date} Date - the Date constructor
-	 * @property {number} loopLimit - the maximum number of timers before assuming an infinite loop
-	 * @property {RequestIdleCallback} requestIdleCallback
-	 * @property {function(number):void} cancelIdleCallback
-	 * @property {setTimeout} setTimeout
-	 * @property {clearTimeout} clearTimeout
-	 * @property {NextTick} nextTick
-	 * @property {queueMicrotask} queueMicrotask
-	 * @property {setInterval} setInterval
-	 * @property {clearInterval} clearInterval
-	 * @property {SetImmediate} setImmediate
-	 * @property {function(NodeImmediate):void} clearImmediate
-	 * @property {function():number} countTimers
-	 * @property {RequestAnimationFrame} requestAnimationFrame
-	 * @property {function(number):void} cancelAnimationFrame
-	 * @property {function():void} runMicrotasks
-	 * @property {function(string | number): number} tick
-	 * @property {function(string | number): Promise<number>} tickAsync
-	 * @property {function(): number} next
-	 * @property {function(): Promise<number>} nextAsync
-	 * @property {function(): number} runAll
-	 * @property {function(): number} runToFrame
-	 * @property {function(): Promise<number>} runAllAsync
-	 * @property {function(): number} runToLast
-	 * @property {function(): Promise<number>} runToLastAsync
-	 * @property {function(): void} reset
-	 * @property {function(number | Date): void} setSystemTime
-	 * @property {function(number): void} jump
-	 * @property {Performance} performance
-	 * @property {function(number[]): number[]} hrtime - process.hrtime (legacy)
-	 * @property {function(): void} uninstall Uninstall the clock.
-	 * @property {Function[]} methods - the methods that are faked
-	 * @property {boolean} [shouldClearNativeTimers] inherited from config
-	 * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
-	 * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
-	 * @property {Map<function(): void, AbortSignal>} abortListenerMap
-	 * @property {function(TimerTickMode): void} setTickMode
+	 * @property {number} now - current mocked time in milliseconds
+	 * @property {typeof Date & {clock?: Clock, isFake?: boolean, toSource?: () => string}} Date - fake Date constructor bound to this clock
+	 * @property {number} loopLimit - maximum number of timers before assuming an infinite loop
+	 * @property {RequestIdleCallback} requestIdleCallback - schedules an idle callback
+	 * @property {CancelIdleCallback} cancelIdleCallback - cancels a scheduled idle callback
+	 * @property {SetTimeout} setTimeout - faked `setTimeout`
+	 * @property {ClearTimeout} clearTimeout - faked `clearTimeout`
+	 * @property {NextTick} nextTick - faked `process.nextTick`
+	 * @property {QueueMicrotask} queueMicrotask - faked `queueMicrotask`
+	 * @property {SetInterval} setInterval - faked `setInterval`
+	 * @property {ClearInterval} clearInterval - faked `clearInterval`
+	 * @property {SetImmediate} setImmediate - faked `setImmediate`
+	 * @property {ClearImmediate} clearImmediate - faked `clearImmediate`
+	 * @property {CountTimers} countTimers - counts scheduled timers
+	 * @property {RequestAnimationFrame} requestAnimationFrame - schedules a frame callback
+	 * @property {CancelAnimationFrame} cancelAnimationFrame - cancels a frame callback
+	 * @property {RunMicrotasks} runMicrotasks - drains microtasks
+	 * @property {Tick} tick - advances fake time synchronously
+	 * @property {TickAsync} tickAsync - advances fake time asynchronously
+	 * @property {Next} next - runs the next scheduled timer
+	 * @property {NextAsync} nextAsync - runs the next scheduled timer asynchronously
+	 * @property {RunAll} runAll - runs all scheduled timers
+	 * @property {RunToFrame} runToFrame - runs timers up to the next animation frame
+	 * @property {RunAllAsync} runAllAsync - runs all scheduled timers asynchronously
+	 * @property {RunToLast} runToLast - runs timers up to the last scheduled timer
+	 * @property {RunToLastAsync} runToLastAsync - runs timers up to the last scheduled timer asynchronously
+	 * @property {Reset} reset - clears all timers and resets the clock
+	 * @property {SetSystemTime} setSystemTime - sets the clock to a specific wall-clock time
+	 * @property {Jump} jump - advances time and returns the new `now`
+	 * @property {any} performance - fake performance object
+	 * @property {Hrtime} hrtime - faked `process.hrtime`
+	 * @property {Uninstall} uninstall - restores native timers
+	 * @property {string[]} methods - names of faked methods
+	 * @property {boolean} [shouldClearNativeTimers] - inherited from config
+	 * @property {{methodName:string, original:unknown}[] | undefined} timersModuleMethods - saved Node timers module methods
+	 * @property {{methodName:string, original:unknown}[] | undefined} timersPromisesModuleMethods - saved Node timers/promises methods
+	 * @property {Map<VoidVarArgsFunc, AbortSignal>} abortListenerMap - active abort listeners
+	 * @property {SetTickMode} setTickMode - switches the auto-tick mode
+	 * @property {Map<number, Timer>} [timers] - internal timer storage
+	 * @property {TimerHeap} [timerHeap] - internal timer heap
+	 * @property {boolean} [duringTick] - internal flag
+	 * @property {boolean} isNearInfiniteLimit - internal flag indicating the loop limit is nearly reached
+	 * @property {TimerId} [attachedInterval] - internal flag
+	 * @property {ClockTickMode} [tickMode] - internal flag
+	 * @property {Timer[]} [jobs] - internal flag
+	 * @property {IntlWithClock} [Intl] - fake Intl object
 	 */
-	/* eslint-enable jsdoc/require-property-description */
+	/* eslint-enable jsdoc/reject-any-type */
 
 	/**
 	 * Configuration object for the `install` method.
 	 * @typedef {object} Config
-	 * @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)
-	 * @property {string[]} [toFake] names of the methods that should be faked.
-	 * @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll()
-	 * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)
-	 * @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)
-	 * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)
-	 * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error
+	 * @property {number|Date} [now] initial mocked time, as milliseconds since epoch or a Date
+	 * @property {FakeMethod[]} [toFake] method names that should be faked
+	 * @property {FakeMethod[]} [toNotFake] method names that should remain native
+	 * @property {number} [loopLimit] maximum number of timers run before aborting with an infinite-loop error
+	 * @property {boolean} [shouldAdvanceTime] automatically increments mocked time while the clock is installed
+	 * @property {number} [advanceTimeDelta] interval in milliseconds used when `shouldAdvanceTime` is enabled
+	 * @property {boolean} [shouldClearNativeTimers] forwards clear calls to native methods when the timer is not fake
+	 * @property {boolean} [ignoreMissingTimers] suppresses errors when a requested timer is missing from the global object
+	 * @property {GlobalObject} [target] global object to install onto
 	 */
 
-	/* eslint-disable jsdoc/require-property-description */
 	/**
 	 * The internal structure to describe a scheduled fake timer
-	 * @typedef {object} Timer
-	 * @property {Function} func
-	 * @property {*[]} args
-	 * @property {number} delay
-	 * @property {number} callAt
-	 * @property {number} createdAt
-	 * @property {boolean} immediate
-	 * @property {number} id
-	 * @property {Error} [error]
+	 * @typedef {TimerInitialProps} Timer
+	 * @property {unknown[]} args - arguments passed to the callback
+	 * @property {number} callAt - scheduled execution time
+	 * @property {number} createdAt - time at which the timer was created
+	 * @property {number} id - unique timer identifier
+	 * @property {'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback'} type - timer kind
+	 */
+
+	/**
+	 * @callback NodeImmediateHasRef
+	 * @returns {boolean}
+	 */
+
+	/**
+	 * @callback NodeImmediateRef
+	 * @returns {NodeImmediate}
+	 */
+
+	/**
+	 * @callback NodeImmediateUnref
+	 * @returns {NodeImmediate}
 	 */
 
 	/**
 	 * A Node timer
 	 * @typedef {object} NodeImmediate
-	 * @property {function(): boolean} hasRef
-	 * @property {function(): NodeImmediate} ref
-	 * @property {function(): NodeImmediate} unref
+	 * @property {NodeImmediateHasRef} hasRef - reports whether the timer keeps the event loop alive
+	 * @property {NodeImmediateRef} ref - marks the timer as referenced
+	 * @property {NodeImmediateUnref} unref - marks the timer as unreferenced
 	 */
-	/* eslint-enable jsdoc/require-property-description */
 
 	/* eslint-disable complexity */
 
 	/**
 	 * Mocks available features in the specified global namespace.
-	 * @param {*} _global Namespace to mock (e.g. `window`)
+	 * @param {GlobalObject} _global Namespace to mock (e.g. `window`)
 	 * @returns {FakeTimers}
 	 */
 	function withGlobal(_global) {
@@ -2731,7 +3044,10 @@ function requireFakeTimersSrc () {
 	        _global.performance &&
 	        _global.performance.constructor &&
 	        _global.performance.constructor.prototype;
-	    isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+	    isPresent.queueMicrotask = Object.prototype.hasOwnProperty.call(
+	        _global,
+	        "queueMicrotask",
+	    );
 	    isPresent.requestAnimationFrame =
 	        _global.requestAnimationFrame &&
 	        typeof _global.requestAnimationFrame === "function";
@@ -2741,7 +3057,7 @@ function requireFakeTimersSrc () {
 	    isPresent.requestIdleCallback =
 	        _global.requestIdleCallback &&
 	        typeof _global.requestIdleCallback === "function";
-	    isPresent.cancelIdleCallbackPresent =
+	    isPresent.cancelIdleCallback =
 	        _global.cancelIdleCallback &&
 	        typeof _global.cancelIdleCallback === "function";
 	    isPresent.setImmediate =
@@ -2762,6 +3078,8 @@ function requireFakeTimersSrc () {
 	          )
 	        : undefined;
 	    let uniqueTimerId = idCounterStart;
+	    /** @type {number} */
+	    let uniqueTimerOrder = 0;
 
 	    if (NativeDate === undefined) {
 	        throw new Error(
@@ -2802,23 +3120,23 @@ function requireFakeTimersSrc () {
 	        return isFinite(num);
 	    }
 
-	    let isNearInfiniteLimit = false;
-
 	    /**
 	     * @param {Clock} clock
 	     * @param {number} i
 	     */
 	    function checkIsNearInfiniteLimit(clock, i) {
 	        if (clock.loopLimit && i === clock.loopLimit - 1) {
-	            isNearInfiniteLimit = true;
+	            clock.isNearInfiniteLimit = true;
 	        }
 	    }
 
 	    /**
-	     *
+	     * @param {Clock} clock
 	     */
-	    function resetIsNearInfiniteLimit() {
-	        isNearInfiniteLimit = false;
+	    function resetIsNearInfiniteLimit(clock) {
+	        if (clock) {
+	            clock.isNearInfiniteLimit = false;
+	        }
 	    }
 
 	    /**
@@ -2883,12 +3201,12 @@ function requireFakeTimersSrc () {
 	        if (!epoch) {
 	            return 0;
 	        }
-	        if (typeof epoch.getTime === "function") {
-	            return epoch.getTime();
-	        }
 	        if (typeof epoch === "number") {
 	            return epoch;
 	        }
+	        if (typeof epoch.getTime === "function") {
+	            return epoch.getTime();
+	        }
 	        throw new TypeError("now should be milliseconds since UNIX epoch");
 	    }
 
@@ -2905,6 +3223,7 @@ function requireFakeTimersSrc () {
 	    /**
 	     * @param {Clock} clock
 	     * @param {Timer} job
+	     * @returns {Error}
 	     */
 	    function getInfiniteLoopError(clock, job) {
 	        const infiniteLoopError = new Error(
@@ -2964,34 +3283,29 @@ function requireFakeTimersSrc () {
 	            Object.defineProperty(infiniteLoopError, "stack", {
 	                value: stack,
 	            });
-	        } catch (e) {
+	        } catch {
 	            // noop
 	        }
 
 	        return infiniteLoopError;
 	    }
 
-	    //eslint-disable-next-line jsdoc/require-jsdoc
+	    /**
+	     * @returns {typeof Date & { clock: Clock }}
+	     */
 	    function createDate() {
 	        class ClockDate extends NativeDate {
-	            /**
-	             * @param {number} year
-	             * @param {number} month
-	             * @param {number} date
-	             * @param {number} hour
-	             * @param {number} minute
-	             * @param {number} second
-	             * @param {number} ms
-	             * @returns void
-	             */
-	            // eslint-disable-next-line no-unused-vars
-	            constructor(year, month, date, hour, minute, second, ms) {
-	                // Defensive and verbose to avoid potential harm in passing
-	                // explicit undefined when user does not pass argument
-	                if (arguments.length === 0) {
+	            /** @type {Clock} */
+	            static clock;
+
+	            constructor(...args) {
+	                // Preserve fake time when Date is called without arguments.
+	                if (args.length === 0) {
 	                    super(ClockDate.clock.now);
 	                } else {
-	                    super(...arguments);
+	                    // The subclass is intentionally thin for explicit args.
+	                    // @ts-expect-error Date constructor overloads are intentionally dynamic.
+	                    super(...args);
 	                }
 
 	                // ensures identity checks using the constructor prop still works
@@ -3015,21 +3329,26 @@ function requireFakeTimersSrc () {
 	            };
 	        }
 
-	        if (NativeDate.toSource) {
+	        const NativeDateWithToSource =
+	            /** @type {typeof Date & { toSource?: () => string }} */ (
+	                NativeDate
+	            );
+
+	        if (NativeDateWithToSource.toSource) {
 	            ClockDate.toSource = function toSource() {
-	                return NativeDate.toSource();
+	                return NativeDateWithToSource.toSource();
 	            };
 	        }
 
 	        ClockDate.toString = function toString() {
-	            return NativeDate.toString();
+	            return NativeDateWithToSource.toString();
 	        };
 
 	        // noinspection UnnecessaryLocalVariableJS
 	        /**
 	         * A normal Class constructor cannot be called without `new`, but Date can, so we need
 	         * to wrap it in a Proxy in order to ensure this functionality of Date is kept intact
-	         * @type {ClockDate}
+	         * @type {typeof ClockDate}
 	         */
 	        const ClockDateProxy = new Proxy(ClockDate, {
 	            // handler for [[Call]] invocations (i.e. not using `new`)
@@ -3046,7 +3365,9 @@ function requireFakeTimersSrc () {
 	            },
 	        });
 
-	        return ClockDateProxy;
+	        return /** @type {typeof Date & { clock: Clock }} */ (
+	            /** @type {unknown} */ (ClockDateProxy)
+	        );
 	    }
 
 	    /**
@@ -3055,19 +3376,21 @@ function requireFakeTimersSrc () {
 	     * Most of the properties are the original native ones,
 	     * but we need to take control of those that have a
 	     * dependency on the current clock.
-	     * @returns {object} the partly fake Intl implementation
+	     * @param {Clock} clock
+	     * @returns {IntlWithClock} the partly fake Intl implementation
 	     */
-	    function createIntl() {
-	        const ClockIntl = {};
+	    function createIntl(clock) {
+	        /** @type {IntlWithClock} */
+	        const IntlWithClock = { clock: clock };
 	        /*
 	         * All properties of Intl are non-enumerable, so we need
 	         * to do a bit of work to get them out.
 	         */
 	        Object.getOwnPropertyNames(NativeIntl).forEach(
-	            (property) => (ClockIntl[property] = NativeIntl[property]),
+	            (property) => (IntlWithClock[property] = NativeIntl[property]),
 	        );
 
-	        ClockIntl.DateTimeFormat = function (...args) {
+	        IntlWithClock.DateTimeFormat = function (...args) {
 	            const realFormatter = new NativeIntl.DateTimeFormat(...args);
 	            const formatter = {};
 
@@ -3080,21 +3403,23 @@ function requireFakeTimersSrc () {
 
 	            ["format", "formatToParts"].forEach((method) => {
 	                formatter[method] = function (date) {
-	                    return realFormatter[method](date || ClockIntl.clock.now);
+	                    return realFormatter[method](
+	                        date || IntlWithClock.clock.now,
+	                    );
 	                };
 	            });
 
 	            return formatter;
 	        };
 
-	        ClockIntl.DateTimeFormat.prototype = Object.create(
+	        IntlWithClock.DateTimeFormat.prototype = Object.create(
 	            NativeIntl.DateTimeFormat.prototype,
 	        );
 
-	        ClockIntl.DateTimeFormat.supportedLocalesOf =
+	        IntlWithClock.DateTimeFormat.supportedLocalesOf =
 	            NativeIntl.DateTimeFormat.supportedLocalesOf;
 
-	        return ClockIntl;
+	        return IntlWithClock;
 	    }
 
 	    //eslint-disable-next-line jsdoc/require-jsdoc
@@ -3112,6 +3437,7 @@ function requireFakeTimersSrc () {
 	        if (!clock.jobs) {
 	            return;
 	        }
+	        const wasNearLimit = clock.isNearInfiniteLimit;
 	        for (let i = 0; i < clock.jobs.length; i++) {
 	            const job = clock.jobs[i];
 	            job.func.apply(null, job.args);
@@ -3121,38 +3447,275 @@ function requireFakeTimersSrc () {
 	                throw getInfiniteLoopError(clock, job);
 	            }
 	        }
-	        resetIsNearInfiniteLimit();
+	        if (!wasNearLimit) {
+	            resetIsNearInfiniteLimit(clock);
+	        }
 	        clock.jobs = [];
 	    }
 
+	    /**
+	     * A compact "soonest timer first" container.
+	     *
+	     * Think of this as a waiting room for scheduled callbacks where the next
+	     * callback to run is always kept at the front of the list. The internal
+	     * array is arranged so we can find, add, remove, and reorder timers
+	     * efficiently without sorting the whole list every time something changes.
+	     *
+	     * The important idea is not the data structure name, but the behavior:
+	     * the timer that should run next stays near the front, and when one timer
+	     * moves, the rest are shifted just enough to keep that promise true.
+	     */
+	    class TimerHeap {
+	        constructor() {
+	            this.timers = [];
+	        }
+
+	        /**
+	         * Look at the next timer without removing it.
+	         * This is the timer the clock would run first if time advanced now.
+	         * @returns {Timer}
+	         */
+	        peek() {
+	            return this.timers[0];
+	        }
+
+	        /**
+	         * Add a timer to the waiting room, then move it upward until it is in
+	         * the right place relative to the timers it should run before and after.
+	         * @param {Timer} timer
+	         */
+	        push(timer) {
+	            this.timers.push(timer);
+	            this.bubbleUp(this.timers.length - 1);
+	        }
+
+	        /**
+	         * Remove and return the next timer to run.
+	         *
+	         * We pull the front timer out, move the last timer into the empty spot,
+	         * and then shift that replacement down until the ordering is correct
+	         * again. That avoids rebuilding the whole list from scratch.
+	         * @returns {Timer|undefined}
+	         */
+	        pop() {
+	            if (this.timers.length === 0) {
+	                return undefined;
+	            }
+	            const first = this.timers[0];
+	            const last = this.timers.pop();
+	            if (this.timers.length > 0) {
+	                this.timers[0] = last;
+	                last.heapIndex = 0;
+	                this.bubbleDown(0);
+	            }
+	            delete first.heapIndex;
+	            return first;
+	        }
+
+	        /**
+	         * Remove a specific timer from the waiting room.
+	         *
+	         * The heap stores timers in a shape that lets us jump directly to the
+	         * timer's current position, replace it with the last timer, and then
+	         * move that replacement up or down until the ordering is correct again.
+	         * @param {Timer} timer
+	         * @returns {boolean}
+	         */
+	        remove(timer) {
+	            const index = timer.heapIndex;
+	            if (index === undefined || this.timers[index] !== timer) {
+	                return false;
+	            }
+	            const last = this.timers.pop();
+	            if (timer !== last) {
+	                this.timers[index] = last;
+	                last.heapIndex = index;
+	                if (compareTimers(last, timer) < 0) {
+	                    this.bubbleUp(index);
+	                } else {
+	                    this.bubbleDown(index);
+	                }
+	            }
+	            delete timer.heapIndex;
+	            return true;
+	        }
+
+	        /**
+	         * Move a timer toward the front until it is no longer "earlier" than
+	         * the timer above it.
+	         *
+	         * Conceptually, this is what happens when something newly scheduled
+	         * turns out to belong ahead of its parent in the waiting room. We keep
+	         * swapping it upward until it is no longer out of place.
+	         * @param {number} index
+	         */
+	        bubbleUp(index) {
+	            const timer = this.timers[index];
+	            let currentIndex = index;
+	            while (currentIndex > 0) {
+	                const parentIndex = Math.floor((currentIndex - 1) / 2);
+	                const parent = this.timers[parentIndex];
+	                if (compareTimers(timer, parent) < 0) {
+	                    this.timers[currentIndex] = parent;
+	                    parent.heapIndex = currentIndex;
+	                    currentIndex = parentIndex;
+	                } else {
+	                    break;
+	                }
+	            }
+	            this.timers[currentIndex] = timer;
+	            timer.heapIndex = currentIndex;
+	        }
+
+	        /**
+	         * Move a timer away from the front until the timer below it is no
+	         * longer supposed to run after it.
+	         *
+	         * This is the opposite of `bubbleUp`: when a timer at the front is
+	         * removed or moved, the replacement may be too far ahead, so we
+	         * repeatedly swap it downward with the best child until the waiting
+	         * room is ordered again.
+	         * @param {number} index
+	         */
+	        bubbleDown(index) {
+	            const timer = this.timers[index];
+	            let currentIndex = index;
+	            const halfLength = Math.floor(this.timers.length / 2);
+	            while (currentIndex < halfLength) {
+	                const leftIndex = currentIndex * 2 + 1;
+	                const rightIndex = leftIndex + 1;
+	                let bestChildIndex = leftIndex;
+	                let bestChild = this.timers[leftIndex];
+
+	                if (
+	                    rightIndex < this.timers.length &&
+	                    compareTimers(this.timers[rightIndex], bestChild) < 0
+	                ) {
+	                    bestChildIndex = rightIndex;
+	                    bestChild = this.timers[rightIndex];
+	                }
+
+	                if (compareTimers(bestChild, timer) < 0) {
+	                    this.timers[currentIndex] = bestChild;
+	                    bestChild.heapIndex = currentIndex;
+	                    currentIndex = bestChildIndex;
+	                } else {
+	                    break;
+	                }
+	            }
+	            this.timers[currentIndex] = timer;
+	            timer.heapIndex = currentIndex;
+	        }
+	    }
+
+	    /**
+	     * Ensure timer storage and heap stay in sync even if a clear path touches
+	     * timer state before anything has been scheduled.
+	     *
+	     * Why do we need two data structures to keep tabs on timers?
+	     * 1. Fast ID Lookup (clock.timers): This is a Map from timer IDs to their respective timer objects. It allows clearTimeout(id) and
+	     * clearInterval(id) to be $O(1)$ operations. Without this map, finding a specific timer in the heap to remove it would require a linear
+	     * $O(n)$ search, which would significantly degrade performance as the number of active timers grows.
+	     * 2. Efficient Scheduling (clock.timerHeap): This is a priority queue (min-heap) that keeps timers ordered by their execution time (callAt). It
+	     * allows the library to instantly find the next timer to run (peek() in $O(1)$) and efficiently update the schedule when timers are added or
+	     * removed ($O(\log n)$).
+	     *
+	     * In short: clock.timers provides fast access by ID, while clock.timerHeap provides fast access by Time. Removing either one would make common
+	     * operations (like clearing or finding the next timer) much slower.
+	     * @param {Clock} clock
+	     */
+	    function ensureTimerState(clock) {
+	        if (!clock.timers) {
+	            clock.timers = new Map();
+	            clock.timerHeap = new TimerHeap();
+	        }
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {number} id
+	     * @returns {boolean}
+	     */
+	    function hasTimer(clock, id) {
+	        return clock.timers ? clock.timers.has(id) : false;
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {number} id
+	     * @returns {Timer}
+	     */
+	    function getTimer(clock, id) {
+	        return clock.timers ? clock.timers.get(id) : undefined;
+	    }
+
 	    /**
 	     * @param {Clock} clock
 	     * @param {Timer} timer
-	     * @returns {number} id of the created timer
+	     */
+	    function setTimer(clock, timer) {
+	        ensureTimerState(clock);
+	        clock.timers.set(timer.id, timer);
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {number} id
+	     * @returns {boolean}
+	     */
+	    function deleteTimer(clock, id) {
+	        return clock.timers ? clock.timers.delete(id) : false;
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {(timer: Timer) => void} callback
+	     */
+	    function forEachActiveTimer(clock, callback) {
+	        if (!clock.timers) {
+	            return;
+	        }
+
+	        for (const timer of clock.timers.values()) {
+	            callback(timer);
+	        }
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     */
+	    function rebuildTimerHeap(clock) {
+	        clock.timerHeap = new TimerHeap();
+	        forEachActiveTimer(clock, (timer) => {
+	            clock.timerHeap.push(timer);
+	        });
+	    }
+
+	    /**
+	     * @param {Clock} clock
+	     * @param {TimerInitialProps} timer
+	     * @returns {TimerId} id of the created timer
 	     */
 	    function addTimer(clock, timer) {
 	        if (timer.func === undefined) {
 	            throw new Error("Callback must be provided to timer calls");
 	        }
 
-	        if (addTimerReturnsObject) {
-	            // Node.js environment
-	            if (typeof timer.func !== "function") {
-	                throw new TypeError(
-	                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${
-	                        timer.func
-	                    } of type ${typeof timer.func}`,
-	                );
-	            }
+	        if (typeof timer.func !== "function") {
+	            throw new TypeError(
+	                `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${
+	                    timer.func
+	                } of type ${typeof timer.func}`,
+	            );
 	        }
 
-	        if (isNearInfiniteLimit) {
+	        if (clock.isNearInfiniteLimit) {
 	            timer.error = new Error();
 	        }
 
 	        timer.type = timer.immediate ? "Immediate" : "Timeout";
 
-	        if (timer.hasOwnProperty("delay")) {
+	        if (Object.prototype.hasOwnProperty.call(timer, "delay")) {
 	            if (typeof timer.delay !== "number") {
 	                timer.delay = parseInt(timer.delay, 10);
 	            }
@@ -3164,42 +3727,60 @@ function requireFakeTimersSrc () {
 	            timer.delay = Math.max(0, timer.delay);
 	        }
 
-	        if (timer.hasOwnProperty("interval")) {
+	        if (Object.prototype.hasOwnProperty.call(timer, "interval")) {
 	            timer.type = "Interval";
 	            timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
 	        }
 
-	        if (timer.hasOwnProperty("animation")) {
+	        if (Object.prototype.hasOwnProperty.call(timer, "animation")) {
 	            timer.type = "AnimationFrame";
 	            timer.animation = true;
 	        }
 
-	        if (timer.hasOwnProperty("idleCallback")) {
-	            timer.type = "IdleCallback";
-	            timer.idleCallback = true;
+	        if (
+	            Object.prototype.hasOwnProperty.call(timer, "requestIdleCallback")
+	        ) {
+	            // mark timer as IdleCallback type if it has no delay, otherwise it'd be of type timeout
+	            // this way we are able to sort such that the timer only gets called when there's truly no pending task to run
+	            if (!timer.delay) {
+	                timer.type = "IdleCallback";
+	            }
+	            timer.requestIdleCallback = true;
 	        }
 
-	        if (!clock.timers) {
-	            clock.timers = {};
+	        ensureTimerState(clock);
+
+	        while (hasTimer(clock, uniqueTimerId)) {
+	            uniqueTimerId++;
+	            if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) {
+	                uniqueTimerId = idCounterStart;
+	            }
 	        }
 
 	        timer.id = uniqueTimerId++;
+	        if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) {
+	            uniqueTimerId = idCounterStart;
+	        }
+
+	        timer.order = uniqueTimerOrder++;
 	        timer.createdAt = clock.now;
 	        timer.callAt =
-	            clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+	            clock.now +
+	            (parseInt(String(timer.delay)) || (clock.duringTick ? 1 : 0));
 
-	        clock.timers[timer.id] = timer;
+	        setTimer(clock, timer);
+	        clock.timerHeap.push(timer);
 
 	        if (addTimerReturnsObject) {
 	            const res = {
 	                refed: true,
 	                ref: function () {
 	                    this.refed = true;
-	                    return res;
+	                    return this;
 	                },
 	                unref: function () {
 	                    this.refed = false;
-	                    return res;
+	                    return this;
 	                },
 	                hasRef: function () {
 	                    return this.refed;
@@ -3207,12 +3788,15 @@ function requireFakeTimersSrc () {
 	                refresh: function () {
 	                    timer.callAt =
 	                        clock.now +
-	                        (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+	                        (parseInt(String(timer.delay)) ||
+	                            (clock.duringTick ? 1 : 0));
 
-	                    // it _might_ have been removed, but if not the assignment is perfectly fine
-	                    clock.timers[timer.id] = timer;
+	                    clock.timerHeap.remove(timer);
+	                    timer.order = uniqueTimerOrder++;
+	                    setTimer(clock, timer);
+	                    clock.timerHeap.push(timer);
 
-	                    return res;
+	                    return this;
 	                },
 	                [Symbol.toPrimitive]: function () {
 	                    return timer.id;
@@ -3226,12 +3810,20 @@ function requireFakeTimersSrc () {
 
 	    /* eslint consistent-return: "off" */
 	    /**
-	     * Timer comparitor
+	     * Timer comparator
 	     * @param {Timer} a
 	     * @param {Timer} b
 	     * @returns {number}
 	     */
 	    function compareTimers(a, b) {
+	        // Sort IdleCallback timers to the bottom when scheduled for the same time
+	        if (a.type === "IdleCallback" && b.type !== "IdleCallback") {
+	            return 1;
+	        }
+	        if (a.type !== "IdleCallback" && b.type === "IdleCallback") {
+	            return -1;
+	        }
+
 	        // Sort first by absolute timing
 	        if (a.callAt < b.callAt) {
 	            return -1;
@@ -3248,6 +3840,13 @@ function requireFakeTimersSrc () {
 	            return 1;
 	        }
 
+	        if (a.order < b.order) {
+	            return -1;
+	        }
+	        if (a.order > b.order) {
+	            return 1;
+	        }
+
 	        // Sort next by creation time, earlier-created timers take precedence
 	        if (a.createdAt < b.createdAt) {
 	            return -1;
@@ -3265,6 +3864,7 @@ function requireFakeTimersSrc () {
 	        }
 
 	        // As timer ids are unique, no fallback `0` is necessary
+	        return 0;
 	    }
 
 	    /**
@@ -3274,20 +3874,31 @@ function requireFakeTimersSrc () {
 	     * @returns {Timer}
 	     */
 	    function firstTimerInRange(clock, from, to) {
-	        const timers = clock.timers;
-	        let timer = null;
-	        let id, isInRange;
+	        if (!clock.timerHeap) {
+	            return null;
+	        }
 
-	        for (id in timers) {
-	            if (timers.hasOwnProperty(id)) {
-	                isInRange = inRange(from, to, timers[id]);
+	        const timers = clock.timerHeap.timers;
+	        if (timers.length === 1 && timers[0].requestIdleCallback) {
+	            return timers[0];
+	        }
 
-	                if (
-	                    isInRange &&
-	                    (!timer || compareTimers(timer, timers[id]) === 1)
-	                ) {
-	                    timer = timers[id];
-	                }
+	        const first = clock.timerHeap.peek();
+	        if (first && inRange(from, to, first)) {
+	            return first;
+	        }
+
+	        /**
+	         * @type {?Timer}
+	         */
+	        let timer = null;
+
+	        for (let i = 0; i < timers.length; i++) {
+	            if (
+	                inRange(from, to, timers[i]) &&
+	                (!timer || compareTimers(timer, timers[i]) === 1)
+	            ) {
+	                timer = timers[i];
 	            }
 	        }
 
@@ -3299,19 +3910,10 @@ function requireFakeTimersSrc () {
 	     * @returns {Timer}
 	     */
 	    function firstTimer(clock) {
-	        const timers = clock.timers;
-	        let timer = null;
-	        let id;
-
-	        for (id in timers) {
-	            if (timers.hasOwnProperty(id)) {
-	                if (!timer || compareTimers(timer, timers[id]) === 1) {
-	                    timer = timers[id];
-	                }
-	            }
+	        if (!clock.timerHeap) {
+	            return null;
 	        }
-
-	        return timer;
+	        return clock.timerHeap.peek() || null;
 	    }
 
 	    /**
@@ -3319,15 +3921,15 @@ function requireFakeTimersSrc () {
 	     * @returns {Timer}
 	     */
 	    function lastTimer(clock) {
-	        const timers = clock.timers;
+	        if (!clock.timerHeap) {
+	            return null;
+	        }
+	        const timers = clock.timerHeap.timers;
 	        let timer = null;
-	        let id;
 
-	        for (id in timers) {
-	            if (timers.hasOwnProperty(id)) {
-	                if (!timer || compareTimers(timer, timers[id]) === -1) {
-	                    timer = timers[id];
-	                }
+	        for (let i = 0; i < timers.length; i++) {
+	            if (!timer || compareTimers(timer, timers[i]) === -1) {
+	                timer = timers[i];
 	            }
 	        }
 
@@ -3340,25 +3942,27 @@ function requireFakeTimersSrc () {
 	     */
 	    function callTimer(clock, timer) {
 	        if (typeof timer.interval === "number") {
-	            clock.timers[timer.id].callAt += timer.interval;
+	            clock.timerHeap.remove(timer);
+	            timer.callAt += timer.interval;
+	            timer.order = uniqueTimerOrder++;
+	            if (clock.isNearInfiniteLimit) {
+	                timer.error = new Error();
+	            }
+	            clock.timerHeap.push(timer);
 	        } else {
-	            delete clock.timers[timer.id];
+	            deleteTimer(clock, timer.id);
+	            clock.timerHeap.remove(timer);
 	        }
 
 	        if (typeof timer.func === "function") {
 	            timer.func.apply(null, timer.args);
-	        } else {
-	            /* eslint no-eval: "off" */
-	            const eval2 = eval;
-	            (function () {
-	                eval2(timer.func);
-	            })();
 	        }
 	    }
 
 	    /**
 	     * Gets clear handler name for a given timer type
 	     * @param {string} ttype
+	     * @returns {string}
 	     */
 	    function getClearHandler(ttype) {
 	        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
@@ -3370,6 +3974,7 @@ function requireFakeTimersSrc () {
 	    /**
 	     * Gets schedule handler name for a given timer type
 	     * @param {string} ttype
+	     * @returns {string}
 	     */
 	    function getScheduleHandler(ttype) {
 	        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
@@ -3380,6 +3985,7 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Creates an anonymous function to warn only once
+	     * @returns {(msg: string) => void}
 	     */
 	    function createWarnOnce() {
 	        let calls = 0;
@@ -3392,8 +3998,9 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * @param {Clock} clock
-	     * @param {number} timerId
+	     * @param {TimerId} timerId
 	     * @param {string} ttype
+	     * @returns {void}
 	     */
 	    function clearTimer(clock, timerId, ttype) {
 	        if (!timerId) {
@@ -3402,10 +4009,6 @@ function requireFakeTimersSrc () {
 	            return;
 	        }
 
-	        if (!clock.timers) {
-	            clock.timers = {};
-	        }
-
 	        // in Node, the ID is stored as the primitive value for `Timeout` objects
 	        // for `Immediate` objects, no ID exists, so it gets coerced to NaN
 	        const id = Number(timerId);
@@ -3419,21 +4022,30 @@ function requireFakeTimersSrc () {
 	                    ? nativeHandler(timerId)
 	                    : undefined;
 	            }
+
+	            // Include the stacktrace, excluding the 'error' line
+	            const stackTrace = new Error().stack
+	                .split("\n")
+	                .slice(1)
+	                .join("\n");
+
 	            warnOnce(
 	                `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.` +
-	                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`.",
+	                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`." +
+	                    `\n${stackTrace}`,
 	            );
 	        }
 
-	        if (clock.timers.hasOwnProperty(id)) {
+	        if (hasTimer(clock, id)) {
 	            // check that the ID matches a timer of the correct type
-	            const timer = clock.timers[id];
+	            const timer = getTimer(clock, id);
 	            if (
 	                timer.type === ttype ||
 	                (timer.type === "Timeout" && ttype === "Interval") ||
 	                (timer.type === "Interval" && ttype === "Timeout")
 	            ) {
-	                delete clock.timers[id];
+	                deleteTimer(clock, id);
+	                clock.timerHeap.remove(timer);
 	            } else {
 	                const clear = getClearHandler(ttype);
 	                const schedule = getScheduleHandler(timer.type);
@@ -3478,12 +4090,12 @@ function requireFakeTimersSrc () {
 	                    _global[method] = clock[`_${method}`];
 	                }
 	            } else {
-	                if (_global[method] && _global[method].hadOwnProperty) {
+	                if (clock[method] && clock[method].hasOwnProperty) {
 	                    _global[method] = clock[`_${method}`];
 	                } else {
 	                    try {
 	                        delete _global[method];
-	                    } catch (ignore) {
+	                    } catch {
 	                        /* eslint no-empty: "off" */
 	                    }
 	                }
@@ -3506,7 +4118,7 @@ function requireFakeTimersSrc () {
 	            }
 	        }
 
-	        clock.setTickMode("manual");
+	        clock.setTickMode({ mode: "manual" });
 
 	        // Prevent multiple executions which will completely remove these props
 	        clock.methods = [];
@@ -3517,12 +4129,10 @@ function requireFakeTimersSrc () {
 	        }
 
 	        // return pending timers, to enable checking what timers remained on uninstall
-	        if (!clock.timers) {
+	        if (!clock.timerHeap) {
 	            return [];
 	        }
-	        return Object.keys(clock.timers).map(function mapper(key) {
-	            return clock.timers[key];
-	        });
+	        return clock.timerHeap.timers.slice();
 	    }
 
 	    /**
@@ -3531,7 +4141,7 @@ function requireFakeTimersSrc () {
 	     * @param {Clock} clock
 	     */
 	    function hijackMethod(target, method, clock) {
-	        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
+	        clock[method].hasOwnProperty = Object.prototype.hasOwnProperty.call(
 	            target,
 	            method,
 	        );
@@ -3588,26 +4198,6 @@ function requireFakeTimersSrc () {
 	        clock.tick(advanceTimeDelta);
 	    }
 
-	    /**
-	     * @typedef {object} Timers
-	     * @property {setTimeout} setTimeout
-	     * @property {clearTimeout} clearTimeout
-	     * @property {setInterval} setInterval
-	     * @property {clearInterval} clearInterval
-	     * @property {Date} Date
-	     * @property {Intl} Intl
-	     * @property {SetImmediate=} setImmediate
-	     * @property {function(NodeImmediate): void=} clearImmediate
-	     * @property {function(number[]):number[]=} hrtime
-	     * @property {NextTick=} nextTick
-	     * @property {Performance=} performance
-	     * @property {RequestAnimationFrame=} requestAnimationFrame
-	     * @property {boolean=} queueMicrotask
-	     * @property {function(number): void=} cancelAnimationFrame
-	     * @property {RequestIdleCallback=} requestIdleCallback
-	     * @property {function(number): void=} cancelIdleCallback
-	     */
-
 	    /** @type {Timers} */
 	    const timers = {
 	        setTimeout: _global.setTimeout,
@@ -3671,30 +4261,37 @@ function requireFakeTimersSrc () {
 	     * @returns {Clock}
 	     */
 	    function createClock(start, loopLimit) {
+	        /** @type {number} */
 	        // eslint-disable-next-line no-param-reassign
 	        start = Math.floor(getEpoch(start));
+	        const startTimestamp = start;
 	        // eslint-disable-next-line no-param-reassign
 	        loopLimit = loopLimit || 1000;
+	        /** @type {number} */
 	        let nanos = 0;
+	        /** @type {number[]} */
 	        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
 
-	        const clock = {
+	        /** @type {Clock} */
+	        const clock = /** @type {Clock} */ ({
 	            now: start,
 	            Date: createDate(),
 	            loopLimit: loopLimit,
+	            isNearInfiniteLimit: false,
 	            tickMode: { mode: "manual", counter: 0, delta: undefined },
-	        };
+	        });
 
 	        clock.Date.clock = clock;
 
 	        //eslint-disable-next-line jsdoc/require-jsdoc
 	        function getTimeToNextFrame() {
-	            return 16 - ((clock.now - start) % 16);
+	            return 16 - ((clock.now - startTimestamp) % 16);
 	        }
 
 	        //eslint-disable-next-line jsdoc/require-jsdoc
 	        function hrtime(prev) {
-	            const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
+	            const millisSinceStart =
+	                clock.now - adjustedSystemTime[0] - startTimestamp;
 	            const secsSinceStart = Math.floor(millisSinceStart / 1000);
 	            const remainderInNanos =
 	                (millisSinceStart - secsSinceStart * 1e3) * 1e6 +
@@ -3740,20 +4337,21 @@ function requireFakeTimersSrc () {
 	        if (isPresent.hrtimeBigint) {
 	            hrtime.bigint = function () {
 	                const parts = hrtime();
-	                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line
+	                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
 	            };
 	        }
 
 	        if (isPresent.Intl) {
-	            clock.Intl = createIntl();
+	            clock.Intl = createIntl(clock);
 	            clock.Intl.clock = clock;
 	        }
 
 	        /**
-	         * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
+	         * @param {SetTickModeConfig} tickModeConfig - The new configuration for how the clock should tick.
 	         */
 	        clock.setTickMode = function (tickModeConfig) {
-	            const { mode: newMode, delta: newDelta } = tickModeConfig;
+	            const { mode: newMode, delta: newDelta } =
+	                /** @type {SetTickModeConfig} */ (tickModeConfig);
 	            const { mode: oldMode, delta: oldDelta } = clock.tickMode;
 	            if (newMode === oldMode && newDelta === oldDelta) {
 	                return;
@@ -3776,7 +4374,15 @@ function requireFakeTimersSrc () {
 	            }
 	        };
 
+	        /**
+	         * Keeps advancing the native event loop until the tick mode changes.
+	         * @returns {Promise<void>}
+	         */
 	        async function advanceUntilModeChanges() {
+	            /**
+	             * Waits for one native macrotask and then one microtask turn.
+	             * @returns {Promise<void>}
+	             */
 	            async function newMacrotask() {
 	                // MessageChannel ensures that setTimeout is not throttled to 4ms.
 	                // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified
@@ -3784,7 +4390,7 @@ function requireFakeTimersSrc () {
 	                const channel = new MessageChannel();
 	                await new Promise((resolve) => {
 	                    channel.port1.onmessage = () => {
-	                        resolve();
+	                        resolve(undefined);
 	                        channel.port1.close();
 	                    };
 	                    channel.port2.postMessage(undefined);
@@ -3807,6 +4413,11 @@ function requireFakeTimersSrc () {
 	            }
 	        }
 
+	        /**
+	         * Temporarily pauses nextAsync auto-ticking while an async operation runs.
+	         * @param {Promise<unknown>} promise
+	         * @returns {Promise<unknown>}
+	         */
 	        function pauseAutoTickUntilFinished(promise) {
 	            if (clock.tickMode.mode !== "nextAsync") {
 	                return promise;
@@ -3817,24 +4428,37 @@ function requireFakeTimersSrc () {
 	            });
 	        }
 
-	        clock.requestIdleCallback = function requestIdleCallback(
-	            func,
-	            timeout,
-	        ) {
+	        /**
+	         * Returns the remaining time in the current idle window.
+	         * @returns {number}
+	         */
+	        function getTimeToNextIdlePeriod() {
 	            let timeToNextIdlePeriod = 0;
 
 	            if (clock.countTimers() > 0) {
 	                timeToNextIdlePeriod = 50; // const for now
 	            }
 
+	            return timeToNextIdlePeriod;
+	        }
+
+	        clock.requestIdleCallback = function requestIdleCallback(
+	            func,
+	            { timeout } = /** @type {{ timeout?: number }} */ ({}),
+	        ) {
+	            /**
+	             * @type {IdleDeadline}
+	             */
+	            const idleDeadline = {
+	                didTimeout: true,
+	                timeRemaining: getTimeToNextIdlePeriod,
+	            };
+
 	            const result = addTimer(clock, {
 	                func: func,
-	                args: Array.prototype.slice.call(arguments, 2),
-	                delay:
-	                    typeof timeout === "undefined"
-	                        ? timeToNextIdlePeriod
-	                        : Math.min(timeout, timeToNextIdlePeriod),
-	                idleCallback: true,
+	                args: [idleDeadline],
+	                delay: timeout,
+	                requestIdleCallback: true,
 	            });
 
 	            return Number(result);
@@ -3874,7 +4498,7 @@ function requireFakeTimersSrc () {
 	            return enqueueJob(clock, {
 	                func: func,
 	                args: Array.prototype.slice.call(arguments, 1),
-	                error: isNearInfiniteLimit ? new Error() : null,
+	                error: clock.isNearInfiniteLimit ? new Error() : null,
 	            });
 	        };
 
@@ -3884,7 +4508,7 @@ function requireFakeTimersSrc () {
 
 	        clock.setInterval = function setInterval(func, timeout) {
 	            // eslint-disable-next-line no-param-reassign
-	            timeout = parseInt(timeout, 10);
+	            timeout = parseInt(String(timeout), 10);
 	            return addTimer(clock, {
 	                func: func,
 	                args: Array.prototype.slice.call(arguments, 2),
@@ -3898,13 +4522,15 @@ function requireFakeTimersSrc () {
 	        };
 
 	        if (isPresent.setImmediate) {
-	            clock.setImmediate = function setImmediate(func) {
-	                return addTimer(clock, {
-	                    func: func,
-	                    args: Array.prototype.slice.call(arguments, 1),
-	                    immediate: true,
-	                });
-	            };
+	            clock.setImmediate = /** @type {SetImmediate} */ (
+	                function setImmediate(func) {
+	                    return addTimer(clock, {
+	                        func: func,
+	                        args: Array.prototype.slice.call(arguments, 1),
+	                        immediate: true,
+	                    });
+	                }
+	            );
 
 	            if (typeof _global.Promise !== "undefined" && utilPromisify) {
 	                clock.setImmediate[utilPromisify.custom] =
@@ -3928,7 +4554,7 @@ function requireFakeTimersSrc () {
 
 	        clock.countTimers = function countTimers() {
 	            return (
-	                Object.keys(clock.timers || {}).length +
+	                (clock.timerHeap ? clock.timerHeap.timers.length : 0) +
 	                (clock.jobs || []).length
 	            );
 	        };
@@ -3956,12 +4582,9 @@ function requireFakeTimersSrc () {
 
 	        /**
 	         * @param {number|string} tickValue milliseconds or a string parseable by parseTime
-	         * @param {boolean} isAsync
-	         * @param {Function} resolve
-	         * @param {Function} reject
-	         * @returns {number|undefined} will return the new `now` value or nothing for async
+	         * @returns {ClockState} a mutable state object for the tick execution
 	         */
-	        function doTick(tickValue, isAsync, resolve, reject) {
+	        function createTickState(tickValue) {
 	            const msFloat =
 	                typeof tickValue === "number"
 	                    ? tickValue
@@ -3981,122 +4604,202 @@ function requireFakeTimersSrc () {
 	                nanosTotal -= 1e6;
 	            }
 
-	            nanos = nanosTotal;
-	            let tickFrom = clock.now;
-	            let previous = clock.now;
-	            // ESLint fails to detect this correctly
-	            /* eslint-disable prefer-const */
-	            let timer,
-	                firstException,
-	                oldNow,
-	                nextPromiseTick,
-	                compensationCheck,
-	                postTimerCall;
-	            /* eslint-enable prefer-const */
-
-	            clock.duringTick = true;
+	            return /** @type {ClockState} */ ({
+	                msFloat: msFloat,
+	                ms: ms,
+	                nanosTotal: nanosTotal,
+	                tickFrom: clock.now,
+	                tickTo: tickTo,
+	                previous: clock.now,
+	                timer: null,
+	                firstException: null,
+	                oldNow: null,
+	            });
+	        }
 
-	            // perform microtasks
-	            oldNow = clock.now;
-	            runJobs(clock);
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         * @param {number} oldNow the clock.now before some action
+	         * @param {object} [options] compensation options
+	         * @param {boolean} [options.includePrevious] whether to also update state.previous
+	         */
+	        function applyClockChangeCompensation(state, oldNow, options) {
 	            if (oldNow !== clock.now) {
-	                // compensate for any setSystemTime() call during microtask callback
-	                tickFrom += clock.now - oldNow;
-	                tickTo += clock.now - oldNow;
+	                const difference = clock.now - oldNow;
+	                state.tickFrom += difference;
+	                state.tickTo += difference;
+	                if (options && options.includePrevious) {
+	                    state.previous += difference;
+	                }
 	            }
+	        }
 
-	            //eslint-disable-next-line jsdoc/require-jsdoc
-	            function doTickInner() {
-	                // perform each timer in the requested range
-	                timer = firstTimerInRange(clock, tickFrom, tickTo);
-	                // eslint-disable-next-line no-unmodified-loop-condition
-	                while (timer && tickFrom <= tickTo) {
-	                    if (clock.timers[timer.id]) {
-	                        tickFrom = timer.callAt;
-	                        clock.now = timer.callAt;
-	                        oldNow = clock.now;
-	                        try {
-	                            runJobs(clock);
-	                            callTimer(clock, timer);
-	                        } catch (e) {
-	                            firstException = firstException || e;
-	                        }
-
-	                        if (isAsync) {
-	                            // finish up after native setImmediate callback to allow
-	                            // all native es6 promises to process their callbacks after
-	                            // each timer fires.
-	                            originalSetTimeout(nextPromiseTick);
-	                            return;
-	                        }
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         */
+	        function runInitialJobs(state) {
+	            state.oldNow = clock.now;
+	            runJobs(clock);
+	            applyClockChangeCompensation(state, state.oldNow);
+	        }
 
-	                        compensationCheck();
-	                    }
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         */
+	        function runPostLoopJobs(state) {
+	            state.oldNow = clock.now;
+	            runJobs(clock);
+	            applyClockChangeCompensation(state, state.oldNow);
+	        }
 
-	                    postTimerCall();
-	                }
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         */
+	        function selectNextTimerInRange(state) {
+	            state.timer = firstTimerInRange(
+	                clock,
+	                state.previous,
+	                state.tickTo,
+	            );
+	            state.previous = state.tickFrom;
+	        }
 
-	                // perform process.nextTick()s again
-	                oldNow = clock.now;
-	                runJobs(clock);
-	                if (oldNow !== clock.now) {
-	                    // compensate for any setSystemTime() call during process.nextTick() callback
-	                    tickFrom += clock.now - oldNow;
-	                    tickTo += clock.now - oldNow;
-	                }
-	                clock.duringTick = false;
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         * @param {boolean} isAsync whether this is an async tick
+	         * @param {FakeTimersFunction} nextPromiseTick callback for async promise settlement
+	         * @param {FakeTimersFunction} compensationCheck callback for clock change compensation
+	         * @returns {boolean} whether an early return was triggered (async mode)
+	         */
+	        function runTimersInRange(
+	            state,
+	            isAsync,
+	            nextPromiseTick,
+	            compensationCheck,
+	        ) {
+	            state.timer = firstTimerInRange(
+	                clock,
+	                state.tickFrom,
+	                state.tickTo,
+	            );
 
-	                // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]
-	                timer = firstTimerInRange(clock, tickFrom, tickTo);
-	                if (timer) {
+	            while (state.timer && state.tickFrom <= state.tickTo) {
+	                if (hasTimer(clock, state.timer.id)) {
+	                    state.tickFrom = state.timer.callAt;
+	                    clock.now = state.timer.callAt;
+	                    state.oldNow = clock.now;
 	                    try {
-	                        clock.tick(tickTo - clock.now); // do it all again - for the remainder of the requested range
+	                        runJobs(clock);
+	                        callTimer(clock, state.timer);
 	                    } catch (e) {
-	                        firstException = firstException || e;
+	                        state.firstException = state.firstException || e;
 	                    }
-	                } else {
-	                    // no timers remaining in the requested range: move the clock all the way to the end
-	                    clock.now = tickTo;
 
-	                    // update nanos
-	                    nanos = nanosTotal;
-	                }
-	                if (firstException) {
-	                    throw firstException;
+	                    if (isAsync) {
+	                        // finish up after native setImmediate callback to allow
+	                        // all native es6 promises to process their callbacks after
+	                        // each timer fires.
+	                        originalSetTimeout(nextPromiseTick);
+	                        return true;
+	                    }
+
+	                    compensationCheck();
 	                }
 
-	                if (isAsync) {
-	                    resolve(clock.now);
-	                } else {
-	                    return clock.now;
+	                selectNextTimerInRange(state);
+	            }
+	            return false;
+	        }
+
+	        /**
+	         * @param {ClockState} state mutable tick state
+	         * @param {boolean} isAsync whether this is an async tick
+	         * @param {FakeTimersFunction} resolve promise resolve function
+	         * @returns {number|undefined} the new clock.now or nothing for async
+	         */
+	        function finalizeTick(state, isAsync, resolve) {
+	            // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]
+	            state.timer = firstTimerInRange(
+	                clock,
+	                state.tickFrom,
+	                state.tickTo,
+	            );
+	            if (state.timer) {
+	                try {
+	                    clock.tick(state.tickTo - clock.now); // do it all again - for the remainder of the requested range
+	                } catch (e) {
+	                    state.firstException = state.firstException || e;
 	                }
+	            } else {
+	                // no timers remaining in the requested range: move the clock all the way to the end
+	                clock.now = state.tickTo;
+
+	                // update nanos
+	                nanos = state.nanosTotal;
+	            }
+	            if (state.firstException) {
+	                throw state.firstException;
 	            }
 
-	            nextPromiseTick =
+	            if (isAsync) {
+	                resolve(clock.now);
+	            } else {
+	                return clock.now;
+	            }
+	        }
+
+	        /**
+	         * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+	         * @param {boolean} isAsync whether this is an async tick
+	         * @param {FakeTimersFunction} [resolve] promise resolve function
+	         * @param {FakeTimersFunction} [reject] promise reject function
+	         * @returns {number|undefined} the new clock.now or nothing for async
+	         */
+	        function doTick(tickValue, isAsync, resolve, reject) {
+	            /** @type {ClockState} */
+	            const state = createTickState(tickValue);
+
+	            nanos = state.nanosTotal;
+	            clock.duringTick = true;
+
+	            runInitialJobs(state);
+
+	            const compensationCheck = function () {
+	                applyClockChangeCompensation(state, state.oldNow, {
+	                    includePrevious: true,
+	                });
+	            };
+
+	            const nextPromiseTick =
 	                isAsync &&
 	                function () {
 	                    try {
 	                        compensationCheck();
-	                        postTimerCall();
+	                        selectNextTimerInRange(state);
 	                        doTickInner();
 	                    } catch (e) {
 	                        reject(e);
 	                    }
 	                };
 
-	            compensationCheck = function () {
-	                // compensate for any setSystemTime() call during timer callback
-	                if (oldNow !== clock.now) {
-	                    tickFrom += clock.now - oldNow;
-	                    tickTo += clock.now - oldNow;
-	                    previous += clock.now - oldNow;
+	            //eslint-disable-next-line jsdoc/require-jsdoc
+	            function doTickInner() {
+	                if (
+	                    runTimersInRange(
+	                        state,
+	                        isAsync,
+	                        nextPromiseTick,
+	                        compensationCheck,
+	                    )
+	                ) {
+	                    return;
 	                }
-	            };
 
-	            postTimerCall = function () {
-	                timer = firstTimerInRange(clock, previous, tickTo);
-	                previous = tickFrom;
-	            };
+	                runPostLoopJobs(state);
+	                clock.duringTick = false;
+
+	                return finalizeTick(state, isAsync, resolve);
+	            }
 
 	            return doTickInner();
 	        }
@@ -4109,26 +4812,6 @@ function requireFakeTimersSrc () {
 	            return doTick(tickValue, false);
 	        };
 
-	        if (typeof _global.Promise !== "undefined") {
-	            /**
-	             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
-	             * @returns {Promise}
-	             */
-	            clock.tickAsync = function tickAsync(tickValue) {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        originalSetTimeout(function () {
-	                            try {
-	                                doTick(tickValue, true, resolve, reject);
-	                            } catch (e) {
-	                                reject(e);
-	                            }
-	                        });
-	                    }),
-	                );
-	            };
-	        }
-
 	        clock.next = function next() {
 	            runJobs(clock);
 	            const timer = firstTimer(clock);
@@ -4147,61 +4830,40 @@ function requireFakeTimersSrc () {
 	            }
 	        };
 
-	        if (typeof _global.Promise !== "undefined") {
-	            clock.nextAsync = function nextAsync() {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        originalSetTimeout(function () {
-	                            try {
-	                                const timer = firstTimer(clock);
-	                                if (!timer) {
-	                                    resolve(clock.now);
-	                                    return;
-	                                }
-
-	                                let err;
-	                                clock.duringTick = true;
-	                                clock.now = timer.callAt;
-	                                try {
-	                                    callTimer(clock, timer);
-	                                } catch (e) {
-	                                    err = e;
-	                                }
-	                                clock.duringTick = false;
-
-	                                originalSetTimeout(function () {
-	                                    if (err) {
-	                                        reject(err);
-	                                    } else {
-	                                        resolve(clock.now);
-	                                    }
-	                                });
-	                            } catch (e) {
-	                                reject(e);
-	                            }
-	                        });
-	                    }),
-	                );
-	            };
+	        /**
+	         * @param {(resolve: (value: unknown) => void, reject: (reason?: unknown) => void) => void} callback function to run inside native setTimeout
+	         * @returns {Promise}
+	         */
+	        function runAsyncWithNativeTimeout(callback) {
+	            return pauseAutoTickUntilFinished(
+	                new _global.Promise(function (resolve, reject) {
+	                    originalSetTimeout(function () {
+	                        try {
+	                            callback(resolve, reject);
+	                        } catch (e) {
+	                            reject(e);
+	                        }
+	                    });
+	                }),
+	            );
 	        }
 
 	        clock.runAll = function runAll() {
-	            let numTimers, i;
 	            runJobs(clock);
-	            for (i = 0; i < clock.loopLimit; i++) {
+	            for (let i = 0; i < clock.loopLimit; i++) {
 	                if (!clock.timers) {
-	                    resetIsNearInfiniteLimit();
+	                    resetIsNearInfiniteLimit(clock);
 	                    return clock.now;
 	                }
 
-	                numTimers = Object.keys(clock.timers).length;
+	                const numTimers = clock.timerHeap.timers.length;
 	                if (numTimers === 0) {
-	                    resetIsNearInfiniteLimit();
+	                    resetIsNearInfiniteLimit(clock);
 	                    return clock.now;
 	                }
 
-	                clock.next();
 	                checkIsNearInfiniteLimit(clock, i);
+	                clock.next();
 	            }
 
 	            const excessJob = firstTimer(clock);
@@ -4212,60 +4874,6 @@ function requireFakeTimersSrc () {
 	            return clock.tick(getTimeToNextFrame());
 	        };
 
-	        if (typeof _global.Promise !== "undefined") {
-	            clock.runAllAsync = function runAllAsync() {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        let i = 0;
-	                        /**
-	                         *
-	                         */
-	                        function doRun() {
-	                            originalSetTimeout(function () {
-	                                try {
-	                                    runJobs(clock);
-
-	                                    let numTimers;
-	                                    if (i < clock.loopLimit) {
-	                                        if (!clock.timers) {
-	                                            resetIsNearInfiniteLimit();
-	                                            resolve(clock.now);
-	                                            return;
-	                                        }
-
-	                                        numTimers = Object.keys(
-	                                            clock.timers,
-	                                        ).length;
-	                                        if (numTimers === 0) {
-	                                            resetIsNearInfiniteLimit();
-	                                            resolve(clock.now);
-	                                            return;
-	                                        }
-
-	                                        clock.next();
-
-	                                        i++;
-
-	                                        doRun();
-	                                        checkIsNearInfiniteLimit(clock, i);
-	                                        return;
-	                                    }
-
-	                                    const excessJob = firstTimer(clock);
-	                                    reject(
-	                                        getInfiniteLoopError(clock, excessJob),
-	                                    );
-	                                } catch (e) {
-	                                    reject(e);
-	                                }
-	                            });
-	                        }
-	                        doRun();
-	                    }),
-	                );
-	            };
-	        }
-
 	        clock.runToLast = function runToLast() {
 	            const timer = lastTimer(clock);
 	            if (!timer) {
@@ -4277,32 +4885,110 @@ function requireFakeTimersSrc () {
 	        };
 
 	        if (typeof _global.Promise !== "undefined") {
-	            clock.runToLastAsync = function runToLastAsync() {
-	                return pauseAutoTickUntilFinished(
-	                    new _global.Promise(function (resolve, reject) {
-	                        originalSetTimeout(function () {
-	                            try {
-	                                const timer = lastTimer(clock);
-	                                if (!timer) {
-	                                    runJobs(clock);
-	                                    resolve(clock.now);
-	                                }
+	            /**
+	             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+	             * @returns {Promise}
+	             */
+	            clock.tickAsync = function tickAsync(tickValue) {
+	                return runAsyncWithNativeTimeout(function (resolve, reject) {
+	                    doTick(tickValue, true, resolve, reject);
+	                });
+	            };
 
-	                                resolve(
-	                                    clock.tickAsync(timer.callAt - clock.now),
-	                                );
-	                            } catch (e) {
-	                                reject(e);
+	            clock.nextAsync = function nextAsync() {
+	                return runAsyncWithNativeTimeout(function (resolve, reject) {
+	                    const timer = firstTimer(clock);
+	                    if (!timer) {
+	                        resolve(clock.now);
+	                        return;
+	                    }
+
+	                    let err;
+	                    clock.duringTick = true;
+	                    clock.now = timer.callAt;
+	                    try {
+	                        callTimer(clock, timer);
+	                    } catch (e) {
+	                        err = e;
+	                    }
+	                    clock.duringTick = false;
+
+	                    originalSetTimeout(function () {
+	                        if (err) {
+	                            reject(err);
+	                        } else {
+	                            resolve(clock.now);
+	                        }
+	                    });
+	                });
+	            };
+
+	            clock.runAllAsync = function runAllAsync() {
+	                let i = 0;
+	                /**
+	                 * @param {(value: unknown) => void} resolve promise resolve function
+	                 * @param {(reason?: unknown) => void} reject promise reject function
+	                 */
+	                function doRun(resolve, reject) {
+	                    try {
+	                        runJobs(clock);
+
+	                        let numTimers;
+	                        if (i < clock.loopLimit) {
+	                            if (!clock.timerHeap) {
+	                                resetIsNearInfiniteLimit(clock);
+	                                resolve(clock.now);
+	                                return;
 	                            }
-	                        });
-	                    }),
-	                );
+
+	                            numTimers = clock.timerHeap.timers.length;
+	                            if (numTimers === 0) {
+	                                resetIsNearInfiniteLimit(clock);
+	                                resolve(clock.now);
+	                                return;
+	                            }
+
+	                            checkIsNearInfiniteLimit(clock, i);
+	                            clock.next();
+
+	                            i++;
+
+	                            originalSetTimeout(function () {
+	                                doRun(resolve, reject);
+	                            });
+	                            return;
+	                        }
+
+	                        const excessJob = firstTimer(clock);
+	                        reject(getInfiniteLoopError(clock, excessJob));
+	                    } catch (e) {
+	                        reject(e);
+	                    }
+	                }
+
+	                return runAsyncWithNativeTimeout(function (resolve, reject) {
+	                    doRun(resolve, reject);
+	                });
+	            };
+
+	            clock.runToLastAsync = function runToLastAsync() {
+	                return runAsyncWithNativeTimeout(function (resolve) {
+	                    const timer = lastTimer(clock);
+	                    if (!timer) {
+	                        runJobs(clock);
+	                        resolve(clock.now);
+	                        return;
+	                    }
+
+	                    resolve(clock.tickAsync(timer.callAt - clock.now));
+	                });
 	            };
 	        }
 
 	        clock.reset = function reset() {
 	            nanos = 0;
-	            clock.timers = {};
+	            clock.timers = new Map();
+	            clock.timerHeap = new TimerHeap();
 	            clock.jobs = [];
 	            clock.now = start;
 	        };
@@ -4311,7 +4997,6 @@ function requireFakeTimersSrc () {
 	            // determine time difference
 	            const newNow = getEpoch(systemTime);
 	            const difference = newNow - clock.now;
-	            let id, timer;
 
 	            adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
 	            adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
@@ -4320,18 +5005,15 @@ function requireFakeTimersSrc () {
 	            nanos = 0;
 
 	            // update timers and intervals to keep them stable
-	            for (id in clock.timers) {
-	                if (clock.timers.hasOwnProperty(id)) {
-	                    timer = clock.timers[id];
-	                    timer.createdAt += difference;
-	                    timer.callAt += difference;
-	                }
-	            }
+	            forEachActiveTimer(clock, (timer) => {
+	                timer.createdAt += difference;
+	                timer.callAt += difference;
+	            });
 	        };
 
 	        /**
 	         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
-	         * @returns {number} will return the new `now` value
+	         * @returns {number} the new `now` value
 	         */
 	        clock.jump = function jump(tickValue) {
 	            const msFloat =
@@ -4340,12 +5022,17 @@ function requireFakeTimersSrc () {
 	                    : parseTime(tickValue);
 	            const ms = Math.floor(msFloat);
 
-	            for (const timer of Object.values(clock.timers)) {
+	            forEachActiveTimer(clock, (timer) => {
 	                if (clock.now + ms > timer.callAt) {
 	                    timer.callAt = clock.now + ms;
 	                }
-	            }
+	            });
+
+	            // Rebuild heap as order might have changed
+	            rebuildTimerHeap(clock);
+
 	            clock.tick(ms);
+	            return clock.now;
 	        };
 
 	        if (isPresent.performance) {
@@ -4360,6 +5047,11 @@ function requireFakeTimersSrc () {
 	        return clock;
 	    }
 
+	    /**
+	     * Starts the interval used to advance the clock automatically.
+	     * @param {Clock} clock
+	     * @param {number} delta
+	     */
 	    function createIntervalTick(clock, delta) {
 	        const intervalTick = doIntervalTick.bind(null, clock, delta);
 	        const intervalId = originalSetInterval(intervalTick, delta);
@@ -4401,6 +5093,21 @@ function requireFakeTimersSrc () {
 	        config.shouldClearNativeTimers =
 	            config.shouldClearNativeTimers || false;
 
+	        const hasToFake = Object.prototype.hasOwnProperty.call(
+	            config,
+	            "toFake",
+	        );
+	        const hasToNotFake = Object.prototype.hasOwnProperty.call(
+	            config,
+	            "toNotFake",
+	        );
+
+	        if (hasToFake && hasToNotFake) {
+	            throw new TypeError(
+	                "config.toFake and config.toNotFake cannot be used together",
+	            );
+	        }
+
 	        if (config.target) {
 	            throw new TypeError(
 	                "config.target is no longer supported. Use `withGlobal(target)` instead.",
@@ -4408,8 +5115,8 @@ function requireFakeTimersSrc () {
 	        }
 
 	        /**
-	         * @param {string} timer/object the name of the thing that is not present
-	         * @param timer
+	         * Handles a missing timer or API name during installation.
+	         * @param {string} timer - the name of the missing timer or object
 	         */
 	        function handleMissingTimer(timer) {
 	            if (config.ignoreMissingTimers) {
@@ -4431,10 +5138,24 @@ function requireFakeTimersSrc () {
 
 	        clock.abortListenerMap = new Map();
 
-	        clock.methods = config.toFake || [];
-
-	        if (clock.methods.length === 0) {
-	            clock.methods = Object.keys(timers);
+	        if (hasToFake) {
+	            clock.methods = /** @type {FakeMethod[]} */ (config.toFake || []);
+	            if (clock.methods.length === 0) {
+	                clock.methods = /** @type {FakeMethod[]} */ (
+	                    Object.keys(timers)
+	                );
+	            }
+	        } else if (hasToNotFake) {
+	            const methodsToNotFake = /** @type {string[]} */ (
+	                config.toNotFake || []
+	            );
+	            clock.methods = /** @type {FakeMethod[]} */ (
+	                Object.keys(timers).filter(
+	                    (method) => !methodsToNotFake.includes(method),
+	                )
+	            );
+	        } else {
+	            clock.methods = /** @type {FakeMethod[]} */ (Object.keys(timers));
 	        }
 
 	        if (config.shouldAdvanceTime === true) {
@@ -4471,7 +5192,7 @@ function requireFakeTimersSrc () {
 	                // (or the Worker was installed)
 	                clock.performance.timeOrigin = getEpoch(config.now);
 	            } else if ((config.toFake || []).includes("performance")) {
-	                return handleMissingTimer("performance");
+	                handleMissingTimer("performance");
 	            }
 	        }
 	        if (_global === globalObject && timersModule) {
@@ -4635,10 +5356,13 @@ function requireFakeTimersSrc () {
 	                        [Symbol.asyncIterator]: () => {
 	                            const createResolvable = () => {
 	                                let resolve, reject;
-	                                const promise = new Promise((res, rej) => {
-	                                    resolve = res;
-	                                    reject = rej;
-	                                });
+	                                const promise =
+	                                    /** @type {Promise<unknown> & { resolve: (value: unknown) => void; reject: (reason: unknown) => void }} */ (
+	                                        new Promise((res, rej) => {
+	                                            resolve = res;
+	                                            reject = rej;
+	                                        })
+	                                    );
 	                                promise.resolve = resolve;
 	                                promise.reject = reject;
 	                                return promise;
@@ -4766,22 +5490,13 @@ function requireFakeTimersSrc () {
 	    };
 	}
 
-	/**
-	 * @typedef {object} FakeTimers
-	 * @property {Timers} timers
-	 * @property {createClock} createClock
-	 * @property {Function} install
-	 * @property {withGlobal} withGlobal
-	 */
-
-	/* eslint-enable complexity */
-
 	/** @type {FakeTimers} */
 	const defaultImplementation = withGlobal(globalObject);
 
 	fakeTimersSrc.timers = defaultImplementation.timers;
 	fakeTimersSrc.createClock = defaultImplementation.createClock;
 	fakeTimersSrc.install = defaultImplementation.install;
+	/** @type {WithGlobal} */
 	fakeTimersSrc.withGlobal = withGlobal;
 	return fakeTimersSrc;
 }
@@ -4872,12 +5587,18 @@ class FakeTimers {
 			this._fakingDate = null;
 		}
 		if (this._fakingTime) this._clock.uninstall();
-		const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
-		if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
+		let toFake = this._userConfig?.toFake;
+		if (isChildProcess() && toFake?.includes("nextTick")) throw new Error("process.nextTick cannot be mocked inside child_process");
+		let toNotFake = this._userConfig?.toNotFake;
+		if (toFake === void 0 && toNotFake === void 0)
+ // Do not mock timers internally used by node by default. It can still be mocked through userConfig.
+		toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
+		if (isChildProcess() && toNotFake && !toNotFake.includes("nextTick")) toNotFake = [...toNotFake, "nextTick"];
 		this._clock = this._fakeTimers.install({
 			now: fakeDate,
 			...this._userConfig,
-			toFake: this._userConfig?.toFake || toFake,
+			...toFake && { toFake },
+			...toNotFake && { toNotFake },
 			ignoreMissingTimers: true
 		});
 		this._fakingTime = true;
@@ -5325,7 +6046,9 @@ function createExpectPoll(expect) {
 				const promise = async () => {
 					chai.util.flag(assertion, "_name", key);
 					chai.util.flag(assertion, "error", STACK_TRACE_ERROR);
+					const onStart = chai.util.flag(assertion, "_poll.onStart");
 					const onSettled = chai.util.flag(assertion, "_poll.onSettled");
+					await onStart?.({ assertion });
 					if (Object.getOwnPropertyDescriptor(assertionFunction, "__vitest_poll_takeover__")?.value) try {
 						const output = await assertionFunction.call(assertion, ...args);
 						await onSettled?.({
@@ -5341,41 +6064,53 @@ function createExpectPoll(expect) {
 						throwWithCause(err, STACK_TRACE_ERROR);
 					}
 					const { setTimeout, clearTimeout } = getSafeTimers();
-					let executionPhase = "fn";
-					let hasTimedOut = false;
-					const timerId = setTimeout(() => {
-						hasTimedOut = true;
-					}, timeout);
+					let timerId;
+					const timeoutController = new AbortController();
+					const timeoutPromise = new Promise((resolve) => {
+						timerId = setTimeout(() => {
+							timeoutController.abort();
+							resolve();
+						}, timeout);
+					});
+					let lastError;
 					try {
-						while (true) {
-							const isLastAttempt = hasTimedOut;
-							if (isLastAttempt) chai.util.flag(assertion, "_isLastPollAttempt", true);
-							try {
-								executionPhase = "fn";
-								const obj = await fn();
-								chai.util.flag(assertion, "object", obj);
-								executionPhase = "assertion";
-								const output = await assertionFunction.call(assertion, ...args);
-								await onSettled?.({
-									assertion,
-									status: "pass"
-								});
-								return output;
-							} catch (err) {
-								if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) {
-									await onSettled?.({
-										assertion,
-										status: "fail"
-									});
-									throwWithCause(err, STACK_TRACE_ERROR);
-								}
-								await delay(interval, setTimeout);
-								if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+						while (true) try {
+							const fnResult = await raceWith$1(Promise.resolve().then(() => fn({ signal: timeoutController.signal })), timeoutPromise);
+							if (!fnResult.ok) {
+								lastError ??= /* @__PURE__ */ new Error(`expect.poll() function didn't resolve in time.`);
+								break;
 							}
+							const obj = fnResult.value;
+							chai.util.flag(assertion, "object", obj);
+							const assertionResult = await raceWith$1(Promise.resolve().then(() => assertionFunction.apply(assertion, args)), timeoutPromise);
+							if (!assertionResult.ok) {
+								lastError ??= /* @__PURE__ */ new Error(`expect.poll() assertion didn't resolve in time.`);
+								break;
+							}
+							const output = assertionResult.value;
+							await onSettled?.({
+								assertion,
+								status: "pass"
+							});
+							return output;
+						} catch (err) {
+							lastError = err;
+							// no retry for toMatchScreenshot since
+							// it owns retry/stability after the first element resolution
+							if (key === "toMatchScreenshot") break;
+							if (!(await raceWith$1(delay(interval, setTimeout), timeoutPromise)).ok) break;
+							if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
 						}
 					} finally {
 						clearTimeout(timerId);
 					}
+					if (lastError) {
+						await onSettled?.({
+							assertion,
+							status: "fail"
+						});
+						throwWithCause(lastError, STACK_TRACE_ERROR);
+					}
 				};
 				let awaited = false;
 				test.onFinished ??= [];
@@ -5413,6 +6148,17 @@ function copyStackTrace(target, source) {
 	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
 }
+function raceWith$1(promise, other) {
+	const left = promise.then((value) => ({
+		ok: true,
+		value
+	}));
+	if (!other) return left;
+	return Promise.race([left, other.then((value) => ({
+		ok: false,
+		value
+	}))]);
+}
 
 var naturalCompare$1 = {exports: {}};
 
@@ -6303,11 +7049,15 @@ class SnapshotClient {
 			inlineSnapshot
 		});
 		const reference = expectedSnapshot.data !== void 0 && snapshotState.snapshotUpdateState !== "all" ? adapter.parseExpected(expectedSnapshot.data) : void 0;
+		const timeoutController = new AbortController();
 		const stableResult = await getStableSnapshot({
 			adapter,
-			poll,
+			poll: () => poll({ signal: timeoutController.signal }),
 			interval,
-			timedOut: timeout > 0 ? new Promise((r) => setTimeout(r, timeout)) : void 0,
+			timedOut: timeout > 0 ? new Promise((r) => setTimeout(() => {
+				timeoutController.abort();
+				r();
+			}, timeout)) : void 0,
 			match: reference ? (captured) => adapter.match(captured, reference).pass : void 0
 		});
 		expectedSnapshot.markAsChecked();