import * as chai$1 from 'chai'; import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.jjO7Zipk.js'; import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT as GLOBAL_EXPECT$1, ASYMMETRIC_MATCHERS_OBJECT as ASYMMETRIC_MATCHERS_OBJECT$1, getState, setState, addCustomEqualityTesters } from '@vitest/expect'; import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot'; import { getNames } from '@vitest/runner/utils'; import '@vitest/utils/error'; import { getCurrentTest } from '@vitest/runner'; import { g as getFullName } from './tasks.IknbGB2n.js'; import { g as getWorkerState, a as getCurrentEnvironment } from './global.CkGT_TMy.js'; import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils'; import { parseSingleStack } from '@vitest/utils/source-map'; import { i as isChildProcess } from './base.QYERqzkH.js'; import { R as RealDate, r as resetDate, m as mockDate } from './date.Ns1pGd_X.js'; import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy'; function resetModules(modules, resetMocks = false) { const skipPaths = [ // Vitest /\/vitest\/dist\//, /\/vite-node\/dist\//, // yarn's .store folder /vitest-virtual-\w+\/dist/, // cnpm /@vitest\/dist/, // don't clear mocks ...!resetMocks ? [/^mock:/] : [] ]; modules.forEach((mod, path) => { if (skipPaths.some((re) => re.test(path))) return; modules.invalidateModule(mod); }); } function waitNextTick() { const { setTimeout } = getSafeTimers(); return new Promise((resolve) => setTimeout(resolve, 0)); } async function waitForImportsToResolve() { await waitNextTick(); const state = getWorkerState(); const promises = []; let resolvingCount = 0; for (const mod of state.moduleCache.values()) { if (mod.promise && !mod.evaluated) promises.push(mod.promise); if (mod.resolving) resolvingCount++; } if (!promises.length && !resolvingCount) return; await Promise.allSettled(promises); await waitForImportsToResolve(); } function commonjsRequire(path) { throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.'); } var chaiSubset = {exports: {}}; (function (module, exports) { (function() { (function(chaiSubset) { if (typeof commonjsRequire === 'function' && 'object' === 'object' && 'object' === 'object') { return module.exports = chaiSubset; } else { return chai.use(chaiSubset); } })(function(chai, utils) { var Assertion = chai.Assertion; var assertionPrototype = Assertion.prototype; Assertion.addMethod('containSubset', function (expected) { var actual = utils.flag(this, 'object'); var showDiff = chai.config.showDiff; assertionPrototype.assert.call(this, compare(expected, actual), 'expected #{act} to contain subset #{exp}', 'expected #{act} to not contain subset #{exp}', expected, actual, showDiff ); }); chai.assert.containSubset = function(val, exp, msg) { new chai.Assertion(val, msg).to.be.containSubset(exp); }; function compare(expected, actual) { if (expected === actual) { return true; } if (typeof(actual) !== typeof(expected)) { return false; } if (typeof(expected) !== 'object' || expected === null) { return expected === actual; } if (!!expected && !actual) { return false; } if (Array.isArray(expected)) { if (typeof(actual.length) !== 'number') { return false; } var aa = Array.prototype.slice.call(actual); return expected.every(function (exp) { return aa.some(function (act) { return compare(exp, act); }); }); } if (expected instanceof Date) { if (actual instanceof Date) { return expected.getTime() === actual.getTime(); } else { return false; } } return Object.keys(expected).every(function (key) { var eo = expected[key]; var ao = actual[key]; if (typeof(eo) === 'object' && eo !== null && ao !== null) { return compare(eo, ao); } if (typeof(eo) === 'function') { return eo(ao); } return ao === eo; }); } }); }).call(commonjsGlobal); } (chaiSubset)); var chaiSubsetExports = chaiSubset.exports; var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports); const MATCHERS_OBJECT = Symbol.for("matchers-object"); const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object"); const GLOBAL_EXPECT = Symbol.for("expect-global"); const ASYMMETRIC_MATCHERS_OBJECT = Symbol.for("asymmetric-matchers-object"); if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) { const globalState = /* @__PURE__ */ new WeakMap(); const matchers = /* @__PURE__ */ Object.create(null); const customEqualityTesters = []; const assymetricMatchers = /* @__PURE__ */ Object.create(null); Object.defineProperty(globalThis, MATCHERS_OBJECT, { get: () => globalState }); Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, { configurable: true, get: () => ({ state: globalState.get(globalThis[GLOBAL_EXPECT]), matchers, customEqualityTesters }) }); Object.defineProperty(globalThis, ASYMMETRIC_MATCHERS_OBJECT, { get: () => assymetricMatchers }); } function recordAsyncExpect(test, promise) { if (test && promise instanceof Promise) { promise = promise.finally(() => { const index = test.promises.indexOf(promise); if (index !== -1) test.promises.splice(index, 1); }); if (!test.promises) test.promises = []; test.promises.push(promise); } return promise; } let _client; function getSnapshotClient() { if (!_client) { _client = new SnapshotClient({ isEqual: (received, expected) => { return equals(received, expected, [iterableEquality, subsetEquality]); } }); } return _client; } function getError(expected, promise) { if (typeof expected !== "function") { if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`); return expected; } try { expected(); } catch (e) { return e; } throw new Error("snapshot function didn't throw"); } const SnapshotPlugin = (chai, utils) => { const getTestNames = (test) => { var _a; if (!test) return {}; return { filepath: (_a = test.file) == null ? void 0 : _a.filepath, name: getNames(test).slice(1).join(" > ") }; }; for (const key of ["matchSnapshot", "toMatchSnapshot"]) { utils.addMethod( chai.Assertion.prototype, key, function(properties, message) { const expected = utils.flag(this, "object"); const test = utils.flag(this, "vitest-test"); if (typeof properties === "string" && typeof message === "undefined") { message = properties; properties = void 0; } const errorMessage = utils.flag(this, "message"); getSnapshotClient().assert({ received: expected, message, isInline: false, properties, errorMessage, ...getTestNames(test) }); } ); } utils.addMethod( chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) { const expected = utils.flag(this, "object"); const test = utils.flag(this, "vitest-test"); const errorMessage = utils.flag(this, "message"); const promise = getSnapshotClient().assertRaw({ received: expected, message, isInline: false, rawSnapshot: { file }, errorMessage, ...getTestNames(test) }); return recordAsyncExpect(test, promise); } ); utils.addMethod( chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) { var _a; const test = utils.flag(this, "vitest-test"); const isInsideEach = test && (test.each || ((_a = test.suite) == null ? void 0 : _a.each)); if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each"); const expected = utils.flag(this, "object"); const error = utils.flag(this, "error"); if (typeof properties === "string") { message = inlineSnapshot; inlineSnapshot = properties; properties = void 0; } if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot); const errorMessage = utils.flag(this, "message"); getSnapshotClient().assert({ received: expected, message, isInline: true, properties, inlineSnapshot, error, errorMessage, ...getTestNames(test) }); } ); utils.addMethod( chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) { const expected = utils.flag(this, "object"); const test = utils.flag(this, "vitest-test"); const promise = utils.flag(this, "promise"); const errorMessage = utils.flag(this, "message"); getSnapshotClient().assert({ received: getError(expected, promise), message, errorMessage, ...getTestNames(test) }); } ); utils.addMethod( chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) { var _a; const test = utils.flag(this, "vitest-test"); const isInsideEach = test && (test.each || ((_a = test.suite) == null ? void 0 : _a.each)); if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each"); const expected = utils.flag(this, "object"); const error = utils.flag(this, "error"); const promise = utils.flag(this, "promise"); const errorMessage = utils.flag(this, "message"); if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot); getSnapshotClient().assert({ received: getError(expected, promise), message, inlineSnapshot, isInline: true, error, errorMessage, ...getTestNames(test) }); } ); utils.addMethod( chai.expect, "addSnapshotSerializer", addSerializer ); }; chai$1.use(JestExtend); chai$1.use(JestChaiExpect); chai$1.use(Subset); chai$1.use(SnapshotPlugin); chai$1.use(JestAsymmetricMatchers); function createExpect(test) { var _a; const expect = (value, message) => { const { assertionCalls } = getState(expect); setState({ assertionCalls: assertionCalls + 1, soft: false }, expect); const assert2 = chai$1.expect(value, message); const _test = test || getCurrentTest(); if (_test) return assert2.withTest(_test); else return assert2; }; Object.assign(expect, chai$1.expect); Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT$1]); expect.getState = () => getState(expect); expect.setState = (state) => setState(state, expect); const globalState = getState(globalThis[GLOBAL_EXPECT$1]) || {}; setState({ // this should also add "snapshotState" that is added conditionally ...globalState, assertionCalls: 0, isExpectingAssertions: false, isExpectingAssertionsError: null, expectedAssertionsNumber: null, expectedAssertionsNumberErrorGen: null, environment: getCurrentEnvironment(), testPath: test ? (_a = test.suite.file) == null ? void 0 : _a.filepath : globalState.testPath, currentTestName: test ? getFullName(test) : globalState.currentTestName }, expect); expect.extend = (matchers) => chai$1.expect.extend(expect, matchers); expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters); expect.soft = (...args) => { const assert2 = expect(...args); expect.setState({ soft: true }); return assert2; }; expect.unreachable = (message) => { chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`); }; function assertions(expected) { const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`); if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions); expect.setState({ expectedAssertionsNumber: expected, expectedAssertionsNumberErrorGen: errorGen }); } function hasAssertions() { const error = new Error("expected any number of assertion, but got none"); if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions); expect.setState({ isExpectingAssertions: true, isExpectingAssertionsError: error }); } chai$1.util.addMethod(expect, "assertions", assertions); chai$1.util.addMethod(expect, "hasAssertions", hasAssertions); return expect; } const globalExpect = createExpect(); Object.defineProperty(globalThis, GLOBAL_EXPECT$1, { value: globalExpect, writable: true, configurable: true }); /** * A reference to the global object * * @type {object} globalObject */ var globalObject$1; /* istanbul ignore else */ if (typeof commonjsGlobal !== "undefined") { // Node globalObject$1 = commonjsGlobal; } else if (typeof window !== "undefined") { // Browser globalObject$1 = window; } else { // WebWorker globalObject$1 = self; } var global = globalObject$1; /** * 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$1; try { const object = {}; // eslint-disable-next-line no-proto, no-unused-expressions object.__proto__; throwsOnProto$1 = false; } catch (_) { // This branch is covered when tests are run with `--disable-proto=throw`, // however we can test both branches at the same time, so this is ignored /* istanbul ignore next */ throwsOnProto$1 = true; } var throwsOnProto_1 = throwsOnProto$1; var call = Function.call; var throwsOnProto = throwsOnProto_1; var disallowedProperties = [ // ignore size because it throws from Map "size", "caller", "callee", "arguments", ]; // This branch is covered when tests are run with `--disable-proto=throw`, // however we can test both branches at the same time, so this is ignored /* istanbul ignore next */ if (throwsOnProto) { disallowedProperties.push("__proto__"); } var copyPrototypeMethods = function copyPrototypeMethods(prototype) { // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods return Object.getOwnPropertyNames(prototype).reduce(function ( result, name ) { if (disallowedProperties.includes(name)) { return result; } if (typeof prototype[name] !== "function") { return result; } result[name] = call.bind(prototype[name]); return result; }, Object.create(null)); }; var copyPrototype$5 = copyPrototypeMethods; var array = copyPrototype$5(Array.prototype); var every$1 = array.every; /** * @private */ function hasCallsLeft(callMap, spy) { if (callMap[spy.id] === undefined) { callMap[spy.id] = 0; } return callMap[spy.id] < spy.callCount; } /** * @private */ function checkAdjacentCalls(callMap, spy, index, spies) { var calledBeforeNext = true; if (index !== spies.length - 1) { calledBeforeNext = spy.calledBefore(spies[index + 1]); } if (hasCallsLeft(callMap, spy) && calledBeforeNext) { callMap[spy.id] += 1; return true; } return false; } /** * 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 * @property {number} callCount - Number of times this proxy has been called */ /** * 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 */ function calledInOrder(spies) { var callMap = {}; // eslint-disable-next-line no-underscore-dangle var _spies = arguments.length > 1 ? arguments : spies; return every$1(_spies, checkAdjacentCalls.bind(null, callMap)); } var calledInOrder_1 = calledInOrder; /** * Returns a display name for a function * * @param {Function} func * @returns {string} */ var functionName$1 = 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 ""; } }; var functionName = functionName$1; /** * 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 ); } var className_1 = className; var deprecated = {}; /* eslint-disable no-console */ (function (exports) { /** * 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} */ exports.wrap = function (func, msg) { var wrapped = function () { exports.printWarning(msg); return func.apply(this, arguments); }; if (func.prototype) { wrapped.prototype = func.prototype; } return wrapped; }; /** * 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} */ exports.defaultMsg = function (packageName, funcName) { return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`; }; /** * Prints a warning on the console, when it exists * * @param {string} msg * @returns {undefined} */ exports.printWarning = function (msg) { /* istanbul ignore next */ if (typeof process === "object" && process.emitWarning) { // Emit Warnings in Node process.emitWarning(msg); } else if (console.info) { console.info(msg); } else { console.log(msg); } }; } (deprecated)); /** * 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} */ var every = function every(obj, fn) { var pass = true; try { // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods obj.forEach(function () { if (!fn.apply(this, arguments)) { // Throwing an error is the only way to break `forEach` throw new Error(); } }); } catch (e) { pass = false; } return pass; }; var sort = array.sort; var slice = array.slice; /** * @private */ function comparator(a, b) { // uuid, won't ever be equal var aCall = a.getCall(0); var bCall = b.getCall(0); var aId = (aCall && aCall.callId) || -1; var bId = (bCall && bCall.callId) || -1; return aId < bId ? -1 : 1; } /** * 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[]} */ function orderByFirstCall(spies) { return sort(slice(spies), comparator); } var orderByFirstCall_1 = orderByFirstCall; var copyPrototype$4 = copyPrototypeMethods; var _function = copyPrototype$4(Function.prototype); var copyPrototype$3 = copyPrototypeMethods; var map = copyPrototype$3(Map.prototype); var copyPrototype$2 = copyPrototypeMethods; var object = copyPrototype$2(Object.prototype); var copyPrototype$1 = copyPrototypeMethods; var set = copyPrototype$1(Set.prototype); var copyPrototype = copyPrototypeMethods; var string = copyPrototype(String.prototype); var prototypes = { array: array, function: _function, map: map, object: object, set: set, string: string, }; var typeDetect = {exports: {}}; (function (module, exports) { (function (global, factory) { module.exports = factory() ; }(commonjsGlobal, (function () { /* ! * type-detect * Copyright(c) 2013 jake luer * MIT Licensed */ var promiseExists = typeof Promise === 'function'; /* eslint-disable no-undef */ var globalObject = typeof self === 'object' ? self : commonjsGlobal; // eslint-disable-line id-blacklist var symbolExists = typeof Symbol !== 'undefined'; var mapExists = typeof Map !== 'undefined'; var setExists = typeof Set !== 'undefined'; var weakMapExists = typeof WeakMap !== 'undefined'; var weakSetExists = typeof WeakSet !== 'undefined'; var dataViewExists = typeof DataView !== 'undefined'; var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== 'undefined'; var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== 'undefined'; var setEntriesExists = setExists && typeof Set.prototype.entries === 'function'; var mapEntriesExists = mapExists && typeof Map.prototype.entries === 'function'; var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf(new Set().entries()); var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf(new Map().entries()); var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === 'function'; var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]()); var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === 'function'; var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(''[Symbol.iterator]()); var toStringLeftSliceLength = 8; var toStringRightSliceLength = -1; /** * ### typeOf (obj) * * Uses `Object.prototype.toString` to determine the type of an object, * normalising behaviour across engine versions & well optimised. * * @param {Mixed} object * @return {String} object type * @api public */ function typeDetect(obj) { /* ! Speed optimisation * Pre: * string literal x 3,039,035 ops/sec ±1.62% (78 runs sampled) * boolean literal x 1,424,138 ops/sec ±4.54% (75 runs sampled) * number literal x 1,653,153 ops/sec ±1.91% (82 runs sampled) * undefined x 9,978,660 ops/sec ±1.92% (75 runs sampled) * function x 2,556,769 ops/sec ±1.73% (77 runs sampled) * Post: * string literal x 38,564,796 ops/sec ±1.15% (79 runs sampled) * boolean literal x 31,148,940 ops/sec ±1.10% (79 runs sampled) * number literal x 32,679,330 ops/sec ±1.90% (78 runs sampled) * undefined x 32,363,368 ops/sec ±1.07% (82 runs sampled) * function x 31,296,870 ops/sec ±0.96% (83 runs sampled) */ var typeofObj = typeof obj; if (typeofObj !== 'object') { return typeofObj; } /* ! Speed optimisation * Pre: * null x 28,645,765 ops/sec ±1.17% (82 runs sampled) * Post: * null x 36,428,962 ops/sec ±1.37% (84 runs sampled) */ if (obj === null) { return 'null'; } /* ! Spec Conformance * Test: `Object.prototype.toString.call(window)`` * - Node === "[object global]" * - Chrome === "[object global]" * - Firefox === "[object Window]" * - PhantomJS === "[object Window]" * - Safari === "[object Window]" * - IE 11 === "[object Window]" * - IE Edge === "[object Window]" * Test: `Object.prototype.toString.call(this)`` * - Chrome Worker === "[object global]" * - Firefox Worker === "[object DedicatedWorkerGlobalScope]" * - Safari Worker === "[object DedicatedWorkerGlobalScope]" * - IE 11 Worker === "[object WorkerGlobalScope]" * - IE Edge Worker === "[object WorkerGlobalScope]" */ if (obj === globalObject) { return 'global'; } /* ! Speed optimisation * Pre: * array literal x 2,888,352 ops/sec ±0.67% (82 runs sampled) * Post: * array literal x 22,479,650 ops/sec ±0.96% (81 runs sampled) */ if ( Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj)) ) { return 'Array'; } // Not caching existence of `window` and related properties due to potential // for `window` to be unset before tests in quasi-browser environments. if (typeof window === 'object' && window !== null) { /* ! Spec Conformance * (https://html.spec.whatwg.org/multipage/browsers.html#location) * WhatWG HTML$7.7.3 - The `Location` interface * Test: `Object.prototype.toString.call(window.location)`` * - IE <=11 === "[object Object]" * - IE Edge <=13 === "[object Object]" */ if (typeof window.location === 'object' && obj === window.location) { return 'Location'; } /* ! Spec Conformance * (https://html.spec.whatwg.org/#document) * WhatWG HTML$3.1.1 - The `Document` object * Note: Most browsers currently adher to the W3C DOM Level 2 spec * (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-26809268) * which suggests that browsers should use HTMLTableCellElement for * both TD and TH elements. WhatWG separates these. * WhatWG HTML states: * > For historical reasons, Window objects must also have a * > writable, configurable, non-enumerable property named * > HTMLDocument whose value is the Document interface object. * Test: `Object.prototype.toString.call(document)`` * - Chrome === "[object HTMLDocument]" * - Firefox === "[object HTMLDocument]" * - Safari === "[object HTMLDocument]" * - IE <=10 === "[object Document]" * - IE 11 === "[object HTMLDocument]" * - IE Edge <=13 === "[object HTMLDocument]" */ if (typeof window.document === 'object' && obj === window.document) { return 'Document'; } if (typeof window.navigator === 'object') { /* ! Spec Conformance * (https://html.spec.whatwg.org/multipage/webappapis.html#mimetypearray) * WhatWG HTML$8.6.1.5 - Plugins - Interface MimeTypeArray * Test: `Object.prototype.toString.call(navigator.mimeTypes)`` * - IE <=10 === "[object MSMimeTypesCollection]" */ if (typeof window.navigator.mimeTypes === 'object' && obj === window.navigator.mimeTypes) { return 'MimeTypeArray'; } /* ! Spec Conformance * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray) * WhatWG HTML$8.6.1.5 - Plugins - Interface PluginArray * Test: `Object.prototype.toString.call(navigator.plugins)`` * - IE <=10 === "[object MSPluginsCollection]" */ if (typeof window.navigator.plugins === 'object' && obj === window.navigator.plugins) { return 'PluginArray'; } } if ((typeof window.HTMLElement === 'function' || typeof window.HTMLElement === 'object') && obj instanceof window.HTMLElement) { /* ! Spec Conformance * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray) * WhatWG HTML$4.4.4 - The `blockquote` element - Interface `HTMLQuoteElement` * Test: `Object.prototype.toString.call(document.createElement('blockquote'))`` * - IE <=10 === "[object HTMLBlockElement]" */ if (obj.tagName === 'BLOCKQUOTE') { return 'HTMLQuoteElement'; } /* ! Spec Conformance * (https://html.spec.whatwg.org/#htmltabledatacellelement) * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableDataCellElement` * Note: Most browsers currently adher to the W3C DOM Level 2 spec * (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075) * which suggests that browsers should use HTMLTableCellElement for * both TD and TH elements. WhatWG separates these. * Test: Object.prototype.toString.call(document.createElement('td')) * - Chrome === "[object HTMLTableCellElement]" * - Firefox === "[object HTMLTableCellElement]" * - Safari === "[object HTMLTableCellElement]" */ if (obj.tagName === 'TD') { return 'HTMLTableDataCellElement'; } /* ! Spec Conformance * (https://html.spec.whatwg.org/#htmltableheadercellelement) * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableHeaderCellElement` * Note: Most browsers currently adher to the W3C DOM Level 2 spec * (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075) * which suggests that browsers should use HTMLTableCellElement for * both TD and TH elements. WhatWG separates these. * Test: Object.prototype.toString.call(document.createElement('th')) * - Chrome === "[object HTMLTableCellElement]" * - Firefox === "[object HTMLTableCellElement]" * - Safari === "[object HTMLTableCellElement]" */ if (obj.tagName === 'TH') { return 'HTMLTableHeaderCellElement'; } } } /* ! Speed optimisation * Pre: * Float64Array x 625,644 ops/sec ±1.58% (80 runs sampled) * Float32Array x 1,279,852 ops/sec ±2.91% (77 runs sampled) * Uint32Array x 1,178,185 ops/sec ±1.95% (83 runs sampled) * Uint16Array x 1,008,380 ops/sec ±2.25% (80 runs sampled) * Uint8Array x 1,128,040 ops/sec ±2.11% (81 runs sampled) * Int32Array x 1,170,119 ops/sec ±2.88% (80 runs sampled) * Int16Array x 1,176,348 ops/sec ±5.79% (86 runs sampled) * Int8Array x 1,058,707 ops/sec ±4.94% (77 runs sampled) * Uint8ClampedArray x 1,110,633 ops/sec ±4.20% (80 runs sampled) * Post: * Float64Array x 7,105,671 ops/sec ±13.47% (64 runs sampled) * Float32Array x 5,887,912 ops/sec ±1.46% (82 runs sampled) * Uint32Array x 6,491,661 ops/sec ±1.76% (79 runs sampled) * Uint16Array x 6,559,795 ops/sec ±1.67% (82 runs sampled) * Uint8Array x 6,463,966 ops/sec ±1.43% (85 runs sampled) * Int32Array x 5,641,841 ops/sec ±3.49% (81 runs sampled) * Int16Array x 6,583,511 ops/sec ±1.98% (80 runs sampled) * Int8Array x 6,606,078 ops/sec ±1.74% (81 runs sampled) * Uint8ClampedArray x 6,602,224 ops/sec ±1.77% (83 runs sampled) */ var stringTag = (symbolToStringTagExists && obj[Symbol.toStringTag]); if (typeof stringTag === 'string') { return stringTag; } var objPrototype = Object.getPrototypeOf(obj); /* ! Speed optimisation * Pre: * regex literal x 1,772,385 ops/sec ±1.85% (77 runs sampled) * regex constructor x 2,143,634 ops/sec ±2.46% (78 runs sampled) * Post: * regex literal x 3,928,009 ops/sec ±0.65% (78 runs sampled) * regex constructor x 3,931,108 ops/sec ±0.58% (84 runs sampled) */ if (objPrototype === RegExp.prototype) { return 'RegExp'; } /* ! Speed optimisation * Pre: * date x 2,130,074 ops/sec ±4.42% (68 runs sampled) * Post: * date x 3,953,779 ops/sec ±1.35% (77 runs sampled) */ if (objPrototype === Date.prototype) { return 'Date'; } /* ! Spec Conformance * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-promise.prototype-@@tostringtag) * ES6$25.4.5.4 - Promise.prototype[@@toStringTag] should be "Promise": * Test: `Object.prototype.toString.call(Promise.resolve())`` * - Chrome <=47 === "[object Object]" * - Edge <=20 === "[object Object]" * - Firefox 29-Latest === "[object Promise]" * - Safari 7.1-Latest === "[object Promise]" */ if (promiseExists && objPrototype === Promise.prototype) { return 'Promise'; } /* ! Speed optimisation * Pre: * set x 2,222,186 ops/sec ±1.31% (82 runs sampled) * Post: * set x 4,545,879 ops/sec ±1.13% (83 runs sampled) */ if (setExists && objPrototype === Set.prototype) { return 'Set'; } /* ! Speed optimisation * Pre: * map x 2,396,842 ops/sec ±1.59% (81 runs sampled) * Post: * map x 4,183,945 ops/sec ±6.59% (82 runs sampled) */ if (mapExists && objPrototype === Map.prototype) { return 'Map'; } /* ! Speed optimisation * Pre: * weakset x 1,323,220 ops/sec ±2.17% (76 runs sampled) * Post: * weakset x 4,237,510 ops/sec ±2.01% (77 runs sampled) */ if (weakSetExists && objPrototype === WeakSet.prototype) { return 'WeakSet'; } /* ! Speed optimisation * Pre: * weakmap x 1,500,260 ops/sec ±2.02% (78 runs sampled) * Post: * weakmap x 3,881,384 ops/sec ±1.45% (82 runs sampled) */ if (weakMapExists && objPrototype === WeakMap.prototype) { return 'WeakMap'; } /* ! Spec Conformance * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-dataview.prototype-@@tostringtag) * ES6$24.2.4.21 - DataView.prototype[@@toStringTag] should be "DataView": * Test: `Object.prototype.toString.call(new DataView(new ArrayBuffer(1)))`` * - Edge <=13 === "[object Object]" */ if (dataViewExists && objPrototype === DataView.prototype) { return 'DataView'; } /* ! Spec Conformance * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%mapiteratorprototype%-@@tostringtag) * ES6$23.1.5.2.2 - %MapIteratorPrototype%[@@toStringTag] should be "Map Iterator": * Test: `Object.prototype.toString.call(new Map().entries())`` * - Edge <=13 === "[object Object]" */ if (mapExists && objPrototype === mapIteratorPrototype) { return 'Map Iterator'; } /* ! Spec Conformance * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%setiteratorprototype%-@@tostringtag) * ES6$23.2.5.2.2 - %SetIteratorPrototype%[@@toStringTag] should be "Set Iterator": * Test: `Object.prototype.toString.call(new Set().entries())`` * - Edge <=13 === "[object Object]" */ if (setExists && objPrototype === setIteratorPrototype) { return 'Set Iterator'; } /* ! Spec Conformance * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%arrayiteratorprototype%-@@tostringtag) * ES6$22.1.5.2.2 - %ArrayIteratorPrototype%[@@toStringTag] should be "Array Iterator": * Test: `Object.prototype.toString.call([][Symbol.iterator]())`` * - Edge <=13 === "[object Object]" */ if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) { return 'Array Iterator'; } /* ! Spec Conformance * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%stringiteratorprototype%-@@tostringtag) * ES6$21.1.5.2.2 - %StringIteratorPrototype%[@@toStringTag] should be "String Iterator": * Test: `Object.prototype.toString.call(''[Symbol.iterator]())`` * - Edge <=13 === "[object Object]" */ if (stringIteratorExists && objPrototype === stringIteratorPrototype) { return 'String Iterator'; } /* ! Speed optimisation * Pre: * object from null x 2,424,320 ops/sec ±1.67% (76 runs sampled) * Post: * object from null x 5,838,000 ops/sec ±0.99% (84 runs sampled) */ if (objPrototype === null) { return 'Object'; } return Object .prototype .toString .call(obj) .slice(toStringLeftSliceLength, toStringRightSliceLength); } return typeDetect; }))); } (typeDetect)); var typeDetectExports = typeDetect.exports; var type = typeDetectExports; /** * Returns the lower-case result of running type from type-detect on the value * * @param {*} value * @returns {string} */ var typeOf = function typeOf(value) { return type(value).toLowerCase(); }; /** * Returns a string representation of the value * * @param {*} value * @returns {string} */ function valueToString(value) { if (value && value.toString) { // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods return value.toString(); } return String(value); } var valueToString_1 = valueToString; var lib = { global: global, calledInOrder: calledInOrder_1, className: className_1, deprecated: deprecated, every: every, functionName: functionName$1, orderByFirstCall: orderByFirstCall_1, prototypes: prototypes, typeOf: typeOf, valueToString: valueToString_1, }; const globalObject = lib.global; let timersModule; if (typeof __vitest_required__ !== 'undefined') { try { timersModule = __vitest_required__.timers; } catch (e) { // ignored } } /** * @typedef {object} IdleDeadline * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout * @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period */ /** * 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 * @returns {number} the id */ /** * @callback NextTick * @param {VoidVarArgsFunc} callback - the callback to run * @param {...*} arguments - 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 * @returns {NodeImmediate} */ /** * @callback VoidVarArgsFunc * @param {...*} callback - the callback to run * @returns {void} */ /** * @typedef RequestAnimationFrame * @property {function(number):void} requestAnimationFrame * @returns {number} - the id */ /** * @typedef Performance * @property {function(): number} now */ /* eslint-disable jsdoc/require-property-description */ /** * @typedef {object} Clock * @property {number} now - the current time * @property {Date} Date - the Date constructor * @property {number} loopLimit - the maximum number of timers before assuming an infinite loop * @property {RequestIdleCallback} requestIdleCallback * @property {function(number):void} cancelIdleCallback * @property {setTimeout} setTimeout * @property {clearTimeout} clearTimeout * @property {NextTick} nextTick * @property {queueMicrotask} queueMicrotask * @property {setInterval} setInterval * @property {clearInterval} clearInterval * @property {SetImmediate} setImmediate * @property {function(NodeImmediate):void} clearImmediate * @property {function():number} countTimers * @property {RequestAnimationFrame} requestAnimationFrame * @property {function(number):void} cancelAnimationFrame * @property {function():void} runMicrotasks * @property {function(string | number): number} tick * @property {function(string | number): Promise} tickAsync * @property {function(): number} next * @property {function(): Promise} nextAsync * @property {function(): number} runAll * @property {function(): number} runToFrame * @property {function(): Promise} runAllAsync * @property {function(): number} runToLast * @property {function(): Promise} runToLastAsync * @property {function(): void} reset * @property {function(number | Date): void} setSystemTime * @property {function(number): void} jump * @property {Performance} performance * @property {function(number[]): number[]} hrtime - process.hrtime (legacy) * @property {function(): void} uninstall Uninstall the clock. * @property {Function[]} methods - the methods that are faked * @property {boolean} [shouldClearNativeTimers] inherited from config * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods */ /* 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. * @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll() * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false) * @property {number} [advanceTimeDelta] increment mocked time every <> ms (default: 20ms) * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false) */ /* eslint-disable jsdoc/require-property-description */ /** * The internal structure to describe a scheduled fake timer * * @typedef {object} Timer * @property {Function} func * @property {*[]} args * @property {number} delay * @property {number} callAt * @property {number} createdAt * @property {boolean} immediate * @property {number} id * @property {Error} [error] */ /** * A Node timer * * @typedef {object} NodeImmediate * @property {function(): boolean} hasRef * @property {function(): NodeImmediate} ref * @property {function(): NodeImmediate} unref */ /* eslint-enable jsdoc/require-property-description */ /* eslint-disable complexity */ /** * Mocks available features in the specified global namespace. * * @param {*} _global Namespace to mock (e.g. `window`) * @returns {FakeTimers} */ function withGlobal(_global) { const maxTimeout = Math.pow(2, 31) - 1; //see https://heycam.github.io/webidl/#abstract-opdef-converttoint const idCounterStart = 1e12; // arbitrarily large number to avoid collisions with native timer IDs const NOOP = function () { return undefined; }; 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 utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify; const performancePresent = _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); const NativeDate = _global.Date; const NativeIntl = _global.Intl; let uniqueTimerId = idCounterStart; /** * @param {number} num * @returns {boolean} */ function isNumberFinite(num) { if (Number.isFinite) { return Number.isFinite(num); } return isFinite(num); } let isNearInfiniteLimit = false; /** * @param {Clock} clock * @param {number} i */ function checkIsNearInfiniteLimit(clock, i) { if (clock.loopLimit && i === clock.loopLimit - 1) { isNearInfiniteLimit = true; } } /** * */ function resetIsNearInfiniteLimit() { isNearInfiniteLimit = false; } /** * 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} */ function parseTime(str) { if (!str) { return 0; } const strings = str.split(":"); const l = strings.length; let i = l; let ms = 0; let parsed; 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" ); } while (i--) { parsed = parseInt(strings[i], 10); if (parsed >= 60) { throw new Error(`Invalid time ${str}`); } ms += parsed * Math.pow(60, l - i - 1); } return ms * 1000; } /** * 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) * * Example: nanoRemainer(123.456789) -> 456789 */ function nanoRemainder(msFloat) { const modulo = 1e6; const remainder = (msFloat * 1e6) % modulo; const positiveRemainder = remainder < 0 ? remainder + modulo : remainder; return Math.floor(positiveRemainder); } /** * Used to grok the `now` parameter to createClock. * * @param {Date|number} epoch the system time * @returns {number} */ function getEpoch(epoch) { if (!epoch) { return 0; } if (typeof epoch.getTime === "function") { return epoch.getTime(); } if (typeof epoch === "number") { return epoch; } throw new TypeError("now should be milliseconds since UNIX epoch"); } /** * @param {number} from * @param {number} to * @param {Timer} timer * @returns {boolean} */ function inRange(from, to, timer) { return timer && timer.callAt >= from && timer.callAt <= to; } /** * @param {Clock} clock * @param {Timer} job */ function getInfiniteLoopError(clock, job) { const infiniteLoopError = new Error( `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!` ); if (!job.error) { return infiniteLoopError; } // pattern never matched in Node const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/; let clockMethodPattern = new RegExp( String(Object.keys(clock).join("|")) ); if (addTimerReturnsObject) { // node.js environment clockMethodPattern = new RegExp( `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+` ); } let matchedLineIndex = -1; job.error.stack.split("\n").some(function (line, i) { // If we've matched a computed target line (e.g. setTimeout) then we // don't need to look any further. Return true to stop iterating. const matchedComputedTarget = line.match(computedTargetPattern); /* istanbul ignore if */ if (matchedComputedTarget) { matchedLineIndex = i; return true; } // If we've matched a clock method line, then there may still be // others further down the trace. Return false to keep iterating. const matchedClockMethod = line.match(clockMethodPattern); if (matchedClockMethod) { matchedLineIndex = i; return false; } // If we haven't matched anything on this line, but we matched // previously and set the matched line index, then we can stop. // If we haven't matched previously, then we should keep iterating. return matchedLineIndex >= 0; }); const stack = `${infiniteLoopError}\n${job.type || "Microtask"} - ${ job.func.name || "anonymous" }\n${job.error.stack .split("\n") .slice(matchedLineIndex + 1) .join("\n")}`; try { Object.defineProperty(infiniteLoopError, "stack", { value: stack, }); } catch (e) { // noop } 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]; } } // set special now implementation if (source.now) { target.now = function now() { return target.clock.now; }; } else { delete target.now; } // set special toSource implementation if (source.toSource) { target.toSource = function toSource() { return source.toSource(); }; } else { delete target.toSource; } // set special toString implementation target.toString = function toString() { return source.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() { /** * @param {number} year * @param {number} month * @param {number} date * @param {number} hour * @param {number} minute * @param {number} second * @param {number} ms * @returns {Date} */ 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 ); } } return mirrorDateProperties(ClockDate, NativeDate); } //eslint-disable-next-line jsdoc/require-jsdoc function createIntl() { const ClockIntl = { ...NativeIntl }; ClockIntl.DateTimeFormat = function (...args) { const realFormatter = new NativeIntl.DateTimeFormat(...args); const formatter = {}; ["formatRange", "formatRangeToParts", "resolvedOptions"].forEach( (method) => { formatter[method] = realFormatter[method].bind(realFormatter); } ); ["format", "formatToParts"].forEach((method) => { formatter[method] = function (date) { return realFormatter[method](date || ClockIntl.clock.now); }; }); return formatter; }; ClockIntl.DateTimeFormat.prototype = Object.create( NativeIntl.DateTimeFormat.prototype ); ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf; return ClockIntl; } //eslint-disable-next-line jsdoc/require-jsdoc function enqueueJob(clock, job) { // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob if (!clock.jobs) { clock.jobs = []; } clock.jobs.push(job); } //eslint-disable-next-line jsdoc/require-jsdoc function runJobs(clock) { // runs all microtick-deferred tasks - ecma262/#sec-runjobs if (!clock.jobs) { return; } for (let i = 0; i < clock.jobs.length; i++) { const job = clock.jobs[i]; job.func.apply(null, job.args); checkIsNearInfiniteLimit(clock, i); if (clock.loopLimit && i > clock.loopLimit) { throw getInfiniteLoopError(clock, job); } } resetIsNearInfiniteLimit(); clock.jobs = []; } /** * @param {Clock} clock * @param {Timer} timer * @returns {number} id of the created timer */ function addTimer(clock, timer) { if (timer.func === undefined) { throw new Error("Callback must be provided to timer calls"); } if (addTimerReturnsObject) { // Node.js environment if (typeof timer.func !== "function") { throw new TypeError( `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${ timer.func } of type ${typeof timer.func}` ); } } if (isNearInfiniteLimit) { timer.error = new Error(); } timer.type = timer.immediate ? "Immediate" : "Timeout"; if (timer.hasOwnProperty("delay")) { if (typeof timer.delay !== "number") { timer.delay = parseInt(timer.delay, 10); } if (!isNumberFinite(timer.delay)) { timer.delay = 0; } timer.delay = timer.delay > maxTimeout ? 1 : timer.delay; timer.delay = Math.max(0, timer.delay); } if (timer.hasOwnProperty("interval")) { timer.type = "Interval"; timer.interval = timer.interval > maxTimeout ? 1 : timer.interval; } if (timer.hasOwnProperty("animation")) { timer.type = "AnimationFrame"; timer.animation = true; } if (timer.hasOwnProperty("idleCallback")) { timer.type = "IdleCallback"; timer.idleCallback = true; } if (!clock.timers) { clock.timers = {}; } timer.id = uniqueTimerId++; timer.createdAt = clock.now; timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0)); clock.timers[timer.id] = timer; if (addTimerReturnsObject) { const res = { refed: true, ref: function () { this.refed = true; return res; }, unref: function () { this.refed = false; return res; }, hasRef: function () { return this.refed; }, refresh: function () { timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0)); // it _might_ have been removed, but if not the assignment is perfectly fine clock.timers[timer.id] = timer; return res; }, [Symbol.toPrimitive]: function () { return timer.id; }, }; return res; } return timer.id; } /* eslint consistent-return: "off" */ /** * Timer comparitor * * @param {Timer} a * @param {Timer} b * @returns {number} */ function compareTimers(a, b) { // Sort first by absolute timing if (a.callAt < b.callAt) { return -1; } if (a.callAt > b.callAt) { return 1; } // Sort next by immediate, immediate timers take precedence if (a.immediate && !b.immediate) { return -1; } if (!a.immediate && b.immediate) { return 1; } // Sort next by creation time, earlier-created timers take precedence if (a.createdAt < b.createdAt) { return -1; } if (a.createdAt > b.createdAt) { return 1; } // Sort next by id, lower-id timers take precedence if (a.id < b.id) { return -1; } if (a.id > b.id) { return 1; } // As timer ids are unique, no fallback `0` is necessary } /** * @param {Clock} clock * @param {number} from * @param {number} to * @returns {Timer} */ function firstTimerInRange(clock, from, to) { const timers = clock.timers; let timer = null; let id, isInRange; for (id in timers) { if (timers.hasOwnProperty(id)) { isInRange = inRange(from, to, timers[id]); if ( isInRange && (!timer || compareTimers(timer, timers[id]) === 1) ) { timer = timers[id]; } } } return timer; } /** * @param {Clock} clock * @returns {Timer} */ function firstTimer(clock) { const timers = clock.timers; let timer = null; let id; for (id in timers) { if (timers.hasOwnProperty(id)) { if (!timer || compareTimers(timer, timers[id]) === 1) { timer = timers[id]; } } } return timer; } /** * @param {Clock} clock * @returns {Timer} */ function lastTimer(clock) { const timers = clock.timers; let timer = null; let id; for (id in timers) { if (timers.hasOwnProperty(id)) { if (!timer || compareTimers(timer, timers[id]) === -1) { timer = timers[id]; } } } return timer; } /** * @param {Clock} clock * @param {Timer} timer */ function callTimer(clock, timer) { if (typeof timer.interval === "number") { clock.timers[timer.id].callAt += timer.interval; } else { delete clock.timers[timer.id]; } if (typeof timer.func === "function") { timer.func.apply(null, timer.args); } else { /* eslint no-eval: "off" */ const eval2 = eval; (function () { eval2(timer.func); })(); } } /** * Gets clear handler name for a given timer type * * @param {string} ttype */ function getClearHandler(ttype) { if (ttype === "IdleCallback" || ttype === "AnimationFrame") { return `cancel${ttype}`; } return `clear${ttype}`; } /** * Gets schedule handler name for a given timer type * * @param {string} ttype */ function getScheduleHandler(ttype) { if (ttype === "IdleCallback" || ttype === "AnimationFrame") { return `request${ttype}`; } return `set${ttype}`; } /** * Creates an anonymous function to warn only once */ function createWarnOnce() { let calls = 0; return function (msg) { // eslint-disable-next-line !calls++ && console.warn(msg); }; } const warnOnce = createWarnOnce(); /** * @param {Clock} clock * @param {number} timerId * @param {string} ttype */ function clearTimer(clock, timerId, ttype) { if (!timerId) { // null appears to be allowed in most browsers, and appears to be // relied upon by some libraries, like Bootstrap carousel return; } if (!clock.timers) { clock.timers = {}; } // in Node, the ID is stored as the primitive value for `Timeout` objects // for `Immediate` objects, no ID exists, so it gets coerced to NaN const id = Number(timerId); if (Number.isNaN(id) || id < idCounterStart) { const handlerName = getClearHandler(ttype); if (clock.shouldClearNativeTimers === true) { const nativeHandler = clock[`_${handlerName}`]; return typeof nativeHandler === "function" ? nativeHandler(timerId) : undefined; } 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`." ); } if (clock.timers.hasOwnProperty(id)) { // check that the ID matches a timer of the correct type const timer = clock.timers[id]; if ( timer.type === ttype || (timer.type === "Timeout" && ttype === "Interval") || (timer.type === "Interval" && ttype === "Timeout") ) { delete clock.timers[id]; } else { const clear = getClearHandler(ttype); const schedule = getScheduleHandler(timer.type); throw new Error( `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()` ); } } } /** * @param {Clock} clock * @param {Config} config * @returns {Timer[]} */ function uninstall(clock, config) { let method, i, l; const installedHrTime = "_hrtime"; const installedNextTick = "_nextTick"; for (i = 0, l = clock.methods.length; i < l; i++) { method = clock.methods[i]; if (method === "hrtime" && _global.process) { _global.process.hrtime = clock[installedHrTime]; } else if (method === "nextTick" && _global.process) { _global.process.nextTick = clock[installedNextTick]; } else if (method === "performance") { const originalPerfDescriptor = Object.getOwnPropertyDescriptor( clock, `_${method}` ); if ( originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set ) { Object.defineProperty( _global, method, originalPerfDescriptor ); } else if (originalPerfDescriptor.configurable) { _global[method] = clock[`_${method}`]; } } else { if (_global[method] && _global[method].hadOwnProperty) { _global[method] = clock[`_${method}`]; } else { try { delete _global[method]; } catch (ignore) { /* eslint no-empty: "off" */ } } } if (clock.timersModuleMethods !== undefined) { for (let j = 0; j < clock.timersModuleMethods.length; j++) { const entry = clock.timersModuleMethods[j]; timersModule[entry.methodName] = entry.original; } } } if (config.shouldAdvanceTime === true) { _global.clearInterval(clock.attachedInterval); } // Prevent multiple executions which will completely remove these props clock.methods = []; // return pending timers, to enable checking what timers remained on uninstall if (!clock.timers) { return []; } return Object.keys(clock.timers).map(function mapper(key) { return clock.timers[key]; }); } /** * @param {object} target the target containing the method to replace * @param {string} method the keyname of the method on the target * @param {Clock} clock */ function hijackMethod(target, method, clock) { clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call( target, method ); clock[`_${method}`] = target[method]; if (method === "Date") { const date = mirrorDateProperties(clock[method], target[method]); target[method] = date; } else if (method === "Intl") { target[method] = clock[method]; } else if (method === "performance") { const originalPerfDescriptor = Object.getOwnPropertyDescriptor( target, method ); // JSDOM has a read only performance field so we have to save/copy it differently if ( originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set ) { Object.defineProperty( clock, `_${method}`, originalPerfDescriptor ); const perfDescriptor = Object.getOwnPropertyDescriptor( clock, method ); Object.defineProperty(target, method, perfDescriptor); } else { target[method] = clock[method]; } } else { target[method] = function () { return clock[method].apply(clock, arguments); }; Object.defineProperties( target[method], Object.getOwnPropertyDescriptors(clock[method]) ); } target[method].clock = clock; } /** * @param {Clock} clock * @param {number} advanceTimeDelta */ function doIntervalTick(clock, advanceTimeDelta) { clock.tick(advanceTimeDelta); } /** * @typedef {object} Timers * @property {setTimeout} setTimeout * @property {clearTimeout} clearTimeout * @property {setInterval} setInterval * @property {clearInterval} clearInterval * @property {Date} Date * @property {Intl} Intl * @property {SetImmediate=} setImmediate * @property {function(NodeImmediate): void=} clearImmediate * @property {function(number[]):number[]=} hrtime * @property {NextTick=} nextTick * @property {Performance=} performance * @property {RequestAnimationFrame=} requestAnimationFrame * @property {boolean=} queueMicrotask * @property {function(number): void=} cancelAnimationFrame * @property {RequestIdleCallback=} requestIdleCallback * @property {function(number): void=} cancelIdleCallback */ /** @type {Timers} */ const timers = { setTimeout: _global.setTimeout, clearTimeout: _global.clearTimeout, setInterval: _global.setInterval, clearInterval: _global.clearInterval, Date: _global.Date, }; if (setImmediatePresent) { timers.setImmediate = _global.setImmediate; timers.clearImmediate = _global.clearImmediate; } if (hrtimePresent) { timers.hrtime = _global.process.hrtime; } if (nextTickPresent) { timers.nextTick = _global.process.nextTick; } if (performancePresent) { timers.performance = _global.performance; } if (requestAnimationFramePresent) { timers.requestAnimationFrame = _global.requestAnimationFrame; } if (queueMicrotaskPresent) { timers.queueMicrotask = true; } if (cancelAnimationFramePresent) { timers.cancelAnimationFrame = _global.cancelAnimationFrame; } if (requestIdleCallbackPresent) { timers.requestIdleCallback = _global.requestIdleCallback; } if (cancelIdleCallbackPresent) { timers.cancelIdleCallback = _global.cancelIdleCallback; } if (intlPresent) { timers.Intl = _global.Intl; } const originalSetTimeout = _global.setImmediate || _global.setTimeout; /** * @param {Date|number} [start] the system time - non-integer values are floored * @param {number} [loopLimit] maximum number of timers that will be run when calling runAll() * @returns {Clock} */ function createClock(start, loopLimit) { // eslint-disable-next-line no-param-reassign start = Math.floor(getEpoch(start)); // eslint-disable-next-line no-param-reassign loopLimit = loopLimit || 1000; 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(), loopLimit: loopLimit, }; clock.Date.clock = clock; //eslint-disable-next-line jsdoc/require-jsdoc function getTimeToNextFrame() { return 16 - ((clock.now - start) % 16); } //eslint-disable-next-line jsdoc/require-jsdoc function hrtime(prev) { const millisSinceStart = clock.now - adjustedSystemTime[0] - start; const secsSinceStart = Math.floor(millisSinceStart / 1000); const remainderInNanos = (millisSinceStart - secsSinceStart * 1e3) * 1e6 + nanos - adjustedSystemTime[1]; if (Array.isArray(prev)) { if (prev[1] > 1e9) { throw new TypeError( "Number of nanoseconds can't exceed a billion" ); } const oldSecs = prev[0]; let nanoDiff = remainderInNanos - prev[1]; let secDiff = secsSinceStart - oldSecs; if (nanoDiff < 0) { nanoDiff += 1e9; secDiff -= 1; } return [secDiff, nanoDiff]; } return [secsSinceStart, remainderInNanos]; } function fakePerformanceNow() { const hrt = hrtime(); const millis = hrt[0] * 1000 + hrt[1] / 1e6; return millis; } if (hrtimeBigintPresent) { hrtime.bigint = function () { const parts = hrtime(); return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line }; } if (intlPresent) { clock.Intl = createIntl(); clock.Intl.clock = clock; } clock.requestIdleCallback = function requestIdleCallback( func, timeout ) { let timeToNextIdlePeriod = 0; if (clock.countTimers() > 0) { timeToNextIdlePeriod = 50; // const for now } const result = addTimer(clock, { func: func, args: Array.prototype.slice.call(arguments, 2), delay: typeof timeout === "undefined" ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod), idleCallback: true, }); return Number(result); }; clock.cancelIdleCallback = function cancelIdleCallback(timerId) { return clearTimer(clock, timerId, "IdleCallback"); }; clock.setTimeout = function setTimeout(func, timeout) { return addTimer(clock, { func: func, args: Array.prototype.slice.call(arguments, 2), delay: timeout, }); }; if (typeof _global.Promise !== "undefined" && utilPromisify) { clock.setTimeout[utilPromisify.custom] = function promisifiedSetTimeout(timeout, arg) { return new _global.Promise(function setTimeoutExecutor( resolve ) { addTimer(clock, { func: resolve, args: [arg], delay: timeout, }); }); }; } clock.clearTimeout = function clearTimeout(timerId) { return clearTimer(clock, timerId, "Timeout"); }; clock.nextTick = function nextTick(func) { return enqueueJob(clock, { func: func, args: Array.prototype.slice.call(arguments, 1), error: isNearInfiniteLimit ? new Error() : null, }); }; clock.queueMicrotask = function queueMicrotask(func) { return clock.nextTick(func); // explicitly drop additional arguments }; clock.setInterval = function setInterval(func, timeout) { // eslint-disable-next-line no-param-reassign timeout = parseInt(timeout, 10); return addTimer(clock, { func: func, args: Array.prototype.slice.call(arguments, 2), delay: timeout, interval: timeout, }); }; clock.clearInterval = function clearInterval(timerId) { return clearTimer(clock, timerId, "Interval"); }; if (setImmediatePresent) { clock.setImmediate = function setImmediate(func) { return addTimer(clock, { func: func, args: Array.prototype.slice.call(arguments, 1), immediate: true, }); }; if (typeof _global.Promise !== "undefined" && utilPromisify) { clock.setImmediate[utilPromisify.custom] = function promisifiedSetImmediate(arg) { return new _global.Promise( function setImmediateExecutor(resolve) { addTimer(clock, { func: resolve, args: [arg], immediate: true, }); } ); }; } clock.clearImmediate = function clearImmediate(timerId) { return clearTimer(clock, timerId, "Immediate"); }; } clock.countTimers = function countTimers() { return ( Object.keys(clock.timers || {}).length + (clock.jobs || []).length ); }; clock.requestAnimationFrame = function requestAnimationFrame(func) { const result = addTimer(clock, { func: func, delay: getTimeToNextFrame(), get args() { return [fakePerformanceNow()]; }, animation: true, }); return Number(result); }; clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) { return clearTimer(clock, timerId, "AnimationFrame"); }; clock.runMicrotasks = function runMicrotasks() { runJobs(clock); }; /** * @param {number|string} tickValue milliseconds or a string parseable by parseTime * @param {boolean} isAsync * @param {Function} resolve * @param {Function} reject * @returns {number|undefined} will return the new `now` value or nothing for async */ function doTick(tickValue, isAsync, resolve, reject) { const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue); const ms = Math.floor(msFloat); const remainder = nanoRemainder(msFloat); let nanosTotal = nanos + remainder; let tickTo = clock.now + ms; if (msFloat < 0) { throw new TypeError("Negative ticks are not supported"); } // adjust for positive overflow if (nanosTotal >= 1e6) { tickTo += 1; nanosTotal -= 1e6; } nanos = nanosTotal; let tickFrom = clock.now; let previous = clock.now; // ESLint fails to detect this correctly /* eslint-disable prefer-const */ let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall; /* eslint-enable prefer-const */ clock.duringTick = true; // perform microtasks oldNow = clock.now; runJobs(clock); if (oldNow !== clock.now) { // compensate for any setSystemTime() call during microtask callback tickFrom += clock.now - oldNow; tickTo += clock.now - oldNow; } //eslint-disable-next-line jsdoc/require-jsdoc function doTickInner() { // perform each timer in the requested range timer = firstTimerInRange(clock, tickFrom, tickTo); // eslint-disable-next-line no-unmodified-loop-condition while (timer && tickFrom <= tickTo) { if (clock.timers[timer.id]) { tickFrom = timer.callAt; clock.now = timer.callAt; oldNow = clock.now; try { runJobs(clock); callTimer(clock, timer); } catch (e) { firstException = firstException || e; } if (isAsync) { // finish up after native setImmediate callback to allow // all native es6 promises to process their callbacks after // each timer fires. originalSetTimeout(nextPromiseTick); return; } compensationCheck(); } postTimerCall(); } // perform process.nextTick()s again oldNow = clock.now; runJobs(clock); if (oldNow !== clock.now) { // compensate for any setSystemTime() call during process.nextTick() callback tickFrom += clock.now - oldNow; tickTo += clock.now - oldNow; } clock.duringTick = false; // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo] timer = firstTimerInRange(clock, tickFrom, tickTo); if (timer) { try { clock.tick(tickTo - clock.now); // do it all again - for the remainder of the requested range } catch (e) { firstException = firstException || e; } } else { // no timers remaining in the requested range: move the clock all the way to the end clock.now = tickTo; // update nanos nanos = nanosTotal; } if (firstException) { throw firstException; } if (isAsync) { resolve(clock.now); } else { return clock.now; } } nextPromiseTick = isAsync && function () { try { compensationCheck(); postTimerCall(); doTickInner(); } catch (e) { reject(e); } }; compensationCheck = function () { // compensate for any setSystemTime() call during timer callback if (oldNow !== clock.now) { tickFrom += clock.now - oldNow; tickTo += clock.now - oldNow; previous += clock.now - oldNow; } }; postTimerCall = function () { timer = firstTimerInRange(clock, previous, tickTo); previous = tickFrom; }; return doTickInner(); } /** * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15" * @returns {number} will return the new `now` value */ clock.tick = function tick(tickValue) { return doTick(tickValue, false); }; if (typeof _global.Promise !== "undefined") { /** * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15" * @returns {Promise} */ clock.tickAsync = function tickAsync(tickValue) { return new _global.Promise(function (resolve, reject) { originalSetTimeout(function () { try { doTick(tickValue, true, resolve, reject); } catch (e) { reject(e); } }); }); }; } clock.next = function next() { runJobs(clock); const timer = firstTimer(clock); if (!timer) { return clock.now; } clock.duringTick = true; try { clock.now = timer.callAt; callTimer(clock, timer); runJobs(clock); return clock.now; } finally { clock.duringTick = false; } }; if (typeof _global.Promise !== "undefined") { clock.nextAsync = function nextAsync() { return new _global.Promise(function (resolve, reject) { originalSetTimeout(function () { try { const timer = firstTimer(clock); if (!timer) { resolve(clock.now); return; } let err; clock.duringTick = true; clock.now = timer.callAt; try { callTimer(clock, timer); } catch (e) { err = e; } clock.duringTick = false; originalSetTimeout(function () { if (err) { reject(err); } else { resolve(clock.now); } }); } catch (e) { reject(e); } }); }); }; } clock.runAll = function runAll() { let numTimers, i; runJobs(clock); for (i = 0; i < clock.loopLimit; i++) { if (!clock.timers) { resetIsNearInfiniteLimit(); return clock.now; } numTimers = Object.keys(clock.timers).length; if (numTimers === 0) { resetIsNearInfiniteLimit(); return clock.now; } clock.next(); checkIsNearInfiniteLimit(clock, i); } const excessJob = firstTimer(clock); throw getInfiniteLoopError(clock, excessJob); }; clock.runToFrame = function runToFrame() { return clock.tick(getTimeToNextFrame()); }; if (typeof _global.Promise !== "undefined") { clock.runAllAsync = function runAllAsync() { return new _global.Promise(function (resolve, reject) { let i = 0; /** * */ function doRun() { originalSetTimeout(function () { try { let numTimers; if (i < clock.loopLimit) { if (!clock.timers) { resetIsNearInfiniteLimit(); resolve(clock.now); return; } numTimers = Object.keys( clock.timers ).length; if (numTimers === 0) { resetIsNearInfiniteLimit(); resolve(clock.now); return; } clock.next(); i++; doRun(); checkIsNearInfiniteLimit(clock, i); return; } const excessJob = firstTimer(clock); reject(getInfiniteLoopError(clock, excessJob)); } catch (e) { reject(e); } }); } doRun(); }); }; } clock.runToLast = function runToLast() { const timer = lastTimer(clock); if (!timer) { runJobs(clock); return clock.now; } return clock.tick(timer.callAt - clock.now); }; if (typeof _global.Promise !== "undefined") { clock.runToLastAsync = function runToLastAsync() { return new _global.Promise(function (resolve, reject) { originalSetTimeout(function () { try { const timer = lastTimer(clock); if (!timer) { resolve(clock.now); } resolve(clock.tickAsync(timer.callAt - clock.now)); } catch (e) { reject(e); } }); }); }; } clock.reset = function reset() { nanos = 0; clock.timers = {}; clock.jobs = []; clock.now = start; }; clock.setSystemTime = function setSystemTime(systemTime) { // determine time difference const newNow = getEpoch(systemTime); const difference = newNow - clock.now; let id, timer; adjustedSystemTime[0] = adjustedSystemTime[0] + difference; adjustedSystemTime[1] = adjustedSystemTime[1] + nanos; // update 'system clock' clock.now = newNow; nanos = 0; // update timers and intervals to keep them stable for (id in clock.timers) { if (clock.timers.hasOwnProperty(id)) { timer = clock.timers[id]; timer.createdAt += difference; timer.callAt += difference; } } }; /** * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15" * @returns {number} will return the new `now` value */ clock.jump = function jump(tickValue) { const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue); const ms = Math.floor(msFloat); for (const timer of Object.values(clock.timers)) { if (clock.now + ms > timer.callAt) { timer.callAt = clock.now + ms; } } clock.tick(ms); }; if (performancePresent) { clock.performance = Object.create(null); clock.performance.now = fakePerformanceNow; } if (hrtimePresent) { clock.hrtime = hrtime; } return clock; } /* eslint-disable complexity */ /** * @param {Config=} [config] Optional config * @returns {Clock} */ function install(config) { if ( arguments.length > 1 || config instanceof Date || Array.isArray(config) || typeof config === "number" ) { throw new TypeError( `FakeTimers.install called with ${String( config )} install requires an object parameter` ); } if (_global.Date.isFake === true) { // 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." ); } // eslint-disable-next-line no-param-reassign config = typeof config !== "undefined" ? config : {}; config.shouldAdvanceTime = config.shouldAdvanceTime || false; config.advanceTimeDelta = config.advanceTimeDelta || 20; config.shouldClearNativeTimers = config.shouldClearNativeTimers || false; if (config.target) { throw new TypeError( "config.target is no longer supported. Use `withGlobal(target)` instead." ); } let i, l; const clock = createClock(config.now, config.loopLimit); clock.shouldClearNativeTimers = config.shouldClearNativeTimers; clock.uninstall = function () { return uninstall(clock, config); }; 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"; }); } if (config.shouldAdvanceTime === true) { const intervalTick = doIntervalTick.bind( null, clock, config.advanceTimeDelta ); const intervalId = _global.setInterval( intervalTick, config.advanceTimeDelta ); clock.attachedInterval = intervalId; } if (clock.methods.includes("performance")) { const proto = (() => { if (hasPerformanceConstructorPrototype) { return _global.performance.constructor.prototype; } if (hasPerformancePrototype) { return _global.Performance.prototype; } })(); if (proto) { Object.getOwnPropertyNames(proto).forEach(function (name) { if (name !== "now") { clock.performance[name] = name.indexOf("getEntries") === 0 ? NOOP_ARRAY : NOOP; } }); } 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" ); } } if (_global === globalObject && timersModule) { clock.timersModuleMethods = []; } for (i = 0, l = clock.methods.length; i < l; i++) { const nameOfMethodToReplace = clock.methods[i]; if (nameOfMethodToReplace === "hrtime") { if ( _global.process && typeof _global.process.hrtime === "function" ) { hijackMethod(_global.process, nameOfMethodToReplace, clock); } } else if (nameOfMethodToReplace === "nextTick") { if ( _global.process && typeof _global.process.nextTick === "function" ) { hijackMethod(_global.process, nameOfMethodToReplace, clock); } } else { hijackMethod(_global, nameOfMethodToReplace, clock); } if ( clock.timersModuleMethods !== undefined && timersModule[nameOfMethodToReplace] ) { const original = timersModule[nameOfMethodToReplace]; clock.timersModuleMethods.push({ methodName: nameOfMethodToReplace, original: original, }); timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace]; } } return clock; } /* eslint-enable complexity */ return { timers: timers, createClock: createClock, install: install, withGlobal: withGlobal, }; } /** * @typedef {object} FakeTimers * @property {Timers} timers * @property {createClock} createClock * @property {Function} install * @property {withGlobal} withGlobal */ /* eslint-enable complexity */ /** @type {FakeTimers} */ const defaultImplementation = withGlobal(globalObject); defaultImplementation.timers; defaultImplementation.createClock; defaultImplementation.install; var withGlobal_1 = withGlobal; class FakeTimers { _global; _clock; _fakingTime; _fakingDate; _fakeTimers; _userConfig; _now = RealDate.now; constructor({ global, config }) { this._userConfig = config; this._fakingDate = false; this._fakingTime = false; this._fakeTimers = withGlobal_1(global); this._global = global; } clearAllTimers() { if (this._fakingTime) this._clock.reset(); } dispose() { this.useRealTimers(); } runAllTimers() { if (this._checkFakeTimers()) this._clock.runAll(); } async runAllTimersAsync() { if (this._checkFakeTimers()) await this._clock.runAllAsync(); } runOnlyPendingTimers() { if (this._checkFakeTimers()) this._clock.runToLast(); } async runOnlyPendingTimersAsync() { if (this._checkFakeTimers()) await this._clock.runToLastAsync(); } advanceTimersToNextTimer(steps = 1) { if (this._checkFakeTimers()) { for (let i = steps; i > 0; i--) { this._clock.next(); this._clock.tick(0); if (this._clock.countTimers() === 0) break; } } } async advanceTimersToNextTimerAsync(steps = 1) { if (this._checkFakeTimers()) { for (let i = steps; i > 0; i--) { await this._clock.nextAsync(); this._clock.tick(0); if (this._clock.countTimers() === 0) break; } } } advanceTimersByTime(msToRun) { if (this._checkFakeTimers()) this._clock.tick(msToRun); } async advanceTimersByTimeAsync(msToRun) { if (this._checkFakeTimers()) await this._clock.tickAsync(msToRun); } runAllTicks() { if (this._checkFakeTimers()) { this._clock.runMicrotasks(); } } useRealTimers() { if (this._fakingDate) { resetDate(); this._fakingDate = false; } if (this._fakingTime) { this._clock.uninstall(); this._fakingTime = false; } } useFakeTimers() { var _a, _b, _c; if (this._fakingDate) { throw new Error( '"setSystemTime" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.' ); } if (!this._fakingTime) { const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick"); if (((_b = (_a = this._userConfig) == null ? void 0 : _a.toFake) == null ? void 0 : _b.includes("nextTick")) && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process"); const existingFakedMethods = (((_c = this._userConfig) == null ? void 0 : _c.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 }); this._fakingTime = true; } } reset() { if (this._checkFakeTimers()) { const { now } = this._clock; this._clock.reset(); this._clock.setSystemTime(now); } } setSystemTime(now) { if (this._fakingTime) { this._clock.setSystemTime(now); } else { mockDate(now ?? this.getRealSystemTime()); this._fakingDate = true; } } getRealSystemTime() { return this._now(); } getTimerCount() { if (this._checkFakeTimers()) return this._clock.countTimers(); return 0; } configure(config) { this._userConfig = config; } isFakeTimers() { return this._fakingTime; } _checkFakeTimers() { if (!this._fakingTime) { throw new Error( 'Timers are not mocked. Try calling "vi.useFakeTimers()" first.' ); } return this._fakingTime; } } function copyStackTrace(target, source) { if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message); return target; } function waitFor(callback, options = {}) { const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers(); const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options; const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR"); return new Promise((resolve, reject) => { let lastError; let promiseStatus = "idle"; let timeoutId; let intervalId; const onResolve = (result) => { if (timeoutId) clearTimeout(timeoutId); if (intervalId) clearInterval(intervalId); resolve(result); }; const handleTimeout = () => { let error = lastError; if (!error) error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR); reject(error); }; const checkCallback = () => { if (vi.isFakeTimers()) vi.advanceTimersByTime(interval); if (promiseStatus === "pending") return; try { const result = callback(); if (result !== null && typeof result === "object" && typeof result.then === "function") { const thenable = result; promiseStatus = "pending"; thenable.then( (resolvedValue) => { promiseStatus = "resolved"; onResolve(resolvedValue); }, (rejectedValue) => { promiseStatus = "rejected"; lastError = rejectedValue; } ); } else { onResolve(result); return true; } } catch (error) { lastError = error; } }; if (checkCallback() === true) return; timeoutId = setTimeout(handleTimeout, timeout); intervalId = setInterval(checkCallback, interval); }); } function waitUntil(callback, options = {}) { const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers(); const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options; const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR"); return new Promise((resolve, reject) => { let promiseStatus = "idle"; let timeoutId; let intervalId; const onReject = (error) => { if (!error) error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR); reject(error); }; const onResolve = (result) => { if (!result) return; if (timeoutId) clearTimeout(timeoutId); if (intervalId) clearInterval(intervalId); resolve(result); return true; }; const checkCallback = () => { if (vi.isFakeTimers()) vi.advanceTimersByTime(interval); if (promiseStatus === "pending") return; try { const result = callback(); if (result !== null && typeof result === "object" && typeof result.then === "function") { const thenable = result; promiseStatus = "pending"; thenable.then( (resolvedValue) => { promiseStatus = "resolved"; onResolve(resolvedValue); }, (rejectedValue) => { promiseStatus = "rejected"; onReject(rejectedValue); } ); } else { return onResolve(result); } } catch (error) { onReject(error); } }; if (checkCallback() === true) return; timeoutId = setTimeout(onReject, timeout); intervalId = setInterval(checkCallback, interval); }); } function createVitest() { const _mocker = typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) { throw new Error( `Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.` ); } }); let _mockedDate = null; let _config = null; const workerState = getWorkerState(); const _timers = new FakeTimers({ global: globalThis, config: workerState.config.fakeTimers }); const _stubsGlobal = /* @__PURE__ */ new Map(); const _stubsEnv = /* @__PURE__ */ new Map(); const getImporter = () => { const stackTrace = createSimpleStackTrace({ stackTraceLimit: 4 }); const importerStack = stackTrace.split("\n")[4]; const stack = parseSingleStack(importerStack); return (stack == null ? void 0 : stack.file) || ""; }; const utils = { useFakeTimers(config) { var _a, _b, _c, _d; if (isChildProcess()) { if (((_a = config == null ? void 0 : config.toFake) == null ? void 0 : _a.includes("nextTick")) || ((_d = (_c = (_b = workerState.config) == null ? void 0 : _b.fakeTimers) == null ? void 0 : _c.toFake) == null ? void 0 : _d.includes("nextTick"))) { throw new Error( 'vi.useFakeTimers({ toFake: ["nextTick"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.' ); } } if (config) _timers.configure({ ...workerState.config.fakeTimers, ...config }); else _timers.configure(workerState.config.fakeTimers); _timers.useFakeTimers(); return utils; }, isFakeTimers() { return _timers.isFakeTimers(); }, useRealTimers() { _timers.useRealTimers(); _mockedDate = null; return utils; }, runOnlyPendingTimers() { _timers.runOnlyPendingTimers(); return utils; }, async runOnlyPendingTimersAsync() { await _timers.runOnlyPendingTimersAsync(); return utils; }, runAllTimers() { _timers.runAllTimers(); return utils; }, async runAllTimersAsync() { await _timers.runAllTimersAsync(); return utils; }, runAllTicks() { _timers.runAllTicks(); return utils; }, advanceTimersByTime(ms) { _timers.advanceTimersByTime(ms); return utils; }, async advanceTimersByTimeAsync(ms) { await _timers.advanceTimersByTimeAsync(ms); return utils; }, advanceTimersToNextTimer() { _timers.advanceTimersToNextTimer(); return utils; }, async advanceTimersToNextTimerAsync() { await _timers.advanceTimersToNextTimerAsync(); return utils; }, getTimerCount() { return _timers.getTimerCount(); }, setSystemTime(time) { const date = time instanceof Date ? time : new Date(time); _mockedDate = date; _timers.setSystemTime(date); return utils; }, getMockedSystemTime() { return _mockedDate; }, getRealSystemTime() { return _timers.getRealSystemTime(); }, clearAllTimers() { _timers.clearAllTimers(); return utils; }, // mocks spyOn, fn, waitFor, waitUntil, hoisted(factory) { assertTypes(factory, '"vi.hoisted" factory', ["function"]); return factory(); }, mock(path, factory) { const importer = getImporter(); _mocker.queueMock( path, importer, factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0, true ); }, unmock(path) { _mocker.queueUnmock(path, getImporter()); }, doMock(path, factory) { const importer = getImporter(); _mocker.queueMock( path, importer, factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0, false ); }, doUnmock(path) { _mocker.queueUnmock(path, getImporter()); }, async importActual(path) { return _mocker.importActual( path, getImporter(), _mocker.getMockContext().callstack ); }, async importMock(path) { return _mocker.importMock(path, getImporter()); }, mocked(item, _options = {}) { return item; }, isMockFunction(fn2) { return isMockFunction(fn2); }, clearAllMocks() { mocks.forEach((spy) => spy.mockClear()); return utils; }, resetAllMocks() { mocks.forEach((spy) => spy.mockReset()); return utils; }, restoreAllMocks() { mocks.forEach((spy) => spy.mockRestore()); return utils; }, stubGlobal(name, value) { if (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name)); Object.defineProperty(globalThis, name, { value, writable: true, configurable: true, enumerable: true }); return utils; }, stubEnv(name, value) { if (!_stubsEnv.has(name)) _stubsEnv.set(name, process.env[name]); process.env[name] = value; return utils; }, unstubAllGlobals() { _stubsGlobal.forEach((original, name) => { if (!original) Reflect.deleteProperty(globalThis, name); else Object.defineProperty(globalThis, name, original); }); _stubsGlobal.clear(); return utils; }, unstubAllEnvs() { _stubsEnv.forEach((original, name) => { if (original === void 0) delete process.env[name]; else process.env[name] = original; }); _stubsEnv.clear(); return utils; }, resetModules() { resetModules(workerState.moduleCache); return utils; }, async dynamicImportSettled() { return waitForImportsToResolve(); }, setConfig(config) { if (!_config) _config = { ...workerState.config }; Object.assign(workerState.config, config); }, resetConfig() { if (_config) Object.assign(workerState.config, _config); } }; return utils; } const vitest = createVitest(); const vi = vitest; export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, resetModules as r, vi as v };