@rstest/core 0.9.5 → 0.9.7

package/dist/browser-runtime/2~fake-timers.js

@@ -1,4 +1,4 @@
-import { __webpack_require__ } from "./rslib-runtime.js";
+import { __webpack_require__ } from "./723.js";
 import "./723.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__) {
@@ -183,18 +183,14 @@ __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 {
-            timersModule = __webpack_require__("../../node_modules/.pnpm/timers-browserify@2.0.12/node_modules/timers-browserify/main.js");
+            timersModule = __webpack_require__("?4e05");
         } catch (e) {}
         try {
-            timersPromisesModule = __webpack_require__(Object(function __rspack_missing_module() {
-                var e = new Error("Cannot find module 'timers/promises'");
-                e.code = 'MODULE_NOT_FOUND';
-                throw e;
-            }()));
+            timersPromisesModule = __webpack_require__("?7123");
         } catch (e) {}
         function withGlobal(_global) {
             const maxTimeout = Math.pow(2, 31) - 1;
@@ -220,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;
@@ -232,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 {
@@ -251,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;
@@ -281,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");
             }
@@ -381,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;
@@ -448,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}`;
@@ -513,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);
@@ -524,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}()`);
@@ -546,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) {}
@@ -559,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];
@@ -626,6 +735,7 @@ __webpack_require__.add({
                     now: start,
                     Date: createDate(),
                     loopLimit: loopLimit,
+                    isNearInfiniteLimit: false,
                     tickMode: {
                         mode: "manual",
                         counter: 0,
@@ -690,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);
@@ -719,21 +829,30 @@ __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);
                 };
                 clock.cancelIdleCallback = function cancelIdleCallback(timerId) {
                     return clearTimer(clock, timerId, "IdleCallback");
                 };
