@rstest/core 0.9.6 → 0.9.7

package/dist/0~fake-timers.js

@@ -1,6 +1,6 @@
 import "node:module";
 import { __webpack_require__ } from "./0~rslib-runtime.js";
-import "./6887.js";
+import "./7290.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/called-in-order.js" (module, __unused_rspack_exports, __webpack_require__) {
         var every = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/prototypes/array.js").every;
@@ -183,7 +183,7 @@ __webpack_require__.add({
         }
         module.exports = valueToString;
     },
-    "../../node_modules/.pnpm/@sinonjs+fake-timers@15.2.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js" (__unused_rspack_module, exports, __webpack_require__) {
+    "../../node_modules/.pnpm/@sinonjs+fake-timers@15.3.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js" (__unused_rspack_module, exports, __webpack_require__) {
         const globalObject = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/index.js").global;
         let timersModule, timersPromisesModule;
         try {
@@ -248,12 +248,11 @@ __webpack_require__.add({
                 if (Number.isFinite) return Number.isFinite(num);
                 return isFinite(num);
             }
-            let isNearInfiniteLimit = false;
             function checkIsNearInfiniteLimit(clock, i) {
-                if (clock.loopLimit && i === clock.loopLimit - 1) isNearInfiniteLimit = true;
+                if (clock.loopLimit && i === clock.loopLimit - 1) clock.isNearInfiniteLimit = true;
             }
-            function resetIsNearInfiniteLimit() {
-                isNearInfiniteLimit = false;
+            function resetIsNearInfiniteLimit(clock) {
+                if (clock) clock.isNearInfiniteLimit = false;
             }
             function parseTime(str) {
                 if (!str) return 0;
@@ -278,7 +277,7 @@ __webpack_require__.add({
             }
             function getEpoch(epoch) {
                 if (!epoch) return 0;
-                if ("function" == typeof epoch.getTime) return epoch.getTime();
+                if (epoch instanceof Date) return epoch.getTime();
                 if ("number" == typeof epoch) return epoch;
                 throw new TypeError("now should be milliseconds since UNIX epoch");
             }
@@ -378,19 +377,123 @@ __webpack_require__.add({
             }
             function runJobs(clock) {
                 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);
                     checkIsNearInfiniteLimit(clock, i);
                     if (clock.loopLimit && i > clock.loopLimit) throw getInfiniteLoopError(clock, job);
                 }
-                resetIsNearInfiniteLimit();
+                if (!wasNearLimit) resetIsNearInfiniteLimit(clock);
                 clock.jobs = [];
             }
+            class TimerHeap {
+                constructor(){
+                    this.timers = [];
+                }
+                peek() {
+                    return this.timers[0];
+                }
+                push(timer) {
+                    this.timers.push(timer);
+                    this.bubbleUp(this.timers.length - 1);
+                }
+                pop() {
+                    if (0 === this.timers.length) return;
+                    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(timer) {
+                    const index = timer.heapIndex;
+                    if (void 0 === index || 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;
+                }
+                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;
+                }
+                bubbleDown(index) {
+                    const timer = this.timers[index];
+                    let currentIndex = index;
+                    const halfLength = Math.floor(this.timers.length / 2);
+                    while(currentIndex < halfLength){
+                        const leftIndex = 2 * currentIndex + 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;
+                }
+            }
+            function ensureTimerState(clock) {
+                if (!clock.timers) {
+                    clock.timers = new Map();
+                    clock.timerHeap = new TimerHeap();
+                }
+            }
+            function hasTimer(clock, id) {
+                return clock.timers ? clock.timers.has(id) : false;
+            }
+            function getTimer(clock, id) {
+                return clock.timers ? clock.timers.get(id) : void 0;
+            }
+            function setTimer(clock, timer) {
+                ensureTimerState(clock);
+                clock.timers.set(timer.id, timer);
+            }
+            function deleteTimer(clock, id) {
+                return clock.timers ? clock.timers.delete(id) : false;
+            }
+            function forEachActiveTimer(clock, callback) {
+                if (!clock.timers) return;
+                for (const timer of clock.timers.values())callback(timer);
+            }
+            function rebuildTimerHeap(clock) {
+                clock.timerHeap = new TimerHeap();
+                forEachActiveTimer(clock, (timer)=>{
+                    clock.timerHeap.push(timer);
+                });
+            }
             function addTimer(clock, timer) {
                 if (void 0 === timer.func) throw new Error("Callback must be provided to timer calls");
                 if ("function" != typeof timer.func) throw new TypeError(`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`);
-                if (isNearInfiniteLimit) timer.error = new Error();
+                if (clock.isNearInfiniteLimit) timer.error = new Error();
                 timer.type = timer.immediate ? "Immediate" : "Timeout";
                 if (Object.prototype.hasOwnProperty.call(timer, "delay")) {
                     if ("number" != typeof timer.delay) timer.delay = parseInt(timer.delay, 10);
@@ -410,11 +513,8 @@ __webpack_require__.add({
                     if (!timer.delay) timer.type = "IdleCallback";
                     timer.requestIdleCallback = true;
                 }
-                if (!clock.timers) {
-                    clock.timers = {};
-                    clock.timerHeap = new TimerHeap();
-                }
-                while(clock.timers && clock.timers[uniqueTimerId]){
+                ensureTimerState(clock);
+                while(hasTimer(clock, uniqueTimerId)){
                     uniqueTimerId++;
                     if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) uniqueTimerId = idCounterStart;
                 }
@@ -422,8 +522,8 @@ __webpack_require__.add({
                 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.timers[timer.id] = timer;
+                timer.callAt = clock.now + (parseInt(String(timer.delay)) || (clock.duringTick ? 1 : 0));
+                setTimer(clock, timer);
                 clock.timerHeap.push(timer);
                 if (addTimerReturnsObject) {
                     const res = {
@@ -440,10 +540,10 @@ __webpack_require__.add({
                             return this.refed;
                         },
                         refresh: function() {
-                            timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+                            timer.callAt = clock.now + (parseInt(String(timer.delay)) || (clock.duringTick ? 1 : 0));
                             clock.timerHeap.remove(timer);
                             timer.order = uniqueTimerOrder++;
-                            clock.timers[timer.id] = timer;
+                            setTimer(clock, timer);
                             clock.timerHeap.push(timer);
                             return this;
                         },
@@ -470,78 +570,6 @@ __webpack_require__.add({
                 if (a.id > b.id) return 1;
                 return 0;
             }
-            function TimerHeap() {
-                this.timers = [];
-            }
-            TimerHeap.prototype.peek = function() {
-                return this.timers[0];
-            };
-            TimerHeap.prototype.push = function(timer) {
-                this.timers.push(timer);
-                this.bubbleUp(this.timers.length - 1);
-            };
-            TimerHeap.prototype.pop = function() {
-                if (0 === this.timers.length) return;
-                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;
-            };
-            TimerHeap.prototype.remove = function(timer) {
-                const index = timer.heapIndex;
-                if (void 0 === index || 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;
-            };
-            TimerHeap.prototype.bubbleUp = function(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;
-            };
-            TimerHeap.prototype.bubbleDown = function(index) {
-                const timer = this.timers[index];
-                let currentIndex = index;
-                const halfLength = Math.floor(this.timers.length / 2);
-                while(currentIndex < halfLength){
-                    const leftIndex = 2 * currentIndex + 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;
-            };
             function firstTimerInRange(clock, from, to) {
                 if (!clock.timerHeap) return null;
                 const timers = clock.timerHeap.timers;
@@ -568,9 +596,10 @@ __webpack_require__.add({
                     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 ("function" == typeof timer.func) timer.func.apply(null, timer.args);
@@ -592,7 +621,6 @@ __webpack_require__.add({
             const warnOnce = createWarnOnce();
             function clearTimer(clock, timerId, ttype) {
                 if (!timerId) return;
-                if (!clock.timers) clock.timers = {};
                 const id = Number(timerId);
                 if (Number.isNaN(id) || id < idCounterStart) {
                     const handlerName = getClearHandler(ttype);
@@ -603,10 +631,10 @@ __webpack_require__.add({
                     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\`.\n${stackTrace}`);
                 }
-                if (Object.prototype.hasOwnProperty.call(clock.timers, id)) {
-                    const timer = clock.timers[id];
+                if (hasTimer(clock, id)) {
+                    const timer = getTimer(clock, id);
                     if (timer.type === ttype || "Timeout" === timer.type && "Interval" === ttype || "Interval" === timer.type && "Timeout" === ttype) {
-                        delete clock.timers[id];
+                        deleteTimer(clock, id);
                         clock.timerHeap.remove(timer);
                     } else {
                         const clear = getClearHandler(ttype);
@@ -640,7 +668,9 @@ __webpack_require__.add({
                         timersPromisesModule[entry.methodName] = entry.original;
                     }
                 }
-                clock.setTickMode("manual");
+                clock.setTickMode({
+                    mode: "manual"
+                });
                 clock.methods = [];
                 for (const [listener, signal] of clock.abortListenerMap.entries()){
                     signal.removeEventListener("abort", listener);
@@ -705,6 +735,7 @@ __webpack_require__.add({
                     now: start,
                     Date: createDate(),
                     loopLimit: loopLimit,
+                    isNearInfiniteLimit: false,
                     tickMode: {
                         mode: "manual",
                         counter: 0,
@@ -769,7 +800,7 @@ __webpack_require__.add({
                         const channel = new MessageChannel();
                         await new Promise((resolve)=>{
                             channel.port1.onmessage = ()=>{
-                                resolve();
+                                resolve(void 0);
                                 channel.port1.close();
                             };
                             channel.port2.postMessage(void 0);
@@ -846,7 +877,7 @@ __webpack_require__.add({
                     return enqueueJob(clock, {
                         func: func,
                         args: Array.prototype.slice.call(arguments, 1),
-                        error: isNearInfiniteLimit ? new Error() : null
+                        error: clock.isNearInfiniteLimit ? new Error() : null
                     });
                 };
                 clock.queueMicrotask = function queueMicrotask(func) {
@@ -909,7 +940,7 @@ __webpack_require__.add({
                 clock.runMicrotasks = function runMicrotasks() {
                     runJobs(clock);
                 };
-                function doTick(tickValue, isAsync, resolve, reject) {
+                function createTickState(tickValue) {
                     const msFloat = "number" == typeof tickValue ? tickValue : parseTime(tickValue);
                     const ms = Math.floor(msFloat);
                     const remainder = nanoRemainder(msFloat);
@@ -920,92 +951,108 @@ __webpack_require__.add({
                         tickTo += 1;
                         nanosTotal -= 1e6;
                     }
-                    nanos = nanosTotal;
-                    let tickFrom = clock.now;
-                    let previous = clock.now;
-                    let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall;
-                    clock.duringTick = true;
-                    oldNow = clock.now;
-                    runJobs(clock);
+                    return {
+                        msFloat: msFloat,
+                        ms: ms,
+                        nanosTotal: nanosTotal,
+                        tickFrom: clock.now,
+                        tickTo: tickTo,
+                        previous: clock.now,
+                        timer: null,
+                        firstException: null,
+                        oldNow: null
+                    };
+                }
+                function applyClockChangeCompensation(state, oldNow, options) {
                     if (oldNow !== clock.now) {
-                        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;
                     }
-                    function doTickInner() {
-                        timer = firstTimerInRange(clock, tickFrom, tickTo);
-                        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) return void originalSetTimeout(nextPromiseTick);
-                                compensationCheck();
+                }
+                function runInitialJobs(state) {
+                    state.oldNow = clock.now;
+                    runJobs(clock);
+                    applyClockChangeCompensation(state, state.oldNow);
+                }
+                function runPostLoopJobs(state) {
+                    state.oldNow = clock.now;
+                    runJobs(clock);
+                    applyClockChangeCompensation(state, state.oldNow);
+                }
+                function selectNextTimerInRange(state) {
+                    state.timer = firstTimerInRange(clock, state.previous, state.tickTo);
+                    state.previous = state.tickFrom;
+                }
+                function runTimersInRange(state, isAsync, nextPromiseTick, compensationCheck) {
+                    state.timer = firstTimerInRange(clock, state.tickFrom, state.tickTo);
+                    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 {
+                                runJobs(clock);
+                                callTimer(clock, state.timer);
+                            } catch (e) {
+                                state.firstException = state.firstException || e;
                             }
-                            postTimerCall();
-                        }
-                        oldNow = clock.now;
-                        runJobs(clock);
-                        if (oldNow !== clock.now) {
-                            tickFrom += clock.now - oldNow;
-                            tickTo += clock.now - oldNow;
-                        }
-                        clock.duringTick = false;
-                        timer = firstTimerInRange(clock, tickFrom, tickTo);
-                        if (timer) try {
-                            clock.tick(tickTo - clock.now);
-                        } catch (e) {
-                            firstException = firstException || e;
-                        }
-                        else {
-                            clock.now = tickTo;
-                            nanos = nanosTotal;
+                            if (isAsync) {
+                                originalSetTimeout(nextPromiseTick);
+                                return true;
+                            }
+                            compensationCheck();
                         }
-                        if (firstException) throw firstException;
-                        if (!isAsync) return clock.now;
-                        resolve(clock.now);
+                        selectNextTimerInRange(state);
+                    }
+                    return false;
+                }
+                function finalizeTick(state, isAsync, resolve) {
+                    state.timer = firstTimerInRange(clock, state.tickFrom, state.tickTo);
+                    if (state.timer) try {
+                        clock.tick(state.tickTo - clock.now);
+                    } catch (e) {
+                        state.firstException = state.firstException || e;
+                    }
+                    else {
+                        clock.now = state.tickTo;
+                        nanos = state.nanosTotal;
                     }
-                    nextPromiseTick = isAsync && function() {
+                    if (state.firstException) throw state.firstException;
+                    if (!isAsync) return clock.now;
+                    resolve(clock.now);
+                }
+                function doTick(tickValue, isAsync, resolve, reject) {
+                    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() {
-                        if (oldNow !== clock.now) {
-                            tickFrom += clock.now - oldNow;
-                            tickTo += clock.now - oldNow;
-                            previous += clock.now - oldNow;
-                        }
-                    };
-                    postTimerCall = function() {
-                        timer = firstTimerInRange(clock, previous, tickTo);
-                        previous = tickFrom;
-                    };
+                    function doTickInner() {
+                        if (runTimersInRange(state, isAsync, nextPromiseTick, compensationCheck)) return;
+                        runPostLoopJobs(state);
+                        clock.duringTick = false;
+                        return finalizeTick(state, isAsync, resolve);
+                    }
                     return doTickInner();
                 }
                 clock.tick = function tick(tickValue) {
                     return doTick(tickValue, false);
                 };
-                if (void 0 !== _global.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);
@@ -1020,46 +1067,31 @@ __webpack_require__.add({
                         clock.duringTick = false;
                     }
                 };
-                if (void 0 !== _global.Promise) clock.nextAsync = function nextAsync() {
+                function runAsyncWithNativeTimeout(callback) {
                     return pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
                         originalSetTimeout(function() {
                             try {
-                                const timer = firstTimer(clock);
-                                if (!timer) return void resolve(clock.now);
-                                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);
-                                });
+                                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 = clock.timerHeap.timers.length;
+                        const numTimers = clock.timerHeap.timers.length;
                         if (0 === numTimers) {
-                            resetIsNearInfiniteLimit();
+                            resetIsNearInfiniteLimit(clock);
                             return clock.now;
                         }
-                        clock.next();
                         checkIsNearInfiniteLimit(clock, i);
+                        clock.next();
                     }
                     const excessJob = firstTimer(clock);
                     throw getInfiniteLoopError(clock, excessJob);
@@ -1067,42 +1099,6 @@ __webpack_require__.add({
                 clock.runToFrame = function runToFrame() {
                     return clock.tick(getTimeToNextFrame());
                 };
-                if (void 0 !== _global.Promise) 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.timerHeap) {
-                                            resetIsNearInfiniteLimit();
-                                            resolve(clock.now);
-                                            return;
-                                        }
-                                        numTimers = clock.timerHeap.timers.length;
-                                        if (0 === numTimers) {
-                                            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) {
@@ -1111,25 +1107,82 @@ __webpack_require__.add({
                     }
                     return clock.tick(timer.callAt - clock.now);
                 };
-                if (void 0 !== _global.Promise) clock.runToLastAsync = function runToLastAsync() {
-                    return pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
-                        originalSetTimeout(function() {
+                if (void 0 !== _global.Promise) {
+                    clock.tickAsync = function tickAsync(tickValue) {
+                        return runAsyncWithNativeTimeout(function(resolve, reject) {
+                            doTick(tickValue, true, resolve, reject);
+                        });
+                    };
+                    clock.nextAsync = function nextAsync() {
+                        return runAsyncWithNativeTimeout(function(resolve, reject) {
+                            const timer = firstTimer(clock);
+                            if (!timer) return void resolve(clock.now);
+                            let err;
+                            clock.duringTick = true;
+                            clock.now = timer.callAt;
                             try {
-                                const timer = lastTimer(clock);
-                                if (!timer) {
-                                    runJobs(clock);
-                                    resolve(clock.now);
+                                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;
+                        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 (0 === numTimers) {
+                                        resetIsNearInfiniteLimit(clock);
+                                        resolve(clock.now);
+                                        return;
+                                    }
+                                    checkIsNearInfiniteLimit(clock, i);
+                                    clock.next();
+                                    i++;
+                                    originalSetTimeout(function() {
+                                        doRun(resolve, reject);
+                                    });
+                                    return;
                                 }
-                                resolve(clock.tickAsync(timer.callAt - clock.now));
+                                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;
@@ -1137,25 +1190,22 @@ __webpack_require__.add({
                 clock.setSystemTime = function setSystemTime(systemTime) {
                     const newNow = getEpoch(systemTime);
                     const difference = newNow - clock.now;
-                    let id, timer;
                     adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
                     adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
                     clock.now = newNow;
                     nanos = 0;
-                    for(id in clock.timers)if (Object.prototype.hasOwnProperty.call(clock.timers, id)) {
-                        timer = clock.timers[id];
+                    forEachActiveTimer(clock, (timer)=>{
                         timer.createdAt += difference;
                         timer.callAt += difference;
-                    }
+                    });
                 };
                 clock.jump = function jump(tickValue) {
                     const msFloat = "number" == typeof tickValue ? tickValue : parseTime(tickValue);
                     const ms = Math.floor(msFloat);
-                    if (clock.timers) {
-                        for (const timer of Object.values(clock.timers))if (clock.now + ms > timer.callAt) timer.callAt = clock.now + ms;
-                        clock.timerHeap = new TimerHeap();
-                        for (const timer of Object.values(clock.timers))clock.timerHeap.push(timer);
-                    }
+                    forEachActiveTimer(clock, (timer)=>{
+                        if (clock.now + ms > timer.callAt) timer.callAt = clock.now + ms;
+                    });
+                    rebuildTimerHeap(clock);
                     clock.tick(ms);
                     return clock.now;
                 };
@@ -1216,7 +1266,7 @@ __webpack_require__.add({
                         clock.performance.mark = (name)=>new FakePerformanceEntry(name, "mark", 0, 0);
                         clock.performance.measure = (name)=>new FakePerformanceEntry(name, "measure", 0, 100);
                         clock.performance.timeOrigin = getEpoch(config.now);
-                    } else if ((config.toFake || []).includes("performance")) return handleMissingTimer("performance");
+                    } else if ((config.toFake || []).includes("performance")) handleMissingTimer("performance");
                 }
                 if (_global === globalObject && timersModule) clock.timersModuleMethods = [];
                 if (_global === globalObject && timersPromisesModule) clock.timersPromisesModuleMethods = [];
@@ -1471,7 +1521,7 @@ __webpack_require__.add({
 });
 const RealDate = Date;
 const loadFakeTimersModule = ()=>{
-    const loaded = __webpack_require__("../../node_modules/.pnpm/@sinonjs+fake-timers@15.2.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js");
+    const loaded = __webpack_require__("../../node_modules/.pnpm/@sinonjs+fake-timers@15.3.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js");
     return {
         withGlobal: loaded.withGlobal
     };
@@ -1538,7 +1588,7 @@ class FakeTimers {
     }
     useFakeTimers(fakeTimersConfig = {}) {
         if (this._fakingTime) this._clock.uninstall();
-        const toFake = Object.keys(this._fakeTimers.timers).filter((timer)=>'nextTick' !== timer && 'queueMicrotask' !== timer);
+        const toFake = Object.keys(this._fakeTimers.timers).filter((timer)=>'Intl' !== timer && 'nextTick' !== timer && 'queueMicrotask' !== timer);
         const isChildProcess = "u" > typeof process && !!process.send;
         if (this._config?.toFake?.includes('nextTick') && isChildProcess) throw new Error('process.nextTick cannot be mocked inside child_process');
         this._clock = this._fakeTimers.install({