vitest 3.0.0-beta.3 → 3.0.0

package/dist/chunks/{vi.S4Fq8wSo.js → vi.Da_PT3Vw.js}

@@ -13,7 +13,7 @@ import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy';
 
 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",
@@ -66,19 +66,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 } = 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 {
                 chai$1.util.flag(assertion, "_name", key);
@@ -89,9 +79,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;
@@ -592,7 +599,6 @@ function requireGlobal () {
 
 	/**
 	 * A reference to the global object
-	 *
 	 * @type {object} globalObject
 	 */
 	var globalObject;
@@ -623,11 +629,9 @@ function requireThrowsOnProto () {
 	/**
 	 * Is true when the environment causes an error to be thrown for accessing the
 	 * __proto__ property.
-	 *
 	 * This is necessary in order to support `node --disable-proto=throw`.
 	 *
 	 * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
-	 *
 	 * @type {boolean}
 	 */
 	let throwsOnProto;
@@ -748,7 +752,6 @@ function requireCalledInOrder () {
 
 	/**
 	 * A Sinon proxy object (fake, spy, stub)
-	 *
 	 * @typedef {object} SinonProxy
 	 * @property {Function} calledBefore - A method that determines if this proxy was called before another one
 	 * @property {string} id - Some id
@@ -757,7 +760,6 @@ function requireCalledInOrder () {
 
 	/**
 	 * Returns true when the spies have been called in the order they were supplied in
-	 *
 	 * @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
 	 * @returns {boolean} true when spies are called in order, false otherwise
 	 */
@@ -773,43 +775,6 @@ function requireCalledInOrder () {
 	return calledInOrder_1;
 }
 
-var functionName;
-var hasRequiredFunctionName;
-
-function requireFunctionName () {
-	if (hasRequiredFunctionName) return functionName;
-	hasRequiredFunctionName = 1;
-
-	/**
-	 * Returns a display name for a function
-	 *
-	 * @param  {Function} func
-	 * @returns {string}
-	 */
-	functionName = function functionName(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) {
-	        // Stringify may fail and we might get an exception, as a last-last
-	        // resort fall back to empty string.
-	        return "";
-	    }
-	};
-	return functionName;
-}
-
 var className_1;
 var hasRequiredClassName;
 
@@ -817,28 +782,14 @@ function requireClassName () {
 	if (hasRequiredClassName) return className_1;
 	hasRequiredClassName = 1;
 
-	var functionName = requireFunctionName();
-
 	/**
 	 * Returns a display name for a value from a constructor
-	 *
 	 * @param  {object} value A value to examine
 	 * @returns {(string|null)} A string or null
 	 */
 	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 */
-	            functionName(value.constructor)) ||
-	        null
-	    );
+	    const name = value.constructor && value.constructor.name;
+	    return name || null;
 	}
 
 	className_1 = className;
@@ -859,7 +810,6 @@ function requireDeprecated () {
 		/**
 		 * Returns a function that will invoke the supplied function and print a
 		 * deprecation warning to the console each time it is called.
-		 *
 		 * @param  {Function} func
 		 * @param  {string} msg
 		 * @returns {Function}
@@ -878,7 +828,6 @@ function requireDeprecated () {
 		/**
 		 * Returns a string which can be supplied to `wrap()` to notify the user that a
 		 * particular part of the sinon API has been deprecated.
-		 *
 		 * @param  {string} packageName
 		 * @param  {string} funcName
 		 * @returns {string}
@@ -889,7 +838,6 @@ function requireDeprecated () {
 
 		/**
 		 * Prints a warning on the console, when it exists
-		 *
 		 * @param  {string} msg
 		 * @returns {undefined}
 		 */
@@ -918,7 +866,6 @@ function requireEvery () {
 	/**
 	 * Returns true when fn returns true for all members of obj.
 	 * This is an every implementation that works for all iterables
-	 *
 	 * @param  {object}   obj
 	 * @param  {Function} fn
 	 * @returns {boolean}
@@ -943,6 +890,42 @@ function requireEvery () {
 	return every;
 }
 
+var functionName;
+var hasRequiredFunctionName;
+
+function requireFunctionName () {
+	if (hasRequiredFunctionName) return functionName;
+	hasRequiredFunctionName = 1;
+
+	/**
+	 * Returns a display name for a function
+	 * @param  {Function} func
+	 * @returns {string}
+	 */
+	functionName = function functionName(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) {
+	        // Stringify may fail and we might get an exception, as a last-last
+	        // resort fall back to empty string.
+	        return "";
+	    }
+	};
+	return functionName;
+}
+
 var orderByFirstCall_1;
 var hasRequiredOrderByFirstCall;
 
@@ -968,14 +951,12 @@ function requireOrderByFirstCall () {
 
 	/**
 	 * A Sinon proxy object (fake, spy, stub)
-	 *
 	 * @typedef {object} SinonProxy
 	 * @property {Function} getCall - A method that can return the first call
 	 */
 
 	/**
 	 * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
-	 *
 	 * @param  {SinonProxy[] | SinonProxy} spies
 	 * @returns {SinonProxy[]}
 	 */
@@ -1480,7 +1461,6 @@ function requireTypeOf () {
 
 	/**
 	 * Returns the lower-case result of running type from type-detect on the value
-	 *
 	 * @param  {*} value
 	 * @returns {string}
 	 */
@@ -1499,7 +1479,6 @@ function requireValueToString () {
 
 	/**
 	 * Returns a string representation of the value
-	 *
 	 * @param  {*} value
 	 * @returns {string}
 	 */
@@ -1544,13 +1523,18 @@ function requireFakeTimersSrc () {
 	hasRequiredFakeTimersSrc = 1;
 
 	const globalObject = requireLib().global;
-	let timersModule;
+	let timersModule, timersPromisesModule;
 	if (typeof __vitest_required__ !== 'undefined') {
 	    try {
 	        timersModule = __vitest_required__.timers;
 	    } catch (e) {
 	        // ignored
 	    }
+	    try {
+	        timersPromisesModule = __vitest_required__.timersPromises;
+	    } catch (e) {
+	        // ignored
+	    }
 	}
 
 	/**
@@ -1561,7 +1545,6 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * Queues a function to be called during a browser's idle periods
-	 *
 	 * @callback RequestIdleCallback
 	 * @param {function(IdleDeadline)} callback
 	 * @param {{timeout: number}} options - an options object
@@ -1571,14 +1554,14 @@ function requireFakeTimersSrc () {
 	/**
 	 * @callback NextTick
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} arguments - optional arguments to call the callback with
+	 * @param {...*} args - optional arguments to call the callback with
 	 * @returns {void}
 	 */
 
 	/**
 	 * @callback SetImmediate
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} arguments - optional arguments to call the callback with
+	 * @param {...*} args - optional arguments to call the callback with
 	 * @returns {NodeImmediate}
 	 */
 
@@ -1637,12 +1620,13 @@ function requireFakeTimersSrc () {
 	 * @property {Function[]} methods - the methods that are faked
 	 * @property {boolean} [shouldClearNativeTimers] inherited from config
 	 * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
+	 * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
+	 * @property {Map<function(): void, AbortSignal>} abortListenerMap
 	 */
 	/* eslint-enable jsdoc/require-property-description */
 
 	/**
 	 * Configuration object for the `install` method.
-	 *
 	 * @typedef {object} Config
 	 * @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)
 	 * @property {string[]} [toFake] names of the methods that should be faked.
@@ -1650,12 +1634,12 @@ function requireFakeTimersSrc () {
 	 * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)
 	 * @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)
 	 * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)
+	 * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error
 	 */
 
 	/* eslint-disable jsdoc/require-property-description */
 	/**
 	 * The internal structure to describe a scheduled fake timer
-	 *
 	 * @typedef {object} Timer
 	 * @property {Function} func
 	 * @property {*[]} args
@@ -1669,7 +1653,6 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * A Node timer
-	 *
 	 * @typedef {object} NodeImmediate
 	 * @property {function(): boolean} hasRef
 	 * @property {function(): NodeImmediate} ref
@@ -1681,7 +1664,6 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * Mocks available features in the specified global namespace.
-	 *
 	 * @param {*} _global Namespace to mock (e.g. `window`)
 	 * @returns {FakeTimers}
 	 */
@@ -1694,16 +1676,26 @@ function requireFakeTimersSrc () {
 	    const NOOP_ARRAY = function () {
 	        return [];
 	    };
-	    const timeoutResult = _global.setTimeout(NOOP, 0);
-	    const addTimerReturnsObject = typeof timeoutResult === "object";
-	    const hrtimePresent =
+	    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";
-	    const hrtimeBigintPresent =
-	        hrtimePresent && typeof _global.process.hrtime.bigint === "function";
-	    const nextTickPresent =
+	    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 =
+	    isPresent.performance =
 	        _global.performance && typeof _global.performance.now === "function";
 	    const hasPerformancePrototype =
 	        _global.Performance &&
@@ -1712,29 +1704,65 @@ function requireFakeTimersSrc () {
 	        _global.performance &&
 	        _global.performance.constructor &&
 	        _global.performance.constructor.prototype;
-	    const queueMicrotaskPresent = _global.hasOwnProperty("queueMicrotask");
-	    const requestAnimationFramePresent =
+	    isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+	    isPresent.requestAnimationFrame =
 	        _global.requestAnimationFrame &&
 	        typeof _global.requestAnimationFrame === "function";
-	    const cancelAnimationFramePresent =
+	    isPresent.cancelAnimationFrame =
 	        _global.cancelAnimationFrame &&
 	        typeof _global.cancelAnimationFrame === "function";
-	    const requestIdleCallbackPresent =
+	    isPresent.requestIdleCallback =
 	        _global.requestIdleCallback &&
 	        typeof _global.requestIdleCallback === "function";
-	    const cancelIdleCallbackPresent =
+	    isPresent.cancelIdleCallbackPresent =
 	        _global.cancelIdleCallback &&
 	        typeof _global.cancelIdleCallback === "function";
-	    const setImmediatePresent =
+	    isPresent.setImmediate =
 	        _global.setImmediate && typeof _global.setImmediate === "function";
-	    const intlPresent = _global.Intl && typeof _global.Intl === "object";
+	    isPresent.clearImmediate =
+	        _global.clearImmediate && typeof _global.clearImmediate === "function";
+	    isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
 
-	    _global.clearTimeout(timeoutResult);
+	    if (_global.clearTimeout) {
+	        _global.clearTimeout(timeoutResult);
+	    }
 
 	    const NativeDate = _global.Date;
-	    const NativeIntl = _global.Intl;
+	    const NativeIntl = isPresent.Intl
+	        ? Object.defineProperties(
+	              Object.create(null),
+	              Object.getOwnPropertyDescriptors(_global.Intl),
+	          )
+	        : undefined;
 	    let uniqueTimerId = idCounterStart;
 
+	    if (NativeDate === undefined) {
+	        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;
+
+	    /**
+	     * The PerformanceEntry object encapsulates a single performance metric
+	     * that is part of the browser's performance timeline.
+	     *
+	     * This is an object returned by the `mark` and `measure` methods on the Performance prototype
+	     */
+	    class FakePerformanceEntry {
+	        constructor(name, entryType, startTime, duration) {
+	            this.name = name;
+	            this.entryType = entryType;
+	            this.startTime = startTime;
+	            this.duration = duration;
+	        }
+
+	        toJSON() {
+	            return JSON.stringify({ ...this });
+	        }
+	    }
+
 	    /**
 	     * @param {number} num
 	     * @returns {boolean}
@@ -1770,7 +1798,6 @@ function requireFakeTimersSrc () {
 	     * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into
 	     * number of milliseconds. This is used to support human-readable strings passed
 	     * to clock.tick()
-	     *
 	     * @param {string} str
 	     * @returns {number}
 	     */
@@ -1787,7 +1814,7 @@ function requireFakeTimersSrc () {
 
 	        if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
 	            throw new Error(
-	                "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
+	                "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits",
 	            );
 	        }
 
@@ -1806,7 +1833,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Get the decimal part of the millisecond value as nanoseconds
-	     *
 	     * @param {number} msFloat the number of milliseconds
 	     * @returns {number} an integer number of nanoseconds in the range [0,1e6)
 	     *
@@ -1823,7 +1849,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Used to grok the `now` parameter to createClock.
-	     *
 	     * @param {Date|number} epoch the system time
 	     * @returns {number}
 	     */
@@ -1856,7 +1881,7 @@ function requireFakeTimersSrc () {
 	     */
 	    function getInfiniteLoopError(clock, job) {
 	        const infiniteLoopError = new Error(
-	            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`
+	            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`,
 	        );
 
 	        if (!job.error) {
@@ -1866,13 +1891,13 @@ function requireFakeTimersSrc () {
 	        // pattern never matched in Node
 	        const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
 	        let clockMethodPattern = new RegExp(
-	            String(Object.keys(clock).join("|"))
+	            String(Object.keys(clock).join("|")),
 	        );
 
 	        if (addTimerReturnsObject) {
 	            // node.js environment
 	            clockMethodPattern = new RegExp(
-	                `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`
+	                `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`,
 	            );
 	        }
 
@@ -1919,114 +1944,101 @@ function requireFakeTimersSrc () {
 	        return infiniteLoopError;
 	    }
 
-	    /**
-	     * @param {Date} target
-	     * @param {Date} source
-	     * @returns {Date} the target after modifications
-	     */
-	    function mirrorDateProperties(target, source) {
-	        let prop;
-	        for (prop in source) {
-	            if (source.hasOwnProperty(prop)) {
-	                target[prop] = source[prop];
+	    //eslint-disable-next-line jsdoc/require-jsdoc
+	    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) {
+	                // Defensive and verbose to avoid potential harm in passing
+	                // explicit undefined when user does not pass argument
+	                if (arguments.length === 0) {
+	                    super(ClockDate.clock.now);
+	                } else {
+	                    super(...arguments);
+	                }
+
+	                // ensures identity checks using the constructor prop still works
+	                // this should have no other functional effect
+	                Object.defineProperty(this, "constructor", {
+	                    value: NativeDate,
+	                    enumerable: false,
+	                });
+	            }
+
+	            static [Symbol.hasInstance](instance) {
+	                return instance instanceof NativeDate;
 	            }
 	        }
 
-	        // set special now implementation
-	        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;
 	        }
 
-	        // set special toSource implementation
-	        if (source.toSource) {
-	            target.toSource = function toSource() {
-	                return source.toSource();
+	        if (NativeDate.toSource) {
+	            ClockDate.toSource = function toSource() {
+	                return NativeDate.toSource();
 	            };
-	        } else {
-	            delete target.toSource;
 	        }
 
-	        // set special toString implementation
-	        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;
-	    }
-
-	    //eslint-disable-next-line jsdoc/require-jsdoc
-	    function createDate() {
+	        // noinspection UnnecessaryLocalVariableJS
 	        /**
-	         * @param {number} year
-	         * @param {number} month
-	         * @param {number} date
-	         * @param {number} hour
-	         * @param {number} minute
-	         * @param {number} second
-	         * @param {number} ms
-	         * @returns {Date}
+	         * A normal Class constructor cannot be called without `new`, but Date can, so we need
+	         * to wrap it in a Proxy in order to ensure this functionality of Date is kept intact
+	         * @type {ClockDate}
 	         */
-	        function ClockDate(year, month, date, hour, minute, second, ms) {
-	            // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.
-	            // This remains so in the 10th edition of 2019 as well.
-	            if (!(this instanceof ClockDate)) {
-	                return new NativeDate(ClockDate.clock.now).toString();
-	            }
-
-	            // if Date is called as a constructor with 'new' keyword
-	            // Defensive and verbose to avoid potential harm in passing
-	            // explicit undefined when user does not pass argument
-	            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() {
+	                // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.
+	                // This remains so in the 10th edition of 2019 as well.
+	                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;
 	    }
 
-	    //eslint-disable-next-line jsdoc/require-jsdoc
+	    /**
+	     * Mirror Intl by default on our fake implementation
+	     *
+	     * Most of the properties are the original native ones,
+	     * but we need to take control of those that have a
+	     * dependency on the current clock.
+	     * @returns {object} the partly fake Intl implementation
+	     */
 	    function createIntl() {
-	        const ClockIntl = { ...NativeIntl };
+	        const ClockIntl = {};
+	        /*
+	         * All properties of Intl are non-enumerable, so we need
+	         * to do a bit of work to get them out.
+	         */
+	        Object.getOwnPropertyNames(NativeIntl).forEach(
+	            (property) => (ClockIntl[property] = NativeIntl[property]),
+	        );
 
 	        ClockIntl.DateTimeFormat = function (...args) {
 	            const realFormatter = new NativeIntl.DateTimeFormat(...args);
@@ -2036,7 +2048,7 @@ function requireFakeTimersSrc () {
 	                (method) => {
 	                    formatter[method] =
 	                        realFormatter[method].bind(realFormatter);
-	                }
+	                },
 	            );
 
 	            ["format", "formatToParts"].forEach((method) => {
@@ -2049,7 +2061,7 @@ function requireFakeTimersSrc () {
 	        };
 
 	        ClockIntl.DateTimeFormat.prototype = Object.create(
-	            NativeIntl.DateTimeFormat.prototype
+	            NativeIntl.DateTimeFormat.prototype,
 	        );
 
 	        ClockIntl.DateTimeFormat.supportedLocalesOf =
@@ -2102,7 +2114,7 @@ function requireFakeTimersSrc () {
 	                throw new TypeError(
 	                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${
 	                        timer.func
-	                    } of type ${typeof timer.func}`
+	                    } of type ${typeof timer.func}`,
 	                );
 	            }
 	        }
@@ -2188,7 +2200,6 @@ function requireFakeTimersSrc () {
 	    /* eslint consistent-return: "off" */
 	    /**
 	     * Timer comparitor
-	     *
 	     * @param {Timer} a
 	     * @param {Timer} b
 	     * @returns {number}
@@ -2320,7 +2331,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Gets clear handler name for a given timer type
-	     *
 	     * @param {string} ttype
 	     */
 	    function getClearHandler(ttype) {
@@ -2332,7 +2342,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Gets schedule handler name for a given timer type
-	     *
 	     * @param {string} ttype
 	     */
 	    function getScheduleHandler(ttype) {
@@ -2385,7 +2394,7 @@ function requireFakeTimersSrc () {
 	            }
 	            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`."
+	                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`.",
 	            );
 	        }
 
@@ -2402,7 +2411,7 @@ function requireFakeTimersSrc () {
 	                const clear = getClearHandler(ttype);
 	                const schedule = getScheduleHandler(timer.type);
 	                throw new Error(
-	                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`
+	                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`,
 	                );
 	            }
 	        }
@@ -2427,7 +2436,7 @@ function requireFakeTimersSrc () {
 	            } else if (method === "performance") {
 	                const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
 	                    clock,
-	                    `_${method}`
+	                    `_${method}`,
 	                );
 	                if (
 	                    originalPerfDescriptor &&
@@ -2437,7 +2446,7 @@ function requireFakeTimersSrc () {
 	                    Object.defineProperty(
 	                        _global,
 	                        method,
-	                        originalPerfDescriptor
+	                        originalPerfDescriptor,
 	                    );
 	                } else if (originalPerfDescriptor.configurable) {
 	                    _global[method] = clock[`_${method}`];
@@ -2459,6 +2468,16 @@ function requireFakeTimersSrc () {
 	                    timersModule[entry.methodName] = entry.original;
 	                }
 	            }
+	            if (clock.timersPromisesModuleMethods !== undefined) {
+	                for (
+	                    let j = 0;
+	                    j < clock.timersPromisesModuleMethods.length;
+	                    j++
+	                ) {
+	                    const entry = clock.timersPromisesModuleMethods[j];
+	                    timersPromisesModule[entry.methodName] = entry.original;
+	                }
+	            }
 	        }
 
 	        if (config.shouldAdvanceTime === true) {
@@ -2468,6 +2487,11 @@ function requireFakeTimersSrc () {
 	        // Prevent multiple executions which will completely remove these props
 	        clock.methods = [];
 
+	        for (const [listener, signal] of clock.abortListenerMap.entries()) {
+	            signal.removeEventListener("abort", listener);
+	            clock.abortListenerMap.delete(listener);
+	        }
+
 	        // return pending timers, to enable checking what timers remained on uninstall
 	        if (!clock.timers) {
 	            return [];
@@ -2485,19 +2509,18 @@ function requireFakeTimersSrc () {
 	    function hijackMethod(target, method, clock) {
 	        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
 	            target,
-	            method
+	            method,
 	        );
 	        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") {
 	            const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
 	                target,
-	                method
+	                method,
 	            );
 	            // JSDOM has a read only performance field so we have to save/copy it differently
 	            if (
@@ -2508,12 +2531,12 @@ function requireFakeTimersSrc () {
 	                Object.defineProperty(
 	                    clock,
 	                    `_${method}`,
-	                    originalPerfDescriptor
+	                    originalPerfDescriptor,
 	                );
 
 	                const perfDescriptor = Object.getOwnPropertyDescriptor(
 	                    clock,
-	                    method
+	                    method,
 	                );
 	                Object.defineProperty(target, method, perfDescriptor);
 	            } else {
@@ -2526,7 +2549,7 @@ function requireFakeTimersSrc () {
 
 	            Object.defineProperties(
 	                target[method],
-	                Object.getOwnPropertyDescriptors(clock[method])
+	                Object.getOwnPropertyDescriptors(clock[method]),
 	            );
 	        }
 
@@ -2570,45 +2593,48 @@ function requireFakeTimersSrc () {
 	        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;
@@ -2626,13 +2652,6 @@ function requireFakeTimersSrc () {
 	        let nanos = 0;
 	        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
 
-	        if (NativeDate === undefined) {
-	            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(),
@@ -2658,7 +2677,7 @@ function requireFakeTimersSrc () {
 	            if (Array.isArray(prev)) {
 	                if (prev[1] > 1e9) {
 	                    throw new TypeError(
-	                        "Number of nanoseconds can't exceed a billion"
+	                        "Number of nanoseconds can't exceed a billion",
 	                    );
 	                }
 
@@ -2676,27 +2695,36 @@ function requireFakeTimersSrc () {
 	            return [secsSinceStart, remainderInNanos];
 	        }
 
+	        /**
+	         * A high resolution timestamp in milliseconds.
+	         * @typedef {number} DOMHighResTimeStamp
+	         */
+
+	        /**
+	         * performance.now()
+	         * @returns {DOMHighResTimeStamp}
+	         */
 	        function fakePerformanceNow() {
 	            const hrt = hrtime();
 	            const millis = hrt[0] * 1000 + 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]); // eslint-disable-line
 	            };
 	        }
 
-	        if (intlPresent) {
+	        if (isPresent.Intl) {
 	            clock.Intl = createIntl();
 	            clock.Intl.clock = clock;
 	        }
 
 	        clock.requestIdleCallback = function requestIdleCallback(
 	            func,
-	            timeout
+	            timeout,
 	        ) {
 	            let timeToNextIdlePeriod = 0;
 
@@ -2732,7 +2760,7 @@ function requireFakeTimersSrc () {
 	            clock.setTimeout[utilPromisify.custom] =
 	                function promisifiedSetTimeout(timeout, arg) {
 	                    return new _global.Promise(function setTimeoutExecutor(
-	                        resolve
+	                        resolve,
 	                    ) {
 	                        addTimer(clock, {
 	                            func: resolve,
@@ -2774,7 +2802,7 @@ function requireFakeTimersSrc () {
 	            return clearTimer(clock, timerId, "Interval");
 	        };
 
-	        if (setImmediatePresent) {
+	        if (isPresent.setImmediate) {
 	            clock.setImmediate = function setImmediate(func) {
 	                return addTimer(clock, {
 	                    func: func,
@@ -2793,7 +2821,7 @@ function requireFakeTimersSrc () {
 	                                    args: [arg],
 	                                    immediate: true,
 	                                });
-	                            }
+	                            },
 	                        );
 	                    };
 	            }
@@ -3095,6 +3123,8 @@ function requireFakeTimersSrc () {
 	                    function doRun() {
 	                        originalSetTimeout(function () {
 	                            try {
+	                                runJobs(clock);
+
 	                                let numTimers;
 	                                if (i < clock.loopLimit) {
 	                                    if (!clock.timers) {
@@ -3104,7 +3134,7 @@ function requireFakeTimersSrc () {
 	                                    }
 
 	                                    numTimers = Object.keys(
-	                                        clock.timers
+	                                        clock.timers,
 	                                    ).length;
 	                                    if (numTimers === 0) {
 	                                        resetIsNearInfiniteLimit();
@@ -3150,6 +3180,7 @@ function requireFakeTimersSrc () {
 	                        try {
 	                            const timer = lastTimer(clock);
 	                            if (!timer) {
+	                                runJobs(clock);
 	                                resolve(clock.now);
 	                            }
 
@@ -3210,12 +3241,12 @@ function requireFakeTimersSrc () {
 	            clock.tick(ms);
 	        };
 
-	        if (performancePresent) {
+	        if (isPresent.performance) {
 	            clock.performance = Object.create(null);
 	            clock.performance.now = fakePerformanceNow;
 	        }
 
-	        if (hrtimePresent) {
+	        if (isPresent.hrtime) {
 	            clock.hrtime = hrtime;
 	        }
 
@@ -3237,8 +3268,8 @@ function requireFakeTimersSrc () {
 	        ) {
 	            throw new TypeError(
 	                `FakeTimers.install called with ${String(
-	                    config
-	                )} install requires an object parameter`
+	                    config,
+	                )} install requires an object parameter`,
 	            );
 	        }
 
@@ -3246,7 +3277,7 @@ function requireFakeTimersSrc () {
 	            // Timers are already faked; this is a problem.
 	            // Make the user reset timers before continuing.
 	            throw new TypeError(
-	                "Can't install fake timers twice on the same global object."
+	                "Can't install fake timers twice on the same global object.",
 	            );
 	        }
 
@@ -3259,7 +3290,21 @@ function requireFakeTimersSrc () {
 
 	        if (config.target) {
 	            throw new TypeError(
-	                "config.target is no longer supported. Use `withGlobal(target)` instead."
+	                "config.target is no longer supported. Use `withGlobal(target)` instead.",
+	            );
+	        }
+
+	        /**
+	         * @param {string} timer/object the name of the thing that is not present
+	         * @param timer
+	         */
+	        function handleMissingTimer(timer) {
+	            if (config.ignoreMissingTimers) {
+	                return;
+	            }
+
+	            throw new ReferenceError(
+	                `non-existent timers and/or objects cannot be faked: '${timer}'`,
 	            );
 	        }
 
@@ -3271,24 +3316,23 @@ function requireFakeTimersSrc () {
 	            return uninstall(clock, config);
 	        };
 
+	        clock.abortListenerMap = new Map();
+
 	        clock.methods = config.toFake || [];
 
 	        if (clock.methods.length === 0) {
-	            // do not fake nextTick by default - GitHub#126
-	            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(
 	                null,
 	                clock,
-	                config.advanceTimeDelta
+	                config.advanceTimeDelta,
 	            );
 	            const intervalId = _global.setInterval(
 	                intervalTick,
-	                config.advanceTimeDelta
+	                config.advanceTimeDelta,
 	            );
 	            clock.attachedInterval = intervalId;
 	        }
@@ -3311,18 +3355,33 @@ function requireFakeTimersSrc () {
 	                                : NOOP;
 	                    }
 	                });
+	                // ensure `mark` returns a value that is valid
+	                clock.performance.mark = (name) =>
+	                    new FakePerformanceEntry(name, "mark", 0, 0);
+	                clock.performance.measure = (name) =>
+	                    new FakePerformanceEntry(name, "measure", 0, 100);
+	                // `timeOrigin` should return the time of when the Window session started
+	                // (or the Worker was installed)
+	                clock.performance.timeOrigin = getEpoch(config.now);
 	            } else if ((config.toFake || []).includes("performance")) {
-	                // user explicitly tried to fake performance when not present
-	                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);
+	                // eslint-disable-next-line
+	                continue;
+	            }
+
 	            if (nameOfMethodToReplace === "hrtime") {
 	                if (
 	                    _global.process &&
@@ -3352,6 +3411,239 @@ function requireFakeTimersSrc () {
 	                timersModule[nameOfMethodToReplace] =
 	                    _global[nameOfMethodToReplace];
 	            }
+	            if (clock.timersPromisesModuleMethods !== undefined) {
+	                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);
+
+	                                // This is safe, there is no code path that leads to this function
+	                                // being invoked before handle has been assigned.
+	                                // eslint-disable-next-line no-use-before-define
+	                                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);
+
+	                                // This is safe, there is no code path that leads to this function
+	                                // being invoked before handle has been assigned.
+	                                // eslint-disable-next-line no-use-before-define
+	                                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: undefined };
+	                                    }
+
+	                                    if (nextAvailable > 0) {
+	                                        nextAvailable--;
+	                                        return { done: false, value: 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: undefined };
+	                                    }
+
+	                                    return { done: false, value: value };
+	                                },
+	                                return: async () => {
+	                                    if (done) {
+	                                        return { done: true, value: undefined };
+	                                    }
+
+	                                    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: undefined };
+	                                },
+	                            };
+	                        },
+	                    });
+	                }
+	            }
 	        }
 
 	        return clock;
@@ -3502,21 +3794,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;
     }