Add node modules and compiled JavaScript from main (#54)

Co-authored-by: Oliver King <oking3@uncc.edu>

node_modules/@jest/fake-timers/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@jest/fake-timers/build/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type {Config} from '@jest/types';
+import type {ModuleMocker} from 'jest-mock';
+import {StackTraceConfig} from 'jest-message-util';
+
+declare type Callback = (...args: Array<unknown>) => void;
+
+export declare class LegacyFakeTimers<TimerRef = unknown> {
+  private _cancelledTicks;
+  private _config;
+  private _disposed?;
+  private _fakeTimerAPIs;
+  private _global;
+  private _immediates;
+  private _maxLoops;
+  private _moduleMocker;
+  private _now;
+  private _ticks;
+  private _timerAPIs;
+  private _timers;
+  private _uuidCounter;
+  private _timerConfig;
+  constructor({
+    global,
+    moduleMocker,
+    timerConfig,
+    config,
+    maxLoops,
+  }: {
+    global: typeof globalThis;
+    moduleMocker: ModuleMocker;
+    timerConfig: TimerConfig<TimerRef>;
+    config: StackTraceConfig;
+    maxLoops?: number;
+  });
+  clearAllTimers(): void;
+  dispose(): void;
+  reset(): void;
+  runAllTicks(): void;
+  runAllImmediates(): void;
+  private _runImmediate;
+  runAllTimers(): void;
+  runOnlyPendingTimers(): void;
+  advanceTimersToNextTimer(steps?: number): void;
+  advanceTimersByTime(msToRun: number): void;
+  runWithRealTimers(cb: Callback): void;
+  useRealTimers(): void;
+  useFakeTimers(): void;
+  getTimerCount(): number;
+  private _checkFakeTimers;
+  private _createMocks;
+  private _fakeClearTimer;
+  private _fakeClearImmediate;
+  private _fakeNextTick;
+  private _fakeRequestAnimationFrame;
+  private _fakeSetImmediate;
+  private _fakeSetInterval;
+  private _fakeSetTimeout;
+  private _getNextTimerHandle;
+  private _runTimerHandle;
+}
+
+export declare class ModernFakeTimers {
+  private _clock;
+  private _config;
+  private _fakingTime;
+  private _global;
+  private _fakeTimers;
+  constructor({
+    global,
+    config,
+  }: {
+    global: typeof globalThis;
+    config: Config.ProjectConfig;
+  });
+  clearAllTimers(): void;
+  dispose(): void;
+  runAllTimers(): void;
+  runOnlyPendingTimers(): void;
+  advanceTimersToNextTimer(steps?: number): void;
+  advanceTimersByTime(msToRun: number): void;
+  runAllTicks(): void;
+  useRealTimers(): void;
+  useFakeTimers(fakeTimersConfig?: Config.FakeTimersConfig): void;
+  reset(): void;
+  setSystemTime(now?: number | Date): void;
+  getRealSystemTime(): number;
+  getTimerCount(): number;
+  private _checkFakeTimers;
+  private _toSinonFakeTimersConfig;
+}
+
+declare type TimerConfig<Ref> = {
+  idToRef: (id: number) => Ref;
+  refToId: (ref: Ref) => number | void;
+};
+
+export {};

node_modules/@jest/fake-timers/build/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+Object.defineProperty(exports, 'LegacyFakeTimers', {
+  enumerable: true,
+  get: function () {
+    return _legacyFakeTimers.default;
+  }
+});
+Object.defineProperty(exports, 'ModernFakeTimers', {
+  enumerable: true,
+  get: function () {
+    return _modernFakeTimers.default;
+  }
+});
+
+var _legacyFakeTimers = _interopRequireDefault(require('./legacyFakeTimers'));
+
+var _modernFakeTimers = _interopRequireDefault(require('./modernFakeTimers'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}

node_modules/@jest/fake-timers/build/legacyFakeTimers.js

@@ -0,0 +1,633 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _util() {
+  const data = require('util');
+
+  _util = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/prefer-spread-eventually */
+const MS_IN_A_YEAR = 31536000000;
+
+class FakeTimers {
+  _cancelledTicks;
+  _config;
+  _disposed;
+  _fakeTimerAPIs;
+  _global;
+  _immediates;
+  _maxLoops;
+  _moduleMocker;
+  _now;
+  _ticks;
+  _timerAPIs;
+  _timers;
+  _uuidCounter;
+  _timerConfig;
+
+  constructor({global, moduleMocker, timerConfig, config, maxLoops}) {
+    this._global = global;
+    this._timerConfig = timerConfig;
+    this._config = config;
+    this._maxLoops = maxLoops || 100000;
+    this._uuidCounter = 1;
+    this._moduleMocker = moduleMocker; // Store original timer APIs for future reference
+
+    this._timerAPIs = {
+      cancelAnimationFrame: global.cancelAnimationFrame,
+      clearImmediate: global.clearImmediate,
+      clearInterval: global.clearInterval,
+      clearTimeout: global.clearTimeout,
+      nextTick: global.process && global.process.nextTick,
+      requestAnimationFrame: global.requestAnimationFrame,
+      setImmediate: global.setImmediate,
+      setInterval: global.setInterval,
+      setTimeout: global.setTimeout
+    };
+    this.reset();
+  }
+
+  clearAllTimers() {
+    this._immediates = [];
+
+    this._timers.clear();
+  }
+
+  dispose() {
+    this._disposed = true;
+    this.clearAllTimers();
+  }
+
+  reset() {
+    this._cancelledTicks = {};
+    this._now = 0;
+    this._ticks = [];
+    this._immediates = [];
+    this._timers = new Map();
+  }
+
+  runAllTicks() {
+    this._checkFakeTimers(); // Only run a generous number of ticks and then bail.
+    // This is just to help avoid recursive loops
+
+    let i;
+
+    for (i = 0; i < this._maxLoops; i++) {
+      const tick = this._ticks.shift();
+
+      if (tick === undefined) {
+        break;
+      }
+
+      if (
+        !Object.prototype.hasOwnProperty.call(this._cancelledTicks, tick.uuid)
+      ) {
+        // Callback may throw, so update the map prior calling.
+        this._cancelledTicks[tick.uuid] = true;
+        tick.callback();
+      }
+    }
+
+    if (i === this._maxLoops) {
+      throw new Error(
+        `Ran ${this._maxLoops} ticks, and there are still more! ` +
+          "Assuming we've hit an infinite recursion and bailing out..."
+      );
+    }
+  }
+
+  runAllImmediates() {
+    this._checkFakeTimers(); // Only run a generous number of immediates and then bail.
+
+    let i;
+
+    for (i = 0; i < this._maxLoops; i++) {
+      const immediate = this._immediates.shift();
+
+      if (immediate === undefined) {
+        break;
+      }
+
+      this._runImmediate(immediate);
+    }
+
+    if (i === this._maxLoops) {
+      throw new Error(
+        `Ran ${this._maxLoops} immediates, and there are still more! Assuming ` +
+          "we've hit an infinite recursion and bailing out..."
+      );
+    }
+  }
+
+  _runImmediate(immediate) {
+    try {
+      immediate.callback();
+    } finally {
+      this._fakeClearImmediate(immediate.uuid);
+    }
+  }
+
+  runAllTimers() {
+    this._checkFakeTimers();
+
+    this.runAllTicks();
+    this.runAllImmediates(); // Only run a generous number of timers and then bail.
+    // This is just to help avoid recursive loops
+
+    let i;
+
+    for (i = 0; i < this._maxLoops; i++) {
+      const nextTimerHandle = this._getNextTimerHandle(); // If there are no more timer handles, stop!
+
+      if (nextTimerHandle === null) {
+        break;
+      }
+
+      this._runTimerHandle(nextTimerHandle); // Some of the immediate calls could be enqueued
+      // during the previous handling of the timers, we should
+      // run them as well.
+
+      if (this._immediates.length) {
+        this.runAllImmediates();
+      }
+
+      if (this._ticks.length) {
+        this.runAllTicks();
+      }
+    }
+
+    if (i === this._maxLoops) {
+      throw new Error(
+        `Ran ${this._maxLoops} timers, and there are still more! ` +
+          "Assuming we've hit an infinite recursion and bailing out..."
+      );
+    }
+  }
+
+  runOnlyPendingTimers() {
+    // We need to hold the current shape of `this._timers` because existing
+    // timers can add new ones to the map and hence would run more than necessary.
+    // See https://github.com/facebook/jest/pull/4608 for details
+    const timerEntries = Array.from(this._timers.entries());
+
+    this._checkFakeTimers();
+
+    this._immediates.forEach(this._runImmediate, this);
+
+    timerEntries
+      .sort(([, left], [, right]) => left.expiry - right.expiry)
+      .forEach(([timerHandle]) => this._runTimerHandle(timerHandle));
+  }
+
+  advanceTimersToNextTimer(steps = 1) {
+    if (steps < 1) {
+      return;
+    }
+
+    const nextExpiry = Array.from(this._timers.values()).reduce(
+      (minExpiry, timer) => {
+        if (minExpiry === null || timer.expiry < minExpiry) return timer.expiry;
+        return minExpiry;
+      },
+      null
+    );
+
+    if (nextExpiry !== null) {
+      this.advanceTimersByTime(nextExpiry - this._now);
+      this.advanceTimersToNextTimer(steps - 1);
+    }
+  }
+
+  advanceTimersByTime(msToRun) {
+    this._checkFakeTimers(); // Only run a generous number of timers and then bail.
+    // This is just to help avoid recursive loops
+
+    let i;
+
+    for (i = 0; i < this._maxLoops; i++) {
+      const timerHandle = this._getNextTimerHandle(); // If there are no more timer handles, stop!
+
+      if (timerHandle === null) {
+        break;
+      }
+
+      const timerValue = this._timers.get(timerHandle);
+
+      if (timerValue === undefined) {
+        break;
+      }
+
+      const nextTimerExpiry = timerValue.expiry;
+
+      if (this._now + msToRun < nextTimerExpiry) {
+        // There are no timers between now and the target we're running to, so
+        // adjust our time cursor and quit
+        this._now += msToRun;
+        break;
+      } else {
+        msToRun -= nextTimerExpiry - this._now;
+        this._now = nextTimerExpiry;
+
+        this._runTimerHandle(timerHandle);
+      }
+    }
+
+    if (i === this._maxLoops) {
+      throw new Error(
+        `Ran ${this._maxLoops} timers, and there are still more! ` +
+          "Assuming we've hit an infinite recursion and bailing out..."
+      );
+    }
+  }
+
+  runWithRealTimers(cb) {
+    const prevClearImmediate = this._global.clearImmediate;
+    const prevClearInterval = this._global.clearInterval;
+    const prevClearTimeout = this._global.clearTimeout;
+    const prevNextTick = this._global.process.nextTick;
+    const prevSetImmediate = this._global.setImmediate;
+    const prevSetInterval = this._global.setInterval;
+    const prevSetTimeout = this._global.setTimeout;
+    this.useRealTimers();
+    let cbErr = null;
+    let errThrown = false;
+
+    try {
+      cb();
+    } catch (e) {
+      errThrown = true;
+      cbErr = e;
+    }
+
+    this._global.clearImmediate = prevClearImmediate;
+    this._global.clearInterval = prevClearInterval;
+    this._global.clearTimeout = prevClearTimeout;
+    this._global.process.nextTick = prevNextTick;
+    this._global.setImmediate = prevSetImmediate;
+    this._global.setInterval = prevSetInterval;
+    this._global.setTimeout = prevSetTimeout;
+
+    if (errThrown) {
+      throw cbErr;
+    }
+  }
+
+  useRealTimers() {
+    const global = this._global;
+
+    if (typeof global.cancelAnimationFrame === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'cancelAnimationFrame',
+        this._timerAPIs.cancelAnimationFrame
+      );
+    }
+
+    if (typeof global.clearImmediate === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'clearImmediate',
+        this._timerAPIs.clearImmediate
+      );
+    }
+
+    (0, _jestUtil().setGlobal)(
+      global,
+      'clearInterval',
+      this._timerAPIs.clearInterval
+    );
+    (0, _jestUtil().setGlobal)(
+      global,
+      'clearTimeout',
+      this._timerAPIs.clearTimeout
+    );
+
+    if (typeof global.requestAnimationFrame === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'requestAnimationFrame',
+        this._timerAPIs.requestAnimationFrame
+      );
+    }
+
+    if (typeof global.setImmediate === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'setImmediate',
+        this._timerAPIs.setImmediate
+      );
+    }
+
+    (0, _jestUtil().setGlobal)(
+      global,
+      'setInterval',
+      this._timerAPIs.setInterval
+    );
+    (0, _jestUtil().setGlobal)(
+      global,
+      'setTimeout',
+      this._timerAPIs.setTimeout
+    );
+    global.process.nextTick = this._timerAPIs.nextTick;
+  }
+
+  useFakeTimers() {
+    this._createMocks();
+
+    const global = this._global;
+
+    if (typeof global.cancelAnimationFrame === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'cancelAnimationFrame',
+        this._fakeTimerAPIs.cancelAnimationFrame
+      );
+    }
+
+    if (typeof global.clearImmediate === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'clearImmediate',
+        this._fakeTimerAPIs.clearImmediate
+      );
+    }
+
+    (0, _jestUtil().setGlobal)(
+      global,
+      'clearInterval',
+      this._fakeTimerAPIs.clearInterval
+    );
+    (0, _jestUtil().setGlobal)(
+      global,
+      'clearTimeout',
+      this._fakeTimerAPIs.clearTimeout
+    );
+
+    if (typeof global.requestAnimationFrame === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'requestAnimationFrame',
+        this._fakeTimerAPIs.requestAnimationFrame
+      );
+    }
+
+    if (typeof global.setImmediate === 'function') {
+      (0, _jestUtil().setGlobal)(
+        global,
+        'setImmediate',
+        this._fakeTimerAPIs.setImmediate
+      );
+    }
+
+    (0, _jestUtil().setGlobal)(
+      global,
+      'setInterval',
+      this._fakeTimerAPIs.setInterval
+    );
+    (0, _jestUtil().setGlobal)(
+      global,
+      'setTimeout',
+      this._fakeTimerAPIs.setTimeout
+    );
+    global.process.nextTick = this._fakeTimerAPIs.nextTick;
+  }
+
+  getTimerCount() {
+    this._checkFakeTimers();
+
+    return this._timers.size + this._immediates.length + this._ticks.length;
+  }
+
+  _checkFakeTimers() {
+    var _this$_fakeTimerAPIs;
+
+    // @ts-expect-error: condition always returns 'true'
+    if (
+      this._global.setTimeout !==
+      ((_this$_fakeTimerAPIs = this._fakeTimerAPIs) === null ||
+      _this$_fakeTimerAPIs === void 0
+        ? void 0
+        : _this$_fakeTimerAPIs.setTimeout)
+    ) {
+      this._global.console.warn(
+        'A function to advance timers was called but the timers APIs are not mocked ' +
+          'with fake timers. Call `jest.useFakeTimers({legacyFakeTimers: true})` ' +
+          'in this test file or enable fake timers for all tests by setting ' +
+          "{'enableGlobally': true, 'legacyFakeTimers': true} in " +
+          `Jest configuration file.\nStack Trace:\n${(0,
+          _jestMessageUtil().formatStackTrace)(
+            new Error().stack,
+            this._config,
+            {
+              noStackTrace: false
+            }
+          )}`
+      );
+    }
+  }
+
+  _createMocks() {
+    const fn = implementation => this._moduleMocker.fn(implementation);
+
+    const promisifiableFakeSetTimeout = fn(this._fakeSetTimeout.bind(this)); // @ts-expect-error: no index
+
+    promisifiableFakeSetTimeout[_util().promisify.custom] = (delay, arg) =>
+      new Promise(resolve => promisifiableFakeSetTimeout(resolve, delay, arg));
+
+    this._fakeTimerAPIs = {
+      cancelAnimationFrame: fn(this._fakeClearTimer.bind(this)),
+      clearImmediate: fn(this._fakeClearImmediate.bind(this)),
+      clearInterval: fn(this._fakeClearTimer.bind(this)),
+      clearTimeout: fn(this._fakeClearTimer.bind(this)),
+      nextTick: fn(this._fakeNextTick.bind(this)),
+      requestAnimationFrame: fn(this._fakeRequestAnimationFrame.bind(this)),
+      setImmediate: fn(this._fakeSetImmediate.bind(this)),
+      setInterval: fn(this._fakeSetInterval.bind(this)),
+      setTimeout: promisifiableFakeSetTimeout
+    };
+  }
+
+  _fakeClearTimer(timerRef) {
+    const uuid = this._timerConfig.refToId(timerRef);
+
+    if (uuid) {
+      this._timers.delete(String(uuid));
+    }
+  }
+
+  _fakeClearImmediate(uuid) {
+    this._immediates = this._immediates.filter(
+      immediate => immediate.uuid !== uuid
+    );
+  }
+
+  _fakeNextTick(callback, ...args) {
+    if (this._disposed) {
+      return;
+    }
+
+    const uuid = String(this._uuidCounter++);
+
+    this._ticks.push({
+      callback: () => callback.apply(null, args),
+      uuid
+    });
+
+    const cancelledTicks = this._cancelledTicks;
+
+    this._timerAPIs.nextTick(() => {
+      if (!Object.prototype.hasOwnProperty.call(cancelledTicks, uuid)) {
+        // Callback may throw, so update the map prior calling.
+        cancelledTicks[uuid] = true;
+        callback.apply(null, args);
+      }
+    });
+  }
+
+  _fakeRequestAnimationFrame(callback) {
+    return this._fakeSetTimeout(() => {
+      // TODO: Use performance.now() once it's mocked
+      callback(this._now);
+    }, 1000 / 60);
+  }
+
+  _fakeSetImmediate(callback, ...args) {
+    if (this._disposed) {
+      return null;
+    }
+
+    const uuid = String(this._uuidCounter++);
+
+    this._immediates.push({
+      callback: () => callback.apply(null, args),
+      uuid
+    });
+
+    this._timerAPIs.setImmediate(() => {
+      if (this._immediates.find(x => x.uuid === uuid)) {
+        try {
+          callback.apply(null, args);
+        } finally {
+          this._fakeClearImmediate(uuid);
+        }
+      }
+    });
+
+    return uuid;
+  }
+
+  _fakeSetInterval(callback, intervalDelay, ...args) {
+    if (this._disposed) {
+      return null;
+    }
+
+    if (intervalDelay == null) {
+      intervalDelay = 0;
+    }
+
+    const uuid = this._uuidCounter++;
+
+    this._timers.set(String(uuid), {
+      callback: () => callback.apply(null, args),
+      expiry: this._now + intervalDelay,
+      interval: intervalDelay,
+      type: 'interval'
+    });
+
+    return this._timerConfig.idToRef(uuid);
+  }
+
+  _fakeSetTimeout(callback, delay, ...args) {
+    if (this._disposed) {
+      return null;
+    } // eslint-disable-next-line no-bitwise
+
+    delay = Number(delay) | 0;
+    const uuid = this._uuidCounter++;
+
+    this._timers.set(String(uuid), {
+      callback: () => callback.apply(null, args),
+      expiry: this._now + delay,
+      interval: undefined,
+      type: 'timeout'
+    });
+
+    return this._timerConfig.idToRef(uuid);
+  }
+
+  _getNextTimerHandle() {
+    let nextTimerHandle = null;
+    let soonestTime = MS_IN_A_YEAR;
+
+    this._timers.forEach((timer, uuid) => {
+      if (timer.expiry < soonestTime) {
+        soonestTime = timer.expiry;
+        nextTimerHandle = uuid;
+      }
+    });
+
+    return nextTimerHandle;
+  }
+
+  _runTimerHandle(timerHandle) {
+    const timer = this._timers.get(timerHandle);
+
+    if (!timer) {
+      return;
+    }
+
+    switch (timer.type) {
+      case 'timeout':
+        this._timers.delete(timerHandle);
+
+        timer.callback();
+        break;
+
+      case 'interval':
+        timer.expiry = this._now + (timer.interval || 0);
+        timer.callback();
+        break;
+
+      default:
+        throw new Error(`Unexpected timer type: ${timer.type}`);
+    }
+  }
+}
+
+exports.default = FakeTimers;

