@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.mjs → 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.mjs}

@@ -1,21 +1,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);
-import { GLOBAL_EXPECT, JestExtend, JestChaiExpect, JestAsymmetricMatchers, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, equals, iterableEquality, subsetEquality } from "../../../../../@vitest_expect@2.1.8/node_modules/@vitest/expect/dist/index.qwik.mjs";
-import "../../../../../@vitest_runner@2.1.8/node_modules/@vitest/runner/dist/index.qwik.mjs";
-import { e as getNames } from "../../../../../@vitest_runner@2.1.8/node_modules/@vitest/runner/dist/chunk-tasks.qwik.mjs";
-import { getSafeTimers } from "../../../../../@vitest_utils@2.1.8/node_modules/@vitest/utils/dist/index.qwik.mjs";
+import { GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers, JestExtend, JestChaiExpect, JestAsymmetricMatchers, equals, iterableEquality, subsetEquality } from "../../../../../@vitest_expect@3.0.5/node_modules/@vitest/expect/dist/index.qwik.mjs";
+import "../../../../../@vitest_runner@3.0.5/node_modules/@vitest/runner/dist/index.qwik.mjs";
+import { f as getNames } from "../../../../../@vitest_runner@3.0.5/node_modules/@vitest/runner/dist/chunk-tasks.qwik.mjs";
+import { getSafeTimers } from "../../../../../@vitest_utils@3.0.5/node_modules/@vitest/utils/dist/index.qwik.mjs";
 import { use, expect, assert, util as utils_exports, Assertion } from "../../../../../chai@5.1.2/node_modules/chai/chai.qwik.mjs";
-import { a as getCurrentEnvironment, g as getWorkerState, i as isChildProcess, r as resetModules, w as waitForImportsToResolve } from "./utils.C8RiOc4B.qwik.mjs";
-import { g as getDefaultExportFromCjs, c as commonjsGlobal } from "./_commonjsHelpers.BFTU3MAI.qwik.mjs";
-import { stripSnapshotIndentation, addSerializer, SnapshotClient } from "../../../../../@vitest_snapshot@2.1.8/node_modules/@vitest/snapshot/dist/index.qwik.mjs";
-import { parseSingleStack } from "../../../../../@vitest_utils@2.1.8/node_modules/@vitest/utils/dist/source-map.qwik.mjs";
+import { g as getWorkerState, w as waitForImportsToResolve, r as resetModules, i as isChildProcess, a as getCurrentEnvironment } from "./utils.C8RiOc4B.qwik.mjs";
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from "./_commonjsHelpers.BFTU3MAI.qwik.mjs";
+import { stripSnapshotIndentation, addSerializer, SnapshotClient } from "../../../../../@vitest_snapshot@3.0.5/node_modules/@vitest/snapshot/dist/index.qwik.mjs";
+import { parseSingleStack } from "../../../../../@vitest_utils@3.0.5/node_modules/@vitest/utils/dist/source-map.qwik.mjs";
 import { R as RealDate, r as resetDate, m as mockDate } from "./date.W2xKR2qe.qwik.mjs";
-import { spyOn, fn, isMockFunction, mocks } from "../../../../../@vitest_spy@2.1.8/node_modules/@vitest/spy/dist/index.qwik.mjs";
-import { assertTypes, createSimpleStackTrace } from "../../../../../@vitest_utils@2.1.8/node_modules/@vitest/utils/dist/helpers.qwik.mjs";
+import { fn, spyOn, mocks, isMockFunction } from "../../../../../@vitest_spy@3.0.5/node_modules/@vitest/spy/dist/index.qwik.mjs";
+import { assertTypes, createSimpleStackTrace } from "../../../../../@vitest_utils@3.0.5/node_modules/@vitest/utils/dist/helpers.qwik.mjs";
 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",
@@ -68,19 +68,9 @@ function createExpectPoll(expect2) {
           const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
           const promise = () => new Promise((resolve, reject) => {
             let intervalId;
+            let timeoutId;
             let lastError;
             const { setTimeout, clearTimeout } = 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 check = async () => {
               try {
                 utils_exports.flag(assertion, "_name", key);
@@ -91,9 +81,26 @@ function createExpectPoll(expect2) {
                 clearTimeout(timeoutId);
               } catch (err) {
                 lastError = err;
-                intervalId = setTimeout(check, interval);
+                if (!utils_exports.flag(assertion, "_isLastPollAttempt")) {
+                  intervalId = setTimeout(check, interval);
+                }
               }
             };
+            timeoutId = setTimeout(() => {
+              clearTimeout(intervalId);
+              utils_exports.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;
@@ -262,9 +269,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);
@@ -305,15 +312,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: getNames(test).slice(1).join(" > ")
+    name: getNames(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,
@@ -325,7 +337,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;
@@ -353,7 +365,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,
@@ -382,8 +394,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"
@@ -424,7 +436,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({
@@ -445,8 +457,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"
@@ -543,6 +555,7 @@ function createExpect(test) {
   }
   utils_exports.addMethod(expect$1, "assertions", assertions);
   utils_exports.addMethod(expect$1, "hasAssertions", hasAssertions);
+  expect$1.extend(customMatchers);
   return expect$1;
 }
 const globalExpect = createExpect();
@@ -658,42 +671,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;
@@ -749,6 +734,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() {
@@ -1000,12 +1006,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;
@@ -1016,26 +1026,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);
@@ -1136,80 +1177,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 = {};
@@ -1495,11 +1522,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 [];
       }
@@ -1514,8 +1551,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") {
@@ -1558,36 +1594,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) {
@@ -1595,11 +1633,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(),
@@ -1635,13 +1668,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;
       }
@@ -1704,7 +1737,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,
@@ -1937,6 +1970,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) {
@@ -1984,6 +2018,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));
@@ -2026,11 +2061,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;
@@ -2057,17 +2092,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(
@@ -2096,17 +2138,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);
@@ -2126,6 +2176,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;
     }
@@ -2257,21 +2495,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;
     }