-                clock.setTimeout = function setTimeout1(func, timeout) {
+                clock.setTimeout = function setTimeout(func, timeout) {
                     return addTimer(clock, {
                         func: func,
                         args: Array.prototype.slice.call(arguments, 2),
@@ -751,20 +870,20 @@ __webpack_require__.add({
                         });
                     });
                 };
-                clock.clearTimeout = function clearTimeout1(timerId) {
+                clock.clearTimeout = function clearTimeout(timerId) {
                     return clearTimer(clock, timerId, "Timeout");
                 };
                 clock.nextTick = function nextTick(func) {
                     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) {
                     return clock.nextTick(func);
                 };
-                clock.setInterval = function setInterval1(func, timeout) {
+                clock.setInterval = function setInterval(func, timeout) {
                     timeout = parseInt(timeout, 10);
                     return addTimer(clock, {
                         func: func,
@@ -773,7 +892,7 @@ __webpack_require__.add({
                         interval: timeout
                     });
                 };
-                clock.clearInterval = function clearInterval1(timerId) {
+                clock.clearInterval = function clearInterval(timerId) {
                     return clearTimer(clock, timerId, "Interval");
                 };
                 if (isPresent.setImmediate) {
@@ -800,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, {
@@ -821,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);
@@ -832,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;
                     }
-                    nextPromiseTick = isAsync && function() {
+                    else {
+                        clock.now = state.tickTo;
+                        nanos = state.nanosTotal;
+                    }
+                    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);
@@ -932,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);
@@ -979,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) {
@@ -1023,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);
@@ -1084,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;
@@ -1096,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
@@ -1114,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 = [];
@@ -1301,175 +1453,6 @@ __webpack_require__.add({
         defaultImplementation.install;
         exports.withGlobal = withGlobal;
     },
-    "../../node_modules/.pnpm/setimmediate@1.0.5/node_modules/setimmediate/setImmediate.js" (__unused_rspack_module, __unused_rspack_exports, __webpack_require__) {
-        var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
-        (function(global, undefined) {
-            "use strict";
-            if (global.setImmediate) return;
-            var nextHandle = 1;
-            var tasksByHandle = {};
-            var currentlyRunningATask = false;
-            var doc = global.document;
-            var registerImmediate;
-            function setImmediate(callback) {
-                if ("function" != typeof callback) callback = new Function("" + callback);
-                var args = new Array(arguments.length - 1);
-                for(var i = 0; i < args.length; i++)args[i] = arguments[i + 1];
-                var task = {
-                    callback: callback,
-                    args: args
-                };
-                tasksByHandle[nextHandle] = task;
-                registerImmediate(nextHandle);
-                return nextHandle++;
-            }
-            function clearImmediate(handle) {
-                delete tasksByHandle[handle];
-            }
-            function run(task) {
-                var callback = task.callback;
-                var args = task.args;
-                switch(args.length){
-                    case 0:
-                        callback();
-                        break;
-                    case 1:
-                        callback(args[0]);
-                        break;
-                    case 2:
-                        callback(args[0], args[1]);
-                        break;
-                    case 3:
-                        callback(args[0], args[1], args[2]);
-                        break;
-                    default:
-                        callback.apply(undefined, args);
-                        break;
-                }
-            }
-            function runIfPresent(handle) {
-                if (currentlyRunningATask) setTimeout(runIfPresent, 0, handle);
-                else {
-                    var task = tasksByHandle[handle];
-                    if (task) {
-                        currentlyRunningATask = true;
-                        try {
-                            run(task);
-                        } finally{
-                            clearImmediate(handle);
-                            currentlyRunningATask = false;
-                        }
-                    }
-                }
-            }
-            function installNextTickImplementation() {
-                registerImmediate = function(handle) {
-                    process.nextTick(function() {
-                        runIfPresent(handle);
-                    });
-                };
-            }
-            function canUsePostMessage() {
-                if (global.postMessage && !global.importScripts) {
-                    var postMessageIsAsynchronous = true;
-                    var oldOnMessage = global.onmessage;
-                    global.onmessage = function() {
-                        postMessageIsAsynchronous = false;
-                    };
-                    global.postMessage("", "*");
-                    global.onmessage = oldOnMessage;
-                    return postMessageIsAsynchronous;
-                }
-            }
-            function installPostMessageImplementation() {
-                var messagePrefix = "setImmediate$" + Math.random() + "$";
-                var onGlobalMessage = function(event) {
-                    if (event.source === global && "string" == typeof event.data && 0 === event.data.indexOf(messagePrefix)) runIfPresent(+event.data.slice(messagePrefix.length));
-                };
-                if (global.addEventListener) global.addEventListener("message", onGlobalMessage, false);
-                else global.attachEvent("onmessage", onGlobalMessage);
-                registerImmediate = function(handle) {
-                    global.postMessage(messagePrefix + handle, "*");
-                };
-            }
-            function installMessageChannelImplementation() {
-                var channel = new MessageChannel();
-                channel.port1.onmessage = function(event) {
-                    var handle = event.data;
-                    runIfPresent(handle);
-                };
-                registerImmediate = function(handle) {
-                    channel.port2.postMessage(handle);
-                };
-            }
-            function installReadyStateChangeImplementation() {
-                var html = doc.documentElement;
-                registerImmediate = function(handle) {
-                    var script = doc.createElement("script");
-                    script.onreadystatechange = function() {
-                        runIfPresent(handle);
-                        script.onreadystatechange = null;
-                        html.removeChild(script);
-                        script = null;
-                    };
-                    html.appendChild(script);
-                };
-            }
-            function installSetTimeoutImplementation() {
-                registerImmediate = function(handle) {
-                    setTimeout(runIfPresent, 0, handle);
-                };
-            }
-            var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
-            attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
-            if ("[object process]" === ({}).toString.call(global.process)) installNextTickImplementation();
-            else if (canUsePostMessage()) installPostMessageImplementation();
-            else if (global.MessageChannel) installMessageChannelImplementation();
-            else if (doc && "onreadystatechange" in doc.createElement("script")) installReadyStateChangeImplementation();
-            else installSetTimeoutImplementation();
-            attachTo.setImmediate = setImmediate;
-            attachTo.clearImmediate = clearImmediate;
-        })("u" < typeof self ? void 0 === __webpack_require__.g ? this : __webpack_require__.g : self);
-    },
-    "../../node_modules/.pnpm/timers-browserify@2.0.12/node_modules/timers-browserify/main.js" (__unused_rspack_module, exports, __webpack_require__) {
-        var scope = void 0 !== __webpack_require__.g && __webpack_require__.g || "u" > typeof self && self || window;
-        var apply = Function.prototype.apply;
-        exports.setTimeout = function() {
-            return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
-        };
-        exports.setInterval = function() {
-            return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
-        };
-        exports.clearTimeout = exports.clearInterval = function(timeout) {
-            if (timeout) timeout.close();
-        };
-        function Timeout(id, clearFn) {
-            this._id = id;
-            this._clearFn = clearFn;
-        }
-        Timeout.prototype.unref = Timeout.prototype.ref = function() {};
-        Timeout.prototype.close = function() {
-            this._clearFn.call(scope, this._id);
-        };
-        exports.enroll = function(item, msecs) {
-            clearTimeout(item._idleTimeoutId);
-            item._idleTimeout = msecs;
-        };
-        exports.unenroll = function(item) {
-            clearTimeout(item._idleTimeoutId);
-            item._idleTimeout = -1;
-        };
-        exports._unrefActive = exports.active = function(item) {
-            clearTimeout(item._idleTimeoutId);
-            var msecs = item._idleTimeout;
-            if (msecs >= 0) item._idleTimeoutId = setTimeout(function onTimeout() {
-                if (item._onTimeout) item._onTimeout();
-            }, msecs);
-        };
-        __webpack_require__("../../node_modules/.pnpm/setimmediate@1.0.5/node_modules/setimmediate/setImmediate.js");
-        exports.setImmediate = "u" > typeof self && self.setImmediate || void 0 !== __webpack_require__.g && __webpack_require__.g.setImmediate || this && this.setImmediate;
-        exports.clearImmediate = "u" > typeof self && self.clearImmediate || void 0 !== __webpack_require__.g && __webpack_require__.g.clearImmediate || this && this.clearImmediate;
-    },
     "../../node_modules/.pnpm/type-detect@4.0.8/node_modules/type-detect/type-detect.js" (module, __unused_rspack_exports, __webpack_require__) {
         (function(global, factory) {
             module.exports = factory();
@@ -1534,12 +1517,14 @@ __webpack_require__.add({
             }
             return typeDetect;
         });
-    }
+    },
+    "?4e05" () {},
+    "?7123" () {}
 });
 var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
 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
     };
@@ -1606,7 +1591,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 = void 0 !== 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({
@@ -1619,6 +1604,7 @@ class FakeTimers {
             ignoreMissingTimers: true,
             ...fakeTimersConfig
         });
+        this._clock.reset();
         this._fakingTime = true;
     }
     reset() {