node_modules/@jest/fake-timers/build/modernFakeTimers.js

@@ -0,0 +1,194 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.default = void 0;
+
+function _fakeTimers() {
+  const data = require('@sinonjs/fake-timers');
+
+  _fakeTimers = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestMessageUtil() {
+  const data = require('jest-message-util');
+
+  _jestMessageUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+class FakeTimers {
+  _clock;
+  _config;
+  _fakingTime;
+  _global;
+  _fakeTimers;
+
+  constructor({global, config}) {
+    this._global = global;
+    this._config = config;
+    this._fakingTime = false;
+    this._fakeTimers = (0, _fakeTimers().withGlobal)(global);
+  }
+
+  clearAllTimers() {
+    if (this._fakingTime) {
+      this._clock.reset();
+    }
+  }
+
+  dispose() {
+    this.useRealTimers();
+  }
+
+  runAllTimers() {
+    if (this._checkFakeTimers()) {
+      this._clock.runAll();
+    }
+  }
+
+  runOnlyPendingTimers() {
+    if (this._checkFakeTimers()) {
+      this._clock.runToLast();
+    }
+  }
+
+  advanceTimersToNextTimer(steps = 1) {
+    if (this._checkFakeTimers()) {
+      for (let i = steps; i > 0; i--) {
+        this._clock.next(); // Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250
+
+        this._clock.tick(0);
+
+        if (this._clock.countTimers() === 0) {
+          break;
+        }
+      }
+    }
+  }
+
+  advanceTimersByTime(msToRun) {
+    if (this._checkFakeTimers()) {
+      this._clock.tick(msToRun);
+    }
+  }
+
+  runAllTicks() {
+    if (this._checkFakeTimers()) {
+      // @ts-expect-error - doesn't exist?
+      this._clock.runMicrotasks();
+    }
+  }
+
+  useRealTimers() {
+    if (this._fakingTime) {
+      this._clock.uninstall();
+
+      this._fakingTime = false;
+    }
+  }
+
+  useFakeTimers(fakeTimersConfig) {
+    if (this._fakingTime) {
+      this._clock.uninstall();
+    }
+
+    this._clock = this._fakeTimers.install(
+      this._toSinonFakeTimersConfig(fakeTimersConfig)
+    );
+    this._fakingTime = true;
+  }
+
+  reset() {
+    if (this._checkFakeTimers()) {
+      const {now} = this._clock;
+
+      this._clock.reset();
+
+      this._clock.setSystemTime(now);
+    }
+  }
+
+  setSystemTime(now) {
+    if (this._checkFakeTimers()) {
+      this._clock.setSystemTime(now);
+    }
+  }
+
+  getRealSystemTime() {
+    return Date.now();
+  }
+
+  getTimerCount() {
+    if (this._checkFakeTimers()) {
+      return this._clock.countTimers();
+    }
+
+    return 0;
+  }
+
+  _checkFakeTimers() {
+    if (!this._fakingTime) {
+      this._global.console.warn(
+        'A function to advance timers was called but the timers APIs are not replaced ' +
+          'with fake timers. Call `jest.useFakeTimers()` in this test file or enable ' +
+          "fake timers for all tests by setting 'fakeTimers': {'enableGlobally': true} " +
+          `in Jest configuration file.\nStack Trace:\n${(0,
+          _jestMessageUtil().formatStackTrace)(
+            new Error().stack,
+            this._config,
+            {
+              noStackTrace: false
+            }
+          )}`
+      );
+    }
+
+    return this._fakingTime;
+  }
+
+  _toSinonFakeTimersConfig(fakeTimersConfig = {}) {
+    var _fakeTimersConfig$doN, _fakeTimersConfig$now;
+
+    fakeTimersConfig = {...this._config.fakeTimers, ...fakeTimersConfig};
+    const advanceTimeDelta =
+      typeof fakeTimersConfig.advanceTimers === 'number'
+        ? fakeTimersConfig.advanceTimers
+        : undefined;
+    const toFake = new Set(Object.keys(this._fakeTimers.timers));
+    (_fakeTimersConfig$doN = fakeTimersConfig.doNotFake) === null ||
+    _fakeTimersConfig$doN === void 0
+      ? void 0
+      : _fakeTimersConfig$doN.forEach(nameOfFakeableAPI => {
+          toFake.delete(nameOfFakeableAPI);
+        });
+    return {
+      advanceTimeDelta,
+      loopLimit: fakeTimersConfig.timerLimit || 100_000,
+      now:
+        (_fakeTimersConfig$now = fakeTimersConfig.now) !== null &&
+        _fakeTimersConfig$now !== void 0
+          ? _fakeTimersConfig$now
+          : Date.now(),
+      shouldAdvanceTime: Boolean(fakeTimersConfig.advanceTimers),
+      shouldClearNativeTimers: true,
+      toFake: Array.from(toFake)
+    };
+  }
+}
+
+exports.default = FakeTimers;

node_modules/@jest/fake-timers/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@jest/fake-timers",
+  "version": "28.1.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-fake-timers"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@jest/types": "^28.1.1",
+    "@sinonjs/fake-timers": "^9.1.1",
+    "@types/node": "*",
+    "jest-message-util": "^28.1.1",
+    "jest-mock": "^28.1.1",
+    "jest-util": "^28.1.1"
+  },
+  "devDependencies": {
+    "@jest/test-utils": "^28.1.1",
+    "@types/sinonjs__fake-timers": "^8.1.2"
+  },
+  "engines": {
+    "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "eb954f8874960920ac50a8f976bb333fbb06ada9"
+}