@rstest/core 0.9.5 → 0.9.7

package/dist/0~fake-timers.js

@@ -1,7 +1,6 @@
 import "node:module";
-import * as __rspack_external_node_util_1b29d436 from "node:util";
-import { __webpack_require__ } from "./rslib-runtime.js";
-import "./4899.js";
+import { __webpack_require__ } from "./0~rslib-runtime.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;
@@ -184,7 +183,7 @@ __webpack_require__.add({
         }
         module.exports = valueToString;
     },
-    "../../node_modules/.pnpm/@sinonjs+fake-timers@15.1.1/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 {
@@ -217,11 +216,11 @@ __webpack_require__.add({
             isPresent.performance = _global.performance && "function" == typeof _global.performance.now;
             const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
             const hasPerformanceConstructorPrototype = _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 && "function" == typeof _global.requestAnimationFrame;
             isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && "function" == typeof _global.cancelAnimationFrame;
             isPresent.requestIdleCallback = _global.requestIdleCallback && "function" == typeof _global.requestIdleCallback;
-            isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && "function" == typeof _global.cancelIdleCallback;
+            isPresent.cancelIdleCallback = _global.cancelIdleCallback && "function" == typeof _global.cancelIdleCallback;
             isPresent.setImmediate = _global.setImmediate && "function" == typeof _global.setImmediate;
             isPresent.clearImmediate = _global.clearImmediate && "function" == typeof _global.clearImmediate;
             isPresent.Intl = _global.Intl && "object" == typeof _global.Intl;
@@ -229,6 +228,7 @@ __webpack_require__.add({
             const NativeDate = _global.Date;
             const NativeIntl = isPresent.Intl ? Object.defineProperties(Object.create(null), Object.getOwnPropertyDescriptors(_global.Intl)) : void 0;
             let uniqueTimerId = idCounterStart;
+            let uniqueTimerOrder = 0;
             if (void 0 === NativeDate) throw new Error("The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)");
             isPresent.Date = true;
             class FakePerformanceEntry {
@@ -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,63 +377,175 @@ __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 (addTimerReturnsObject) {
-                    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 ("function" != typeof timer.func) throw new TypeError(`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`);
+                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 ("number" != typeof timer.delay) timer.delay = parseInt(timer.delay, 10);
                     if (!isNumberFinite(timer.delay)) timer.delay = 0;
                     timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
                     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")) {
+                    if (!timer.delay) timer.type = "IdleCallback";
+                    timer.requestIdleCallback = true;
+                }
+                ensureTimerState(clock);
+                while(hasTimer(clock, uniqueTimerId)){
+                    uniqueTimerId++;
+                    if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) uniqueTimerId = idCounterStart;
                 }
-                if (!clock.timers) clock.timers = {};
                 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.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 = {
                         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;
                         },
                         refresh: function() {
-                            timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
-                            clock.timers[timer.id] = timer;
-                            return res;
+                            timer.callAt = clock.now + (parseInt(String(timer.delay)) || (clock.duringTick ? 1 : 0));
+                            clock.timerHeap.remove(timer);
+                            timer.order = uniqueTimerOrder++;
+                            setTimer(clock, timer);
+                            clock.timerHeap.push(timer);
+                            return this;
                         },
                         [Symbol.toPrimitive]: function() {
                             return timer.id;
@@ -445,53 +556,53 @@ __webpack_require__.add({
                 return timer.id;
             }
             function compareTimers(a, b) {
+                if ("IdleCallback" === a.type && "IdleCallback" !== b.type) return 1;
+                if ("IdleCallback" !== a.type && "IdleCallback" === b.type) return -1;
                 if (a.callAt < b.callAt) return -1;
                 if (a.callAt > b.callAt) return 1;
                 if (a.immediate && !b.immediate) return -1;
                 if (!a.immediate && b.immediate) return 1;
+                if (a.order < b.order) return -1;
+                if (a.order > b.order) return 1;
                 if (a.createdAt < b.createdAt) return -1;
                 if (a.createdAt > b.createdAt) return 1;
                 if (a.id < b.id) return -1;
                 if (a.id > b.id) return 1;
+                return 0;
             }
             function firstTimerInRange(clock, from, to) {
-                const timers = clock.timers;
+                if (!clock.timerHeap) return null;
+                const timers = clock.timerHeap.timers;
+                if (1 === timers.length && timers[0].requestIdleCallback) return timers[0];
+                const first = clock.timerHeap.peek();
+                if (first && inRange(from, to, first)) return first;
                 let timer = null;
-                let id, isInRange;
-                for(id in timers)if (timers.hasOwnProperty(id)) {
-                    isInRange = inRange(from, to, timers[id]);
-                    if (isInRange && (!timer || 1 === compareTimers(timer, timers[id]))) timer = timers[id];
-                }
+                for(let i = 0; i < timers.length; i++)if (inRange(from, to, timers[i]) && (!timer || 1 === compareTimers(timer, timers[i]))) timer = timers[i];
                 return timer;
             }
             function firstTimer(clock) {
-                const timers = clock.timers;
-                let timer = null;
-                let id;
-                for(id in timers)if (timers.hasOwnProperty(id)) {
-                    if (!timer || 1 === compareTimers(timer, timers[id])) timer = timers[id];
-                }
-                return timer;
+                if (!clock.timerHeap) return null;
+                return clock.timerHeap.peek() || null;
             }
             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 || -1 === compareTimers(timer, timers[id])) timer = timers[id];
-                }
+                for(let i = 0; i < timers.length; i++)if (!timer || -1 === compareTimers(timer, timers[i])) timer = timers[i];
                 return timer;
             }
             function callTimer(clock, timer) {
-                if ("number" == typeof timer.interval) clock.timers[timer.id].callAt += timer.interval;
-                else delete clock.timers[timer.id];
-                if ("function" == typeof timer.func) timer.func.apply(null, timer.args);
-                else {
-                    const eval2 = eval;
-                    (function() {
-                        eval2(timer.func);
-                    })();
+                if ("number" == typeof 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 {
+                    deleteTimer(clock, timer.id);
+                    clock.timerHeap.remove(timer);
                 }
+                if ("function" == typeof timer.func) timer.func.apply(null, timer.args);
             }
             function getClearHandler(ttype) {
                 if ("IdleCallback" === ttype || "AnimationFrame" === ttype) return `cancel${ttype}`;
@@ -510,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);
@@ -521,10 +631,12 @@ __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 (clock.timers.hasOwnProperty(id)) {
-                    const timer = clock.timers[id];
-                    if (timer.type === ttype || "Timeout" === timer.type && "Interval" === ttype || "Interval" === timer.type && "Timeout" === ttype) delete clock.timers[id];
-                    else {
+                if (hasTimer(clock, id)) {
+                    const timer = getTimer(clock, id);
+                    if (timer.type === ttype || "Timeout" === timer.type && "Interval" === ttype || "Interval" === timer.type && "Timeout" === ttype) {
+                        deleteTimer(clock, id);
+                        clock.timerHeap.remove(timer);
+                    } else {
                         const clear = getClearHandler(ttype);
                         const schedule = getScheduleHandler(timer.type);
                         throw new Error(`Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`);
@@ -543,7 +655,7 @@ __webpack_require__.add({
                         const originalPerfDescriptor = Object.getOwnPropertyDescriptor(clock, `_${method}`);
                         if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) Object.defineProperty(_global, method, originalPerfDescriptor);
                         else if (originalPerfDescriptor.configurable) _global[method] = clock[`_${method}`];
-                    } else if (_global[method] && _global[method].hadOwnProperty) _global[method] = clock[`_${method}`];
+                    } else if (clock[method] && clock[method].hasOwnProperty) _global[method] = clock[`_${method}`];
                     else try {
                         delete _global[method];
                     } catch (ignore) {}
@@ -556,19 +668,19 @@ __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);
                     clock.abortListenerMap.delete(listener);
                 }
-                if (!clock.timers) return [];
-                return Object.keys(clock.timers).map(function mapper(key) {
-                    return clock.timers[key];
-                });
+                if (!clock.timerHeap) return [];
+                return clock.timerHeap.timers.slice();
             }
             function hijackMethod(target, method, clock) {
-                clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
+                clock[method].hasOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
                 clock[`_${method}`] = target[method];
                 if ("Date" === method) target[method] = clock[method];
                 else if ("Intl" === method) target[method] = clock[method];
@@ -623,6 +735,7 @@ __webpack_require__.add({
                     now: start,
                     Date: createDate(),
                     loopLimit: loopLimit,
+                    isNearInfiniteLimit: false,
                     tickMode: {
                         mode: "manual",
                         counter: 0,
@@ -687,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);
@@ -716,14 +829,23 @@ __webpack_require__.add({
                         });
                     });
                 }
-                clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
+                function getTimeToNextIdlePeriod() {
                     let timeToNextIdlePeriod = 0;
                     if (clock.countTimers() > 0) timeToNextIdlePeriod = 50;
+                    return timeToNextIdlePeriod;
+                }
+                clock.requestIdleCallback = function requestIdleCallback(func, { timeout } = {}) {
+                    const idleDeadline = {
+                        didTimeout: true,
+                        timeRemaining: getTimeToNextIdlePeriod
+                    };
                     const result = addTimer(clock, {
                         func: func,
-                        args: Array.prototype.slice.call(arguments, 2),
-                        delay: void 0 === timeout ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod),
-                        idleCallback: true
+                        args: [
+                            idleDeadline
+                        ],
+                        delay: timeout,
+                        requestIdleCallback: true
                     });
                     return Number(result);
                 };
@@ -755,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) {
@@ -797,7 +919,7 @@ __webpack_require__.add({
                     };
                 }
                 clock.countTimers = function countTimers() {
-                    return Object.keys(clock.timers || {}).length + (clock.jobs || []).length;
+                    return (clock.timerHeap ? clock.timerHeap.timers.length : 0) + (clock.jobs || []).length;
                 };
                 clock.requestAnimationFrame = function requestAnimationFrame(func) {
                     const result = addTimer(clock, {
@@ -818,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);
@@ -829,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);
@@ -929,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 = Object.keys(clock.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);
@@ -976,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.timers) {
-                                            resetIsNearInfiniteLimit();
-                                            resolve(clock.now);
-                                            return;
-                                        }
-                                        numTimers = Object.keys(clock.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) {
@@ -1020,47 +1107,107 @@ __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;
                 };
                 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 (clock.timers.hasOwnProperty(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);
-                    for (const timer of Object.values(clock.timers))if (clock.now + ms > timer.callAt) timer.callAt = clock.now + ms;
+                    forEachActiveTimer(clock, (timer)=>{
+                        if (clock.now + ms > timer.callAt) timer.callAt = clock.now + ms;
+                    });
+                    rebuildTimerHeap(clock);
                     clock.tick(ms);
+                    return clock.now;
                 };
                 if (isPresent.performance) {
                     clock.performance = Object.create(null);
@@ -1081,6 +1228,9 @@ __webpack_require__.add({
                 config.shouldAdvanceTime = config.shouldAdvanceTime || false;
                 config.advanceTimeDelta = config.advanceTimeDelta || 20;
                 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.");
                 function handleMissingTimer(timer) {
                     if (config.ignoreMissingTimers) return;
@@ -1093,8 +1243,13 @@ __webpack_require__.add({
                     return uninstall(clock);
                 };
                 clock.abortListenerMap = new Map();
-                clock.methods = config.toFake || [];
-                if (0 === clock.methods.length) clock.methods = Object.keys(timers);
+                if (hasToFake) {
+                    clock.methods = config.toFake || [];
+                    if (0 === clock.methods.length) clock.methods = Object.keys(timers);
+                } else if (hasToNotFake) {
+                    const methodsToNotFake = config.toNotFake || [];
+                    clock.methods = Object.keys(timers).filter((method)=>!methodsToNotFake.includes(method));
+                } else clock.methods = Object.keys(timers);
                 if (true === config.shouldAdvanceTime) clock.setTickMode({
                     mode: "interval",
                     delta: config.advanceTimeDelta
@@ -1111,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 = [];
@@ -1362,14 +1517,11 @@ __webpack_require__.add({
             }
             return typeDetect;
         });
-    },
-    util (module) {
-        module.exports = __rspack_external_node_util_1b29d436;
     }
 });
 const RealDate = Date;
 const loadFakeTimersModule = ()=>{
-    const loaded = __webpack_require__("../../node_modules/.pnpm/@sinonjs+fake-timers@15.1.1/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
     };
@@ -1436,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({
@@ -1449,6 +1601,7 @@ class FakeTimers {
             ignoreMissingTimers: true,
             ...fakeTimersConfig
         });
+        this._clock.reset();
         this._fakingTime = true;
     }
     reset() {