@noma.to/qwik-testing-library 1.3.0 → 1.3.1

package/lib/node_modules/.pnpm/{vitest@2.1.8_@types_node@22.10.3_@vitest_ui@2.1.8_jsdom@26.0.0/node_modules/vitest/dist/chunks/vi.DgezovHB.qwik.cjs → vitest@3.0.5_@types_node@22.13.1_@vitest_ui@3.0.5_jiti@2.4.2_jsdom@26.0.0/node_modules/vitest/dist/chunks/vi.CjhMlMwf.qwik.cjs}

@@ -3,21 +3,21 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("../../../../../@vitest_expect@2.1.8/node_modules/@vitest/expect/dist/index.qwik.cjs");
-require("../../../../../@vitest_runner@2.1.8/node_modules/@vitest/runner/dist/index.qwik.cjs");
-const chunkTasks = require("../../../../../@vitest_runner@2.1.8/node_modules/@vitest/runner/dist/chunk-tasks.qwik.cjs");
-const index$3 = require("../../../../../@vitest_utils@2.1.8/node_modules/@vitest/utils/dist/index.qwik.cjs");
+const index$2 = require("../../../../../@vitest_expect@3.0.5/node_modules/@vitest/expect/dist/index.qwik.cjs");
+require("../../../../../@vitest_runner@3.0.5/node_modules/@vitest/runner/dist/index.qwik.cjs");
+const chunkTasks = require("../../../../../@vitest_runner@3.0.5/node_modules/@vitest/runner/dist/chunk-tasks.qwik.cjs");
+const index$1 = require("../../../../../@vitest_utils@3.0.5/node_modules/@vitest/utils/dist/index.qwik.cjs");
 const chai$1 = require("../../../../../chai@5.1.2/node_modules/chai/chai.qwik.cjs");
 const utils_C8RiOc4B = require("./utils.C8RiOc4B.qwik.cjs");
 const _commonjsHelpers_BFTU3MAI = require("./_commonjsHelpers.BFTU3MAI.qwik.cjs");
-const index$1 = require("../../../../../@vitest_snapshot@2.1.8/node_modules/@vitest/snapshot/dist/index.qwik.cjs");
-const sourceMap = require("../../../../../@vitest_utils@2.1.8/node_modules/@vitest/utils/dist/source-map.qwik.cjs");
+const index$3 = require("../../../../../@vitest_snapshot@3.0.5/node_modules/@vitest/snapshot/dist/index.qwik.cjs");
+const sourceMap = require("../../../../../@vitest_utils@3.0.5/node_modules/@vitest/utils/dist/source-map.qwik.cjs");
 const date_W2xKR2qe = require("./date.W2xKR2qe.qwik.cjs");
-const index$2 = require("../../../../../@vitest_spy@2.1.8/node_modules/@vitest/spy/dist/index.qwik.cjs");
-const helpers = require("../../../../../@vitest_utils@2.1.8/node_modules/@vitest/utils/dist/helpers.qwik.cjs");
+const index = require("../../../../../@vitest_spy@3.0.5/node_modules/@vitest/spy/dist/index.qwik.cjs");
+const helpers = require("../../../../../@vitest_utils@3.0.5/node_modules/@vitest/utils/dist/helpers.qwik.cjs");
 const unsupported = [
   // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't thow an error
+  // snapshots will always succeed as long as the poll method doesn't throw an error
   // in this case using the `vi.waitFor` method is more appropriate
   "matchSnapshot",
   "toMatchSnapshot",
@@ -70,19 +70,9 @@ function createExpectPoll(expect) {
           const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
           const promise = () => new Promise((resolve, reject) => {
             let intervalId;
+            let timeoutId;
             let lastError;
-            const { setTimeout, clearTimeout } = index$3.getSafeTimers();
-            const timeoutId = setTimeout(() => {
-              clearTimeout(intervalId);
-              reject(
-                copyStackTrace$1(
-                  new Error(`Matcher did not succeed in ${timeout}ms`, {
-                    cause: lastError
-                  }),
-                  STACK_TRACE_ERROR
-                )
-              );
-            }, timeout);
+            const { setTimeout, clearTimeout } = index$1.getSafeTimers();
             const check = async () => {
               try {
                 chai$1.util.flag(assertion, "_name", key);
@@ -93,9 +83,26 @@ function createExpectPoll(expect) {
                 clearTimeout(timeoutId);
               } catch (err) {
                 lastError = err;
-                intervalId = setTimeout(check, interval);
+                if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) {
+                  intervalId = setTimeout(check, interval);
+                }
               }
             };
+            timeoutId = setTimeout(() => {
+              clearTimeout(intervalId);
+              chai$1.util.flag(assertion, "_isLastPollAttempt", true);
+              const rejectWithCause = (cause) => {
+                reject(
+                  copyStackTrace$1(
+                    new Error(`Matcher did not succeed in ${timeout}ms`, {
+                      cause
+                    }),
+                    STACK_TRACE_ERROR
+                  )
+                );
+              };
+              check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
+            }, timeout);
             check();
           });
           let awaited = false;
@@ -264,9 +271,9 @@ function recordAsyncExpect(_test, promise, assertion, error) {
       }
     });
     return {
-      then(onFullfilled, onRejected) {
+      then(onFulfilled, onRejected) {
         resolved = true;
-        return promise.then(onFullfilled, onRejected);
+        return promise.then(onFulfilled, onRejected);
       },
       catch(onRejected) {
         return promise.catch(onRejected);
@@ -282,9 +289,9 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 let _client;
 function getSnapshotClient() {
   if (!_client) {
-    _client = new index$1.SnapshotClient({
+    _client = new index$3.SnapshotClient({
       isEqual: (received, expected) => {
-        return index.equals(received, expected, [index.iterableEquality, index.subsetEquality]);
+        return index$2.equals(received, expected, [index$2.iterableEquality, index$2.subsetEquality]);
       }
     });
   }
@@ -307,15 +314,20 @@ function getError(expected, promise) {
   throw new Error("snapshot function didn't throw");
 }
 function getTestNames(test) {
-  if (!test) {
-    return {};
-  }
   return {
     filepath: test.file.filepath,
-    name: chunkTasks.e(test).slice(1).join(" > ")
+    name: chunkTasks.f(test).slice(1).join(" > "),
+    testId: test.id
   };
 }
 const SnapshotPlugin = (chai2, utils) => {
+  function getTest(assertionName, obj) {
+    const test = utils.flag(obj, "vitest-test");
+    if (!test) {
+      throw new Error(`'${assertionName}' cannot be used without test context`);
+    }
+    return test;
+  }
   for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
     utils.addMethod(
       chai2.Assertion.prototype,
@@ -327,7 +339,7 @@ const SnapshotPlugin = (chai2, utils) => {
           throw new Error(`${key} cannot be used with "not"`);
         }
         const expected = utils.flag(this, "object");
-        const test = utils.flag(this, "vitest-test");
+        const test = getTest(key, this);
         if (typeof properties === "string" && typeof message === "undefined") {
           message = properties;
           properties = void 0;
@@ -355,7 +367,7 @@ const SnapshotPlugin = (chai2, utils) => {
       }
       const error = new Error("resolves");
       const expected = utils.flag(this, "object");
-      const test = utils.flag(this, "vitest-test");
+      const test = getTest("toMatchFileSnapshot", this);
       const errorMessage = utils.flag(this, "message");
       const promise = getSnapshotClient().assertRaw({
         received: expected,
@@ -384,8 +396,8 @@ const SnapshotPlugin = (chai2, utils) => {
       if (isNot) {
         throw new Error('toMatchInlineSnapshot cannot be used with "not"');
       }
-      const test = utils.flag(this, "vitest-test");
-      const isInsideEach = test && (test.each || test.suite?.each);
+      const test = getTest("toMatchInlineSnapshot", this);
+      const isInsideEach = test.each || test.suite?.each;
       if (isInsideEach) {
         throw new Error(
           "InlineSnapshot cannot be used inside of test.each or describe.each"
@@ -399,7 +411,7 @@ const SnapshotPlugin = (chai2, utils) => {
         properties = void 0;
       }
       if (inlineSnapshot) {
-        inlineSnapshot = index$1.stripSnapshotIndentation(inlineSnapshot);
+        inlineSnapshot = index$3.stripSnapshotIndentation(inlineSnapshot);
       }
       const errorMessage = utils.flag(this, "message");
       getSnapshotClient().assert({
@@ -426,7 +438,7 @@ const SnapshotPlugin = (chai2, utils) => {
         );
       }
       const expected = utils.flag(this, "object");
-      const test = utils.flag(this, "vitest-test");
+      const test = getTest("toThrowErrorMatchingSnapshot", this);
       const promise = utils.flag(this, "promise");
       const errorMessage = utils.flag(this, "message");
       getSnapshotClient().assert({
@@ -447,8 +459,8 @@ const SnapshotPlugin = (chai2, utils) => {
           'toThrowErrorMatchingInlineSnapshot cannot be used with "not"'
         );
       }
-      const test = utils.flag(this, "vitest-test");
-      const isInsideEach = test && (test.each || test.suite?.each);
+      const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
+      const isInsideEach = test.each || test.suite?.each;
       if (isInsideEach) {
         throw new Error(
           "InlineSnapshot cannot be used inside of test.each or describe.each"
@@ -459,7 +471,7 @@ const SnapshotPlugin = (chai2, utils) => {
       const promise = utils.flag(this, "promise");
       const errorMessage = utils.flag(this, "message");
       if (inlineSnapshot) {
-        inlineSnapshot = index$1.stripSnapshotIndentation(inlineSnapshot);
+        inlineSnapshot = index$3.stripSnapshotIndentation(inlineSnapshot);
       }
       getSnapshotClient().assert({
         received: getError(expected, promise),
@@ -472,28 +484,28 @@ const SnapshotPlugin = (chai2, utils) => {
       });
     }
   );
-  utils.addMethod(chai2.expect, "addSnapshotSerializer", index$1.addSerializer);
+  utils.addMethod(chai2.expect, "addSnapshotSerializer", index$3.addSerializer);
 };
-chai$1.use(index.JestExtend);
-chai$1.use(index.JestChaiExpect);
+chai$1.use(index$2.JestExtend);
+chai$1.use(index$2.JestChaiExpect);
 chai$1.use(Subset);
 chai$1.use(SnapshotPlugin);
-chai$1.use(index.JestAsymmetricMatchers);
+chai$1.use(index$2.JestAsymmetricMatchers);
 function createExpect(test) {
   const expect = (value, message) => {
-    const { assertionCalls } = index.getState(expect);
-    index.setState({ assertionCalls: assertionCalls + 1 }, expect);
+    const { assertionCalls } = index$2.getState(expect);
+    index$2.setState({ assertionCalls: assertionCalls + 1 }, expect);
     const assert2 = chai$1.expect(value, message);
     {
       return assert2;
     }
   };
   Object.assign(expect, chai$1.expect);
-  Object.assign(expect, globalThis[index.ASYMMETRIC_MATCHERS_OBJECT]);
-  expect.getState = () => index.getState(expect);
-  expect.setState = (state) => index.setState(state, expect);
-  const globalState = index.getState(globalThis[index.GLOBAL_EXPECT]) || {};
-  index.setState(
+  Object.assign(expect, globalThis[index$2.ASYMMETRIC_MATCHERS_OBJECT]);
+  expect.getState = () => index$2.getState(expect);
+  expect.setState = (state) => index$2.setState(state, expect);
+  const globalState = index$2.getState(globalThis[index$2.GLOBAL_EXPECT]) || {};
+  index$2.setState(
     {
       // this should also add "snapshotState" that is added conditionally
       ...globalState,
@@ -511,7 +523,7 @@ function createExpect(test) {
     expect
   );
   expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
-  expect.addEqualityTesters = (customTesters) => index.addCustomEqualityTesters(customTesters);
+  expect.addEqualityTesters = (customTesters) => index$2.addCustomEqualityTesters(customTesters);
   expect.soft = (...args) => {
     return expect(...args).withContext({ soft: true });
   };
@@ -545,10 +557,11 @@ function createExpect(test) {
   }
   chai$1.util.addMethod(expect, "assertions", assertions);
   chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
+  expect.extend(index$2.customMatchers);
   return expect;
 }
 const globalExpect = createExpect();
-Object.defineProperty(globalThis, index.GLOBAL_EXPECT, {
+Object.defineProperty(globalThis, index$2.GLOBAL_EXPECT, {
   value: globalExpect,
   writable: true,
   configurable: true
@@ -660,42 +673,14 @@ function requireCalledInOrder() {
   calledInOrder_1 = calledInOrder;
   return calledInOrder_1;
 }
-var functionName;
-var hasRequiredFunctionName;
-function requireFunctionName() {
-  if (hasRequiredFunctionName) return functionName;
-  hasRequiredFunctionName = 1;
-  functionName = function functionName2(func) {
-    if (!func) {
-      return "";
-    }
-    try {
-      return func.displayName || func.name || // Use function decomposition as a last resort to get function
-      // name. Does not rely on function decomposition to work - if it
-      // doesn't debugging will be slightly less informative
-      // (i.e. toString will say 'spy' rather than 'myFunc').
-      (String(func).match(/function ([^\s(]+)/) || [])[1];
-    } catch (e) {
-      return "";
-    }
-  };
-  return functionName;
-}
 var className_1;
 var hasRequiredClassName;
 function requireClassName() {
   if (hasRequiredClassName) return className_1;
   hasRequiredClassName = 1;
-  var functionName2 = requireFunctionName();
   function className(value) {
-    return value.constructor && value.constructor.name || // The next branch is for IE11 support only:
-    // Because the name property is not set on the prototype
-    // of the Function object, we finally try to grab the
-    // name from its definition. This will never be reached
-    // in node, so we are not able to test this properly.
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
-    typeof value.constructor === "function" && /* istanbul ignore next */
-    functionName2(value.constructor) || null;
+    const name = value.constructor && value.constructor.name;
+    return name || null;
   }
   className_1 = className;
   return className_1;
@@ -751,6 +736,27 @@ function requireEvery() {
   };
   return every;
 }
+var functionName;
+var hasRequiredFunctionName;
+function requireFunctionName() {
+  if (hasRequiredFunctionName) return functionName;
+  hasRequiredFunctionName = 1;
+  functionName = function functionName2(func) {
+    if (!func) {
+      return "";
+    }
+    try {
+      return func.displayName || func.name || // Use function decomposition as a last resort to get function
+      // name. Does not rely on function decomposition to work - if it
+      // doesn't debugging will be slightly less informative
+      // (i.e. toString will say 'spy' rather than 'myFunc').
+      (String(func).match(/function ([^\s(]+)/) || [])[1];
+    } catch (e) {
+      return "";
+    }
+  };
+  return functionName;
+}
 var orderByFirstCall_1;
 var hasRequiredOrderByFirstCall;
 function requireOrderByFirstCall() {
@@ -1002,12 +1008,16 @@ function requireFakeTimersSrc() {
   if (hasRequiredFakeTimersSrc) return fakeTimersSrc;
   hasRequiredFakeTimersSrc = 1;
   const globalObject = requireLib().global;
-  let timersModule;
+  let timersModule, timersPromisesModule;
   if (typeof __vitest_required__ !== "undefined") {
     try {
       timersModule = __vitest_required__.timers;
     } catch (e) {
     }
+    try {
+      timersPromisesModule = __vitest_required__.timersPromises;
+    } catch (e) {
+    }
   }
   function withGlobal(_global) {
     const maxTimeout = Math.pow(2, 31) - 1;
@@ -1018,26 +1028,57 @@ function requireFakeTimersSrc() {
     const NOOP_ARRAY = function() {
       return [];
     };
-    const timeoutResult = _global.setTimeout(NOOP, 0);
-    const addTimerReturnsObject = typeof timeoutResult === "object";
-    const hrtimePresent = _global.process && typeof _global.process.hrtime === "function";
-    const hrtimeBigintPresent = hrtimePresent && typeof _global.process.hrtime.bigint === "function";
-    const nextTickPresent = _global.process && typeof _global.process.nextTick === "function";
+    const isPresent = {};
+    let timeoutResult, addTimerReturnsObject = false;
+    if (_global.setTimeout) {
+      isPresent.setTimeout = true;
+      timeoutResult = _global.setTimeout(NOOP, 0);
+      addTimerReturnsObject = typeof timeoutResult === "object";
+    }
+    isPresent.clearTimeout = Boolean(_global.clearTimeout);
+    isPresent.setInterval = Boolean(_global.setInterval);
+    isPresent.clearInterval = Boolean(_global.clearInterval);
+    isPresent.hrtime = _global.process && typeof _global.process.hrtime === "function";
+    isPresent.hrtimeBigint = isPresent.hrtime && typeof _global.process.hrtime.bigint === "function";
+    isPresent.nextTick = _global.process && typeof _global.process.nextTick === "function";
     const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
-    const performancePresent = _global.performance && typeof _global.performance.now === "function";
+    isPresent.performance = _global.performance && typeof _global.performance.now === "function";
     const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
     const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
-    const queueMicrotaskPresent = _global.hasOwnProperty("queueMicrotask");
-    const requestAnimationFramePresent = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
-    const cancelAnimationFramePresent = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
-    const requestIdleCallbackPresent = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
-    const cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
-    const setImmediatePresent = _global.setImmediate && typeof _global.setImmediate === "function";
-    const intlPresent = _global.Intl && typeof _global.Intl === "object";
-    _global.clearTimeout(timeoutResult);
+    isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+    isPresent.requestAnimationFrame = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
+    isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
+    isPresent.requestIdleCallback = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
+    isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
+    isPresent.setImmediate = _global.setImmediate && typeof _global.setImmediate === "function";
+    isPresent.clearImmediate = _global.clearImmediate && typeof _global.clearImmediate === "function";
+    isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
+    if (_global.clearTimeout) {
+      _global.clearTimeout(timeoutResult);
+    }
     const NativeDate = _global.Date;
-    const NativeIntl = _global.Intl;
+    const NativeIntl = isPresent.Intl ? Object.defineProperties(
+      /* @__PURE__ */ Object.create(null),
+      Object.getOwnPropertyDescriptors(_global.Intl)
+    ) : void 0;
     let uniqueTimerId = idCounterStart;
+    if (NativeDate === void 0) {
+      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 {
+      constructor(name, entryType, startTime, duration) {
+        this.name = name;
+        this.entryType = entryType;
+        this.startTime = startTime;
+        this.duration = duration;
+      }
+      toJSON() {
+        return JSON.stringify({ ...this });
+      }
+    }
     function isNumberFinite(num) {
       if (Number.isFinite) {
         return Number.isFinite(num);
@@ -1138,80 +1179,66 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
       }
       return infiniteLoopError;
     }
-    function mirrorDateProperties(target, source) {
-      let prop;
-      for (prop in source) {
-        if (source.hasOwnProperty(prop)) {
-          target[prop] = source[prop];
+    function createDate() {
+      class ClockDate extends NativeDate {
+        /**
+         * @param {number} year
+         * @param {number} month
+         * @param {number} date
+         * @param {number} hour
+         * @param {number} minute
+         * @param {number} second
+         * @param {number} ms
+         * @returns void
+         */
+        // eslint-disable-next-line no-unused-vars
+        constructor(year, month, date, hour, minute, second, ms) {
+          if (arguments.length === 0) {
+            super(ClockDate.clock.now);
+          } else {
+            super(...arguments);
+          }
+          Object.defineProperty(this, "constructor", {
+            value: NativeDate,
+            enumerable: false
+          });
+        }
+        static [Symbol.hasInstance](instance) {
+          return instance instanceof NativeDate;
         }
       }
-      if (source.now) {
-        target.now = function now() {
-          return target.clock.now;
+      ClockDate.isFake = true;
+      if (NativeDate.now) {
+        ClockDate.now = function now() {
+          return ClockDate.clock.now;
         };
-      } else {
-        delete target.now;
       }
-      if (source.toSource) {
-        target.toSource = function toSource() {
-          return source.toSource();
+      if (NativeDate.toSource) {
+        ClockDate.toSource = function toSource() {
+          return NativeDate.toSource();
         };
-      } else {
-        delete target.toSource;
       }
-      target.toString = function toString() {
-        return source.toString();
+      ClockDate.toString = function toString() {
+        return NativeDate.toString();
       };
-      target.prototype = source.prototype;
-      target.parse = source.parse;
-      target.UTC = source.UTC;
-      target.prototype.toUTCString = source.prototype.toUTCString;
-      target.isFake = true;
-      return target;
-    }
-    function createDate() {
-      function ClockDate(year, month, date, hour, minute, second, ms) {
-        if (!(this instanceof ClockDate)) {
-          return new NativeDate(ClockDate.clock.now).toString();
-        }
-        switch (arguments.length) {
-          case 0:
-            return new NativeDate(ClockDate.clock.now);
-          case 1:
-            return new NativeDate(year);
-          case 2:
-            return new NativeDate(year, month);
-          case 3:
-            return new NativeDate(year, month, date);
-          case 4:
-            return new NativeDate(year, month, date, hour);
-          case 5:
-            return new NativeDate(year, month, date, hour, minute);
-          case 6:
-            return new NativeDate(
-              year,
-              month,
-              date,
-              hour,
-              minute,
-              second
-            );
-          default:
-            return new NativeDate(
-              year,
-              month,
-              date,
-              hour,
-              minute,
-              second,
-              ms
+      const ClockDateProxy = new Proxy(ClockDate, {
+        // handler for [[Call]] invocations (i.e. not using `new`)
+        apply() {
+          if (this instanceof ClockDate) {
+            throw new TypeError(
+              "A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic."
             );
+          }
+          return new NativeDate(ClockDate.clock.now).toString();
         }
-      }
-      return mirrorDateProperties(ClockDate, NativeDate);
+      });
+      return ClockDateProxy;
     }
     function createIntl() {
-      const ClockIntl = { ...NativeIntl };
+      const ClockIntl = {};
+      Object.getOwnPropertyNames(NativeIntl).forEach(
+        (property) => ClockIntl[property] = NativeIntl[property]
+      );
       ClockIntl.DateTimeFormat = function(...args) {
         const realFormatter = new NativeIntl.DateTimeFormat(...args);
         const formatter = {};
@@ -1497,11 +1524,21 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
             timersModule[entry.methodName] = entry.original;
           }
         }
+        if (clock.timersPromisesModuleMethods !== void 0) {
+          for (let j = 0; j < clock.timersPromisesModuleMethods.length; j++) {
+            const entry = clock.timersPromisesModuleMethods[j];
+            timersPromisesModule[entry.methodName] = entry.original;
+          }
+        }
       }
       if (config.shouldAdvanceTime === true) {
         _global.clearInterval(clock.attachedInterval);
       }
       clock.methods = [];
+      for (const [listener, signal] of clock.abortListenerMap.entries()) {
+        signal.removeEventListener("abort", listener);
+        clock.abortListenerMap.delete(listener);
+      }
       if (!clock.timers) {
         return [];
       }
@@ -1516,8 +1553,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       );
       clock[`_${method}`] = target[method];
       if (method === "Date") {
-        const date = mirrorDateProperties(clock[method], target[method]);
-        target[method] = date;
+        target[method] = clock[method];
       } else if (method === "Intl") {
         target[method] = clock[method];
       } else if (method === "performance") {
@@ -1560,36 +1596,38 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       clearInterval: _global.clearInterval,
       Date: _global.Date
     };
-    if (setImmediatePresent) {
+    if (isPresent.setImmediate) {
       timers.setImmediate = _global.setImmediate;
+    }
+    if (isPresent.clearImmediate) {
       timers.clearImmediate = _global.clearImmediate;
     }
-    if (hrtimePresent) {
+    if (isPresent.hrtime) {
       timers.hrtime = _global.process.hrtime;
     }
-    if (nextTickPresent) {
+    if (isPresent.nextTick) {
       timers.nextTick = _global.process.nextTick;
     }
-    if (performancePresent) {
+    if (isPresent.performance) {
       timers.performance = _global.performance;
     }
-    if (requestAnimationFramePresent) {
+    if (isPresent.requestAnimationFrame) {
       timers.requestAnimationFrame = _global.requestAnimationFrame;
     }
-    if (queueMicrotaskPresent) {
-      timers.queueMicrotask = true;
+    if (isPresent.queueMicrotask) {
+      timers.queueMicrotask = _global.queueMicrotask;
     }
-    if (cancelAnimationFramePresent) {
+    if (isPresent.cancelAnimationFrame) {
       timers.cancelAnimationFrame = _global.cancelAnimationFrame;
     }
-    if (requestIdleCallbackPresent) {
+    if (isPresent.requestIdleCallback) {
       timers.requestIdleCallback = _global.requestIdleCallback;
     }
-    if (cancelIdleCallbackPresent) {
+    if (isPresent.cancelIdleCallback) {
       timers.cancelIdleCallback = _global.cancelIdleCallback;
     }
-    if (intlPresent) {
-      timers.Intl = _global.Intl;
+    if (isPresent.Intl) {
+      timers.Intl = NativeIntl;
     }
     const originalSetTimeout = _global.setImmediate || _global.setTimeout;
     function createClock(start, loopLimit) {
@@ -1597,11 +1635,6 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       loopLimit = loopLimit || 1e3;
       let nanos = 0;
       const adjustedSystemTime = [0, 0];
-      if (NativeDate === void 0) {
-        throw new Error(
-          "The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
-        );
-      }
       const clock = {
         now: start,
         Date: createDate(),
@@ -1637,13 +1670,13 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
         const millis = hrt[0] * 1e3 + hrt[1] / 1e6;
         return millis;
       }
-      if (hrtimeBigintPresent) {
+      if (isPresent.hrtimeBigint) {
         hrtime.bigint = function() {
           const parts = hrtime();
           return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
         };
       }
-      if (intlPresent) {
+      if (isPresent.Intl) {
         clock.Intl = createIntl();
         clock.Intl.clock = clock;
       }
@@ -1706,7 +1739,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       clock.clearInterval = function clearInterval(timerId) {
         return clearTimer(clock, timerId, "Interval");
       };
-      if (setImmediatePresent) {
+      if (isPresent.setImmediate) {
         clock.setImmediate = function setImmediate(func) {
           return addTimer(clock, {
             func,
@@ -1939,6 +1972,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
             function doRun() {
               originalSetTimeout(function() {
                 try {
+                  runJobs(clock);
                   let numTimers;
                   if (i < clock.loopLimit) {
                     if (!clock.timers) {
@@ -1986,6 +2020,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
               try {
                 const timer = lastTimer(clock);
                 if (!timer) {
+                  runJobs(clock);
                   resolve(clock.now);
                 }
                 resolve(clock.tickAsync(timer.callAt - clock.now));
@@ -2028,11 +2063,11 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
         }
         clock.tick(ms);
       };
-      if (performancePresent) {
+      if (isPresent.performance) {
         clock.performance = /* @__PURE__ */ Object.create(null);
         clock.performance.now = fakePerformanceNow;
       }
-      if (hrtimePresent) {
+      if (isPresent.hrtime) {
         clock.hrtime = hrtime;
       }
       return clock;
@@ -2059,17 +2094,24 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           "config.target is no longer supported. Use `withGlobal(target)` instead."
         );
       }
+      function handleMissingTimer(timer) {
+        if (config.ignoreMissingTimers) {
+          return;
+        }
+        throw new ReferenceError(
+          `non-existent timers and/or objects cannot be faked: '${timer}'`
+        );
+      }
       let i, l;
       const clock = createClock(config.now, config.loopLimit);
       clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
       clock.uninstall = function() {
         return uninstall(clock, config);
       };
+      clock.abortListenerMap = /* @__PURE__ */ new Map();
       clock.methods = config.toFake || [];
       if (clock.methods.length === 0) {
-        clock.methods = Object.keys(timers).filter(function(key) {
-          return key !== "nextTick" && key !== "queueMicrotask";
-        });
+        clock.methods = Object.keys(timers);
       }
       if (config.shouldAdvanceTime === true) {
         const intervalTick = doIntervalTick.bind(
@@ -2098,17 +2140,25 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
               clock.performance[name] = name.indexOf("getEntries") === 0 ? NOOP_ARRAY : NOOP;
             }
           });
+          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")) {
-          throw new ReferenceError(
-            "non-existent performance object cannot be faked"
-          );
+          return handleMissingTimer("performance");
         }
       }
       if (_global === globalObject && timersModule) {
         clock.timersModuleMethods = [];
       }
+      if (_global === globalObject && timersPromisesModule) {
+        clock.timersPromisesModuleMethods = [];
+      }
       for (i = 0, l = clock.methods.length; i < l; i++) {
         const nameOfMethodToReplace = clock.methods[i];
+        if (!isPresent[nameOfMethodToReplace]) {
+          handleMissingTimer(nameOfMethodToReplace);
+          continue;
+        }
         if (nameOfMethodToReplace === "hrtime") {
           if (_global.process && typeof _global.process.hrtime === "function") {
             hijackMethod(_global.process, nameOfMethodToReplace, clock);
@@ -2128,6 +2178,194 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           });
           timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
         }
+        if (clock.timersPromisesModuleMethods !== void 0) {
+          if (nameOfMethodToReplace === "setTimeout") {
+            clock.timersPromisesModuleMethods.push({
+              methodName: "setTimeout",
+              original: timersPromisesModule.setTimeout
+            });
+            timersPromisesModule.setTimeout = (delay, value, options = {}) => new Promise((resolve, reject) => {
+              const abort = () => {
+                options.signal.removeEventListener(
+                  "abort",
+                  abort
+                );
+                clock.abortListenerMap.delete(abort);
+                clock.clearTimeout(handle);
+                reject(options.signal.reason);
+              };
+              const handle = clock.setTimeout(() => {
+                if (options.signal) {
+                  options.signal.removeEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.delete(abort);
+                }
+                resolve(value);
+              }, delay);
+              if (options.signal) {
+                if (options.signal.aborted) {
+                  abort();
+                } else {
+                  options.signal.addEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.set(
+                    abort,
+                    options.signal
+                  );
+                }
+              }
+            });
+          } else if (nameOfMethodToReplace === "setImmediate") {
+            clock.timersPromisesModuleMethods.push({
+              methodName: "setImmediate",
+              original: timersPromisesModule.setImmediate
+            });
+            timersPromisesModule.setImmediate = (value, options = {}) => new Promise((resolve, reject) => {
+              const abort = () => {
+                options.signal.removeEventListener(
+                  "abort",
+                  abort
+                );
+                clock.abortListenerMap.delete(abort);
+                clock.clearImmediate(handle);
+                reject(options.signal.reason);
+              };
+              const handle = clock.setImmediate(() => {
+                if (options.signal) {
+                  options.signal.removeEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.delete(abort);
+                }
+                resolve(value);
+              });
+              if (options.signal) {
+                if (options.signal.aborted) {
+                  abort();
+                } else {
+                  options.signal.addEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.set(
+                    abort,
+                    options.signal
+                  );
+                }
+              }
+            });
+          } else if (nameOfMethodToReplace === "setInterval") {
+            clock.timersPromisesModuleMethods.push({
+              methodName: "setInterval",
+              original: timersPromisesModule.setInterval
+            });
+            timersPromisesModule.setInterval = (delay, value, options = {}) => ({
+              [Symbol.asyncIterator]: () => {
+                const createResolvable = () => {
+                  let resolve, reject;
+                  const promise = new Promise((res, rej) => {
+                    resolve = res;
+                    reject = rej;
+                  });
+                  promise.resolve = resolve;
+                  promise.reject = reject;
+                  return promise;
+                };
+                let done = false;
+                let hasThrown = false;
+                let returnCall;
+                let nextAvailable = 0;
+                const nextQueue = [];
+                const handle = clock.setInterval(() => {
+                  if (nextQueue.length > 0) {
+                    nextQueue.shift().resolve();
+                  } else {
+                    nextAvailable++;
+                  }
+                }, delay);
+                const abort = () => {
+                  options.signal.removeEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.delete(abort);
+                  clock.clearInterval(handle);
+                  done = true;
+                  for (const resolvable of nextQueue) {
+                    resolvable.resolve();
+                  }
+                };
+                if (options.signal) {
+                  if (options.signal.aborted) {
+                    done = true;
+                  } else {
+                    options.signal.addEventListener(
+                      "abort",
+                      abort
+                    );
+                    clock.abortListenerMap.set(
+                      abort,
+                      options.signal
+                    );
+                  }
+                }
+                return {
+                  next: async () => {
+                    if (options.signal?.aborted && !hasThrown) {
+                      hasThrown = true;
+                      throw options.signal.reason;
+                    }
+                    if (done) {
+                      return { done: true, value: void 0 };
+                    }
+                    if (nextAvailable > 0) {
+                      nextAvailable--;
+                      return { done: false, value };
+                    }
+                    const resolvable = createResolvable();
+                    nextQueue.push(resolvable);
+                    await resolvable;
+                    if (returnCall && nextQueue.length === 0) {
+                      returnCall.resolve();
+                    }
+                    if (options.signal?.aborted && !hasThrown) {
+                      hasThrown = true;
+                      throw options.signal.reason;
+                    }
+                    if (done) {
+                      return { done: true, value: void 0 };
+                    }
+                    return { done: false, value };
+                  },
+                  return: async () => {
+                    if (done) {
+                      return { done: true, value: void 0 };
+                    }
+                    if (nextQueue.length > 0) {
+                      returnCall = createResolvable();
+                      await returnCall;
+                    }
+                    clock.clearInterval(handle);
+                    done = true;
+                    if (options.signal) {
+                      options.signal.removeEventListener(
+                        "abort",
+                        abort
+                      );
+                      clock.abortListenerMap.delete(abort);
+                    }
+                    return { done: true, value: void 0 };
+                  }
+                };
+              }
+            });
+          }
+        }
       }
       return clock;
     }
@@ -2259,21 +2497,11 @@ class FakeTimers {
           "process.nextTick cannot be mocked inside child_process"
         );
       }
-      const existingFakedMethods = (this._userConfig?.toFake || toFake).filter(
-        (method) => {
-          switch (method) {
-            case "setImmediate":
-            case "clearImmediate":
-              return method in this._global && this._global[method];
-            default:
-              return true;
-          }
-        }
-      );
       this._clock = this._fakeTimers.install({
         now: Date.now(),
         ...this._userConfig,
-        toFake: existingFakedMethods
+        toFake: this._userConfig?.toFake || toFake,
+        ignoreMissingTimers: true
       });
       this._fakingTime = true;
     }
@@ -2324,7 +2552,7 @@ function copyStackTrace(target, source) {
   return target;
 }
 function waitFor(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = index$3.getSafeTimers();
+  const { setTimeout, setInterval, clearTimeout, clearInterval } = index$1.getSafeTimers();
   const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
   const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
   return new Promise((resolve, reject) => {
@@ -2392,7 +2620,7 @@ function waitFor(callback, options = {}) {
   });
 }
 function waitUntil(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = index$3.getSafeTimers();
+  const { setTimeout, setInterval, clearTimeout, clearInterval } = index$1.getSafeTimers();
   const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
   const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
   return new Promise((resolve, reject) => {
@@ -2557,8 +2785,8 @@ function createVitest() {
       return utils;
     },
     // mocks
-    spyOn: index$2.spyOn,
-    fn: index$2.fn,
+    spyOn: index.spyOn,
+    fn: index.fn,
     waitFor,
     waitUntil,
     hoisted(factory) {
@@ -2634,18 +2862,18 @@ function createVitest() {
       return item;
     },
     isMockFunction(fn2) {
-      return index$2.isMockFunction(fn2);
+      return index.isMockFunction(fn2);
     },
     clearAllMocks() {
-      index$2.mocks.forEach((spy) => spy.mockClear());
+      index.mocks.forEach((spy) => spy.mockClear());
       return utils;
     },
     resetAllMocks() {
-      index$2.mocks.forEach((spy) => spy.mockReset());
+      index.mocks.forEach((spy) => spy.mockReset());
       return utils;
     },
     restoreAllMocks() {
-      index$2.mocks.forEach((spy) => spy.mockRestore());
+      index.mocks.forEach((spy) => spy.mockRestore());
       return utils;
     },
     stubGlobal(name, value) {