claude-flow 2.0.0-alpha.7 → 2.0.0-alpha.71

package/src/ui/extension/node_modules/nise/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js

@@ -1,7 +1,6 @@
 "use strict";
-
 const globalObject = require("@sinonjs/commons").global;
-let timersModule, timersPromisesModule;
+let timersModule, timersPromisesModule; // TODO: Remove if unused
 if (typeof require === "function" && typeof module === "object") {
     try {
         timersModule = require("timers");
@@ -14,13 +13,11 @@ if (typeof require === "function" && typeof module === "object") {
         // 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
@@ -28,38 +25,32 @@ if (typeof require === "function" && typeof module === "object") {
  * @param {{timeout: number}} options - an options object
  * @returns {number} the id
  */
-
 /**
  * @callback NextTick
  * @param {VoidVarArgsFunc} callback - the callback to run
  * @param {...*} args - optional arguments to call the callback with
  * @returns {void}
  */
-
 /**
  * @callback SetImmediate
  * @param {VoidVarArgsFunc} callback - the callback to run
  * @param {...*} args - 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
@@ -102,7 +93,6 @@ if (typeof require === "function" && typeof module === "object") {
  * @property {Map<function(): void, AbortSignal>} abortListenerMap
  */
 /* eslint-enable jsdoc/require-property-description */
-
 /**
  * Configuration object for the `install` method.
  * @typedef {object} Config
@@ -114,7 +104,6 @@ if (typeof require === "function" && typeof module === "object") {
  * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)
  * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error
  */
-
 /* eslint-disable jsdoc/require-property-description */
 /**
  * The internal structure to describe a scheduled fake timer
@@ -128,7 +117,6 @@ if (typeof require === "function" && typeof module === "object") {
  * @property {number} id
  * @property {Error} [error]
  */
-
 /**
  * A Node timer
  * @typedef {object} NodeImmediate
@@ -137,9 +125,7 @@ if (typeof require === "function" && typeof module === "object") {
  * @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`)
@@ -155,9 +141,8 @@ function withGlobal(_global) {
         return [];
     };
     const isPresent = {};
-    let timeoutResult,
+    let timeoutResult, // TODO: Remove if unused
         addTimerReturnsObject = false;
-
     if (_global.setTimeout) {
         isPresent.setTimeout = true;
         timeoutResult = _global.setTimeout(NOOP, 0);
@@ -200,15 +185,12 @@ function withGlobal(_global) {
     isPresent.clearImmediate =
         _global.clearImmediate && typeof _global.clearImmediate === "function";
     isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
-
     if (_global.clearTimeout) {
         _global.clearTimeout(timeoutResult);
     }
-
     const NativeDate = _global.Date;
     const NativeIntl = _global.Intl;
     let uniqueTimerId = idCounterStart;
-
     if (NativeDate === undefined) {
         throw new Error(
             "The global scope doesn't have a `Date` object" +
@@ -216,7 +198,6 @@ function withGlobal(_global) {
         );
     }
     isPresent.Date = true;
-
     /**
      * @param {number} num
      * @returns {boolean}
@@ -225,12 +206,9 @@ function withGlobal(_global) {
         if (Number.isFinite) {
             return Number.isFinite(num);
         }
-
         return isFinite(num);
     }
-
     let isNearInfiniteLimit = false;
-
     /**
      * @param {Clock} clock
      * @param {number} i
@@ -240,14 +218,12 @@ function withGlobal(_global) {
             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
@@ -259,32 +235,25 @@ function withGlobal(_global) {
         if (!str) {
             return 0;
         }
-
         const strings = str.split(":");
         const l = strings.length;
         let i = l;
         let ms = 0;
-        let parsed;
-
+        let parsed; // TODO: Remove if unused
         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
@@ -297,10 +266,8 @@ function withGlobal(_global) {
         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
@@ -318,7 +285,6 @@ function withGlobal(_global) {
         }
         throw new TypeError("now should be milliseconds since UNIX epoch");
     }
-
     /**
      * @param {number} from
      * @param {number} to
@@ -328,7 +294,6 @@ function withGlobal(_global) {
     function inRange(from, to, timer) {
         return timer && timer.callAt >= from && timer.callAt <= to;
     }
-
     /**
      * @param {Clock} clock
      * @param {Timer} job
@@ -337,24 +302,20 @@ function withGlobal(_global) {
         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
@@ -365,7 +326,6 @@ function withGlobal(_global) {
                 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);
@@ -373,20 +333,17 @@ function withGlobal(_global) {
                 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,
@@ -394,23 +351,20 @@ function withGlobal(_global) {
         } catch (e) {
             // noop
         }
-
         return infiniteLoopError;
     }
-
     /**
      * @param {Date} target
      * @param {Date} source
      * @returns {Date} the target after modifications
      */
     function mirrorDateProperties(target, source) {
-        let prop;
+        let prop; // TODO: Remove if unused
         for (prop in source) {
             if (source.hasOwnProperty(prop)) {
                 target[prop] = source[prop];
             }
         }
-
         // set special now implementation
         if (source.now) {
             target.now = function now() {
@@ -419,7 +373,6 @@ function withGlobal(_global) {
         } else {
             delete target.now;
         }
-
         // set special toSource implementation
         if (source.toSource) {
             target.toSource = function toSource() {
@@ -428,21 +381,17 @@ function withGlobal(_global) {
         } 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() {
         /**
@@ -461,7 +410,6 @@ function withGlobal(_global) {
             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
@@ -499,10 +447,8 @@ function withGlobal(_global) {
                     );
             }
         }
-
         return mirrorDateProperties(ClockDate, NativeDate);
     }
-
     /**
      * Mirror Intl by default on our fake implementation
      *
@@ -520,37 +466,29 @@ function withGlobal(_global) {
         Object.getOwnPropertyNames(NativeIntl).forEach(
             (property) => (ClockIntl[property] = NativeIntl[property]),
         );
-
         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
@@ -559,7 +497,6 @@ function withGlobal(_global) {
         }
         clock.jobs.push(job);
     }
-
     //eslint-disable-next-line jsdoc/require-jsdoc
     function runJobs(clock) {
         // runs all microtick-deferred tasks - ecma262/#sec-runjobs
@@ -569,7 +506,6 @@ function withGlobal(_global) {
         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);
@@ -578,7 +514,6 @@ function withGlobal(_global) {
         resetIsNearInfiniteLimit();
         clock.jobs = [];
     }
-
     /**
      * @param {Clock} clock
      * @param {Timer} timer
@@ -588,7 +523,6 @@ function withGlobal(_global) {
         if (timer.func === undefined) {
             throw new Error("Callback must be provided to timer calls");
         }
-
         if (addTimerReturnsObject) {
             // Node.js environment
             if (typeof timer.func !== "function") {
@@ -599,51 +533,40 @@ function withGlobal(_global) {
                 );
             }
         }
-
         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,
@@ -662,10 +585,8 @@ function withGlobal(_global) {
                     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 () {
@@ -674,10 +595,8 @@ function withGlobal(_global) {
             };
             return res;
         }
-
         return timer.id;
     }
-
     /* eslint consistent-return: "off" */
     /**
      * Timer comparitor
@@ -693,7 +612,6 @@ function withGlobal(_global) {
         if (a.callAt > b.callAt) {
             return 1;
         }
-
         // Sort next by immediate, immediate timers take precedence
         if (a.immediate && !b.immediate) {
             return -1;
@@ -701,7 +619,6 @@ function withGlobal(_global) {
         if (!a.immediate && b.immediate) {
             return 1;
         }
-
         // Sort next by creation time, earlier-created timers take precedence
         if (a.createdAt < b.createdAt) {
             return -1;
@@ -709,7 +626,6 @@ function withGlobal(_global) {
         if (a.createdAt > b.createdAt) {
             return 1;
         }
-
         // Sort next by id, lower-id timers take precedence
         if (a.id < b.id) {
             return -1;
@@ -717,10 +633,8 @@ function withGlobal(_global) {
         if (a.id > b.id) {
             return 1;
         }
-
         // As timer ids are unique, no fallback `0` is necessary
     }
-
     /**
      * @param {Clock} clock
      * @param {number} from
@@ -730,12 +644,10 @@ function withGlobal(_global) {
     function firstTimerInRange(clock, from, to) {
         const timers = clock.timers;
         let timer = null;
-        let id, isInRange;
-
+        let id, isInRange; // TODO: Remove if unused
         for (id in timers) {
             if (timers.hasOwnProperty(id)) {
                 isInRange = inRange(from, to, timers[id]);
-
                 if (
                     isInRange &&
                     (!timer || compareTimers(timer, timers[id]) === 1)
@@ -744,10 +656,8 @@ function withGlobal(_global) {
                 }
             }
         }
-
         return timer;
     }
-
     /**
      * @param {Clock} clock
      * @returns {Timer}
@@ -755,8 +665,7 @@ function withGlobal(_global) {
     function firstTimer(clock) {
         const timers = clock.timers;
         let timer = null;
-        let id;
-
+        let id; // TODO: Remove if unused
         for (id in timers) {
             if (timers.hasOwnProperty(id)) {
                 if (!timer || compareTimers(timer, timers[id]) === 1) {
@@ -764,10 +673,8 @@ function withGlobal(_global) {
                 }
             }
         }
-
         return timer;
     }
-
     /**
      * @param {Clock} clock
      * @returns {Timer}
@@ -775,8 +682,7 @@ function withGlobal(_global) {
     function lastTimer(clock) {
         const timers = clock.timers;
         let timer = null;
-        let id;
-
+        let id; // TODO: Remove if unused
         for (id in timers) {
             if (timers.hasOwnProperty(id)) {
                 if (!timer || compareTimers(timer, timers[id]) === -1) {
@@ -784,10 +690,8 @@ function withGlobal(_global) {
                 }
             }
         }
-
         return timer;
     }
-
     /**
      * @param {Clock} clock
      * @param {Timer} timer
@@ -798,7 +702,6 @@ function withGlobal(_global) {
         } else {
             delete clock.timers[timer.id];
         }
-
         if (typeof timer.func === "function") {
             timer.func.apply(null, timer.args);
         } else {
@@ -809,7 +712,6 @@ function withGlobal(_global) {
             })();
         }
     }
-
     /**
      * Gets clear handler name for a given timer type
      * @param {string} ttype
@@ -820,7 +722,6 @@ function withGlobal(_global) {
         }
         return `clear${ttype}`;
     }
-
     /**
      * Gets schedule handler name for a given timer type
      * @param {string} ttype
@@ -831,7 +732,6 @@ function withGlobal(_global) {
         }
         return `set${ttype}`;
     }
-
     /**
      * Creates an anonymous function to warn only once
      */
@@ -843,7 +743,6 @@ function withGlobal(_global) {
         };
     }
     const warnOnce = createWarnOnce();
-
     /**
      * @param {Clock} clock
      * @param {number} timerId
@@ -855,18 +754,14 @@ function withGlobal(_global) {
             // 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"
@@ -878,7 +773,6 @@ function withGlobal(_global) {
                     "\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];
@@ -897,17 +791,15 @@ function withGlobal(_global) {
             }
         }
     }
-
     /**
      * @param {Clock} clock
      * @param {Config} config
      * @returns {Timer[]}
      */
     function uninstall(clock, config) {
-        let method, i, l;
+        let method, i, l; // TODO: Remove if unused
         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) {
@@ -960,19 +852,15 @@ function withGlobal(_global) {
                 }
             }
         }
-
         if (config.shouldAdvanceTime === true) {
             _global.clearInterval(clock.attachedInterval);
         }
-
         // Prevent multiple executions which will completely remove these props
         clock.methods = [];
-
         for (const [listener, signal] of clock.abortListenerMap.entries()) {
             signal.removeEventListener("abort", listener);
             clock.abortListenerMap.delete(listener);
         }
-
         // return pending timers, to enable checking what timers remained on uninstall
         if (!clock.timers) {
             return [];
@@ -981,7 +869,6 @@ function withGlobal(_global) {
             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
@@ -993,7 +880,6 @@ function withGlobal(_global) {
             method,
         );
         clock[`_${method}`] = target[method];
-
         if (method === "Date") {
             const date = mirrorDateProperties(clock[method], target[method]);
             target[method] = date;
@@ -1015,7 +901,6 @@ function withGlobal(_global) {
                     `_${method}`,
                     originalPerfDescriptor,
                 );
-
                 const perfDescriptor = Object.getOwnPropertyDescriptor(
                     clock,
                     method,
@@ -1028,16 +913,13 @@ function withGlobal(_global) {
             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
@@ -1045,7 +927,6 @@ function withGlobal(_global) {
     function doIntervalTick(clock, advanceTimeDelta) {
         clock.tick(advanceTimeDelta);
     }
-
     /**
      * @typedef {object} Timers
      * @property {setTimeout} setTimeout
@@ -1065,7 +946,6 @@ function withGlobal(_global) {
      * @property {RequestIdleCallback=} requestIdleCallback
      * @property {function(number): void=} cancelIdleCallback
      */
-
     /** @type {Timers} */
     const timers = {
         setTimeout: _global.setTimeout,
@@ -1074,50 +954,38 @@ function withGlobal(_global) {
         clearInterval: _global.clearInterval,
         Date: _global.Date,
     };
-
     if (isPresent.setImmediate) {
         timers.setImmediate = _global.setImmediate;
         timers.clearImmediate = _global.clearImmediate;
     }
-
     if (isPresent.hrtime) {
         timers.hrtime = _global.process.hrtime;
     }
-
     if (isPresent.nextTick) {
         timers.nextTick = _global.process.nextTick;
     }
-
     if (isPresent.performance) {
         timers.performance = _global.performance;
     }
-
     if (isPresent.requestAnimationFrame) {
         timers.requestAnimationFrame = _global.requestAnimationFrame;
     }
-
     if (isPresent.queueMicrotask) {
         timers.queueMicrotask = true;
     }
-
     if (isPresent.cancelAnimationFrame) {
         timers.cancelAnimationFrame = _global.cancelAnimationFrame;
     }
-
     if (isPresent.requestIdleCallback) {
         timers.requestIdleCallback = _global.requestIdleCallback;
     }
-
     if (isPresent.cancelIdleCallback) {
         timers.cancelIdleCallback = _global.cancelIdleCallback;
     }
-
     if (isPresent.Intl) {
         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()
@@ -1130,20 +998,16 @@ function withGlobal(_global) {
         loopLimit = loopLimit || 1000;
         let nanos = 0;
         const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
-
         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;
@@ -1152,33 +1016,27 @@ function withGlobal(_global) {
                 (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];
         }
-
         /**
          * A high resolution timestamp in milliseconds.
          * @typedef {number} DOMHighResTimeStamp
          */
-
         /**
          * performance.now()
          * @returns {DOMHighResTimeStamp}
@@ -1188,29 +1046,24 @@ function withGlobal(_global) {
             const millis = hrt[0] * 1000 + hrt[1] / 1e6;
             return millis;
         }
-
         if (isPresent.hrtimeBigint) {
             hrtime.bigint = function () {
                 const parts = hrtime();
                 return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line
             };
         }
-
         if (isPresent.Intl) {
             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),
@@ -1220,14 +1073,11 @@ function withGlobal(_global) {
                         : 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,
@@ -1249,11 +1099,9 @@ function withGlobal(_global) {
                     });
                 };
         }
-
         clock.clearTimeout = function clearTimeout(timerId) {
             return clearTimer(clock, timerId, "Timeout");
         };
-
         clock.nextTick = function nextTick(func) {
             return enqueueJob(clock, {
                 func: func,
@@ -1261,11 +1109,9 @@ function withGlobal(_global) {
                 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);
@@ -1276,11 +1122,9 @@ function withGlobal(_global) {
                 interval: timeout,
             });
         };
-
         clock.clearInterval = function clearInterval(timerId) {
             return clearTimer(clock, timerId, "Interval");
         };
-
         if (isPresent.setImmediate) {
             clock.setImmediate = function setImmediate(func) {
                 return addTimer(clock, {
@@ -1289,7 +1133,6 @@ function withGlobal(_global) {
                     immediate: true,
                 });
             };
-
             if (typeof _global.Promise !== "undefined" && utilPromisify) {
                 clock.setImmediate[utilPromisify.custom] =
                     function promisifiedSetImmediate(arg) {
@@ -1304,19 +1147,16 @@ function withGlobal(_global) {
                         );
                     };
             }
-
             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,
@@ -1326,18 +1166,14 @@ function withGlobal(_global) {
                 },
                 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
@@ -1354,32 +1190,27 @@ function withGlobal(_global) {
             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,
+            let timer, // TODO: Remove if unused
                 firstException,
                 oldNow,
                 nextPromiseTick,
                 compensationCheck,
                 postTimerCall;
             /* eslint-enable prefer-const */
-
             clock.duringTick = true;
-
             // perform microtasks
             oldNow = clock.now;
             runJobs(clock);
@@ -1388,7 +1219,6 @@ function withGlobal(_global) {
                 tickFrom += clock.now - oldNow;
                 tickTo += clock.now - oldNow;
             }
-
             //eslint-disable-next-line jsdoc/require-jsdoc
             function doTickInner() {
                 // perform each timer in the requested range
@@ -1405,7 +1235,6 @@ function withGlobal(_global) {
                         } catch (e) {
                             firstException = firstException || e;
                         }
-
                         if (isAsync) {
                             // finish up after native setImmediate callback to allow
                             // all native es6 promises to process their callbacks after
@@ -1413,13 +1242,10 @@ function withGlobal(_global) {
                             originalSetTimeout(nextPromiseTick);
                             return;
                         }
-
                         compensationCheck();
                     }
-
                     postTimerCall();
                 }
-
                 // perform process.nextTick()s again
                 oldNow = clock.now;
                 runJobs(clock);
@@ -1429,7 +1255,6 @@ function withGlobal(_global) {
                     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) {
@@ -1441,21 +1266,18 @@ function withGlobal(_global) {
                 } 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 () {
@@ -1467,7 +1289,6 @@ function withGlobal(_global) {
                         reject(e);
                     }
                 };
-
             compensationCheck = function () {
                 // compensate for any setSystemTime() call during timer callback
                 if (oldNow !== clock.now) {
@@ -1476,15 +1297,12 @@ function withGlobal(_global) {
                     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
@@ -1492,7 +1310,6 @@ function withGlobal(_global) {
         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"
@@ -1510,14 +1327,12 @@ function withGlobal(_global) {
                 });
             };
         }
-
         clock.next = function next() {
             runJobs(clock);
             const timer = firstTimer(clock);
             if (!timer) {
                 return clock.now;
             }
-
             clock.duringTick = true;
             try {
                 clock.now = timer.callAt;
@@ -1528,7 +1343,6 @@ function withGlobal(_global) {
                 clock.duringTick = false;
             }
         };
-
         if (typeof _global.Promise !== "undefined") {
             clock.nextAsync = function nextAsync() {
                 return new _global.Promise(function (resolve, reject) {
@@ -1539,8 +1353,7 @@ function withGlobal(_global) {
                                 resolve(clock.now);
                                 return;
                             }
-
-                            let err;
+                            let err; // TODO: Remove if unused
                             clock.duringTick = true;
                             clock.now = timer.callAt;
                             try {
@@ -1549,7 +1362,6 @@ function withGlobal(_global) {
                                 err = e;
                             }
                             clock.duringTick = false;
-
                             originalSetTimeout(function () {
                                 if (err) {
                                     reject(err);
@@ -1564,34 +1376,28 @@ function withGlobal(_global) {
                 });
             };
         }
-
         clock.runAll = function runAll() {
-            let numTimers, i;
+            let numTimers, i; // TODO: Remove if unused
             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) {
@@ -1603,15 +1409,13 @@ function withGlobal(_global) {
                         originalSetTimeout(function () {
                             try {
                                 runJobs(clock);
-
-                                let numTimers;
+                                let numTimers; // TODO: Remove if unused
                                 if (i < clock.loopLimit) {
                                     if (!clock.timers) {
                                         resetIsNearInfiniteLimit();
                                         resolve(clock.now);
                                         return;
                                     }
-
                                     numTimers = Object.keys(
                                         clock.timers,
                                     ).length;
@@ -1620,16 +1424,12 @@ function withGlobal(_global) {
                                         resolve(clock.now);
                                         return;
                                     }
-
                                     clock.next();
-
                                     i++;
-
                                     doRun();
                                     checkIsNearInfiniteLimit(clock, i);
                                     return;
                                 }
-
                                 const excessJob = firstTimer(clock);
                                 reject(getInfiniteLoopError(clock, excessJob));
                             } catch (e) {
@@ -1641,17 +1441,14 @@ function withGlobal(_global) {
                 });
             };
         }
-
         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) {
@@ -1662,7 +1459,6 @@ function withGlobal(_global) {
                                 runJobs(clock);
                                 resolve(clock.now);
                             }
-
                             resolve(clock.tickAsync(timer.callAt - clock.now));
                         } catch (e) {
                             reject(e);
@@ -1671,26 +1467,22 @@ function withGlobal(_global) {
                 });
             };
         }
-
         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;
-
+            let id, timer; // TODO: Remove if unused
             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)) {
@@ -1700,7 +1492,6 @@ function withGlobal(_global) {
                 }
             }
         };
-
         /**
          * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
          * @returns {number} will return the new `now` value
@@ -1711,7 +1502,6 @@ function withGlobal(_global) {
                     ? 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;
@@ -1719,21 +1509,16 @@ function withGlobal(_global) {
             }
             clock.tick(ms);
         };
-
         if (isPresent.performance) {
             clock.performance = Object.create(null);
             clock.performance.now = fakePerformanceNow;
         }
-
         if (isPresent.hrtime) {
             clock.hrtime = hrtime;
         }
-
         return clock;
     }
-
     /* eslint-disable complexity */
-
     /**
      * @param {Config=} [config] Optional config
      * @returns {Clock}
@@ -1751,7 +1536,6 @@ function withGlobal(_global) {
                 )} 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.
@@ -1759,20 +1543,17 @@ function withGlobal(_global) {
                 "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.",
             );
         }
-
         /**
          * @param {string} timer/object the name of the thing that is not present
          * @param timer
@@ -1781,31 +1562,24 @@ function withGlobal(_global) {
             if (config.ignoreMissingTimers) {
                 return;
             }
-
             throw new ReferenceError(
                 `non-existent timers and/or objects cannot be faked: '${timer}'`,
             );
         }
-
-        let i, l;
+        let i, l; // TODO: Remove if unused
         const clock = createClock(config.now, config.loopLimit);
         clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
-
         clock.uninstall = function () {
             return uninstall(clock, config);
         };
-
         clock.abortListenerMap = new Map();
-
         clock.methods = config.toFake || [];
-
         if (clock.methods.length === 0) {
             // do not fake nextTick by default - GitHub#126
             clock.methods = Object.keys(timers).filter(function (key) {
                 return key !== "nextTick" && key !== "queueMicrotask";
             });
         }
-
         if (config.shouldAdvanceTime === true) {
             const intervalTick = doIntervalTick.bind(
                 null,
@@ -1818,7 +1592,6 @@ function withGlobal(_global) {
             );
             clock.attachedInterval = intervalId;
         }
-
         if (clock.methods.includes("performance")) {
             const proto = (() => {
                 if (hasPerformanceConstructorPrototype) {
@@ -1849,13 +1622,11 @@ function withGlobal(_global) {
         }
         for (i = 0, l = clock.methods.length; i < l; i++) {
             const nameOfMethodToReplace = clock.methods[i];
-
             if (!isPresent[nameOfMethodToReplace]) {
                 handleMissingTimer(nameOfMethodToReplace);
                 // eslint-disable-next-line
                 continue;
             }
-
             if (nameOfMethodToReplace === "hrtime") {
                 if (
                     _global.process &&
@@ -1891,7 +1662,6 @@ function withGlobal(_global) {
                         methodName: "setTimeout",
                         original: timersPromisesModule.setTimeout,
                     });
-
                     timersPromisesModule.setTimeout = (
                         delay,
                         value,
@@ -1904,14 +1674,12 @@ function withGlobal(_global) {
                                     abort,
                                 );
                                 clock.abortListenerMap.delete(abort);
-
                                 // This is safe, there is no code path that leads to this function
                                 // being invoked before handle has been assigned.
                                 // eslint-disable-next-line no-use-before-define
                                 clock.clearTimeout(handle);
                                 reject(options.signal.reason);
                             };
-
                             const handle = clock.setTimeout(() => {
                                 if (options.signal) {
                                     options.signal.removeEventListener(
@@ -1920,10 +1688,8 @@ function withGlobal(_global) {
                                     );
                                     clock.abortListenerMap.delete(abort);
                                 }
-
                                 resolve(value);
                             }, delay);
-
                             if (options.signal) {
                                 if (options.signal.aborted) {
                                     abort();
@@ -1944,7 +1710,6 @@ function withGlobal(_global) {
                         methodName: "setImmediate",
                         original: timersPromisesModule.setImmediate,
                     });
-
                     timersPromisesModule.setImmediate = (value, options = {}) =>
                         new Promise((resolve, reject) => {
                             const abort = () => {
@@ -1953,14 +1718,12 @@ function withGlobal(_global) {
                                     abort,
                                 );
                                 clock.abortListenerMap.delete(abort);
-
                                 // This is safe, there is no code path that leads to this function
                                 // being invoked before handle has been assigned.
                                 // eslint-disable-next-line no-use-before-define
                                 clock.clearImmediate(handle);
                                 reject(options.signal.reason);
                             };
-
                             const handle = clock.setImmediate(() => {
                                 if (options.signal) {
                                     options.signal.removeEventListener(
@@ -1969,10 +1732,8 @@ function withGlobal(_global) {
                                     );
                                     clock.abortListenerMap.delete(abort);
                                 }
-
                                 resolve(value);
                             });
-
                             if (options.signal) {
                                 if (options.signal.aborted) {
                                     abort();
@@ -1993,7 +1754,6 @@ function withGlobal(_global) {
                         methodName: "setInterval",
                         original: timersPromisesModule.setInterval,
                     });
-
                     timersPromisesModule.setInterval = (
                         delay,
                         value,
@@ -2001,7 +1761,7 @@ function withGlobal(_global) {
                     ) => ({
                         [Symbol.asyncIterator]: () => {
                             const createResolvable = () => {
-                                let resolve, reject;
+                                let resolve, reject; // TODO: Remove if unused
                                 const promise = new Promise((res, rej) => {
                                     resolve = res;
                                     reject = rej;
@@ -2010,13 +1770,11 @@ function withGlobal(_global) {
                                 promise.reject = reject;
                                 return promise;
                             };
-
                             let done = false;
                             let hasThrown = false;
-                            let returnCall;
+                            let returnCall; // TODO: Remove if unused
                             let nextAvailable = 0;
                             const nextQueue = [];
-
                             const handle = clock.setInterval(() => {
                                 if (nextQueue.length > 0) {
                                     nextQueue.shift().resolve();
@@ -2024,21 +1782,18 @@ function withGlobal(_global) {
                                     nextAvailable++;
                                 }
                             }, delay);
-
                             const abort = () => {
                                 options.signal.removeEventListener(
                                     "abort",
                                     abort,
                                 );
                                 clock.abortListenerMap.delete(abort);
-
                                 clock.clearInterval(handle);
                                 done = true;
                                 for (const resolvable of nextQueue) {
                                     resolvable.resolve();
                                 }
                             };
-
                             if (options.signal) {
                                 if (options.signal.aborted) {
                                     done = true;
@@ -2053,56 +1808,44 @@ function withGlobal(_global) {
                                     );
                                 }
                             }
-
                             return {
                                 next: async () => {
                                     if (options.signal?.aborted && !hasThrown) {
                                         hasThrown = true;
                                         throw options.signal.reason;
                                     }
-
                                     if (done) {
                                         return { done: true, value: undefined };
                                     }
-
                                     if (nextAvailable > 0) {
                                         nextAvailable--;
                                         return { done: false, value: value };
                                     }
-
                                     const resolvable = createResolvable();
                                     nextQueue.push(resolvable);
-
                                     await resolvable;
-
                                     if (returnCall && nextQueue.length === 0) {
                                         returnCall.resolve();
                                     }
-
                                     if (options.signal?.aborted && !hasThrown) {
                                         hasThrown = true;
                                         throw options.signal.reason;
                                     }
-
                                     if (done) {
                                         return { done: true, value: undefined };
                                     }
-
                                     return { done: false, value: value };
                                 },
                                 return: async () => {
                                     if (done) {
                                         return { done: true, value: undefined };
                                     }
-
                                     if (nextQueue.length > 0) {
                                         returnCall = createResolvable();
                                         await returnCall;
                                     }
-
                                     clock.clearInterval(handle);
                                     done = true;
-
                                     if (options.signal) {
                                         options.signal.removeEventListener(
                                             "abort",
@@ -2110,7 +1853,6 @@ function withGlobal(_global) {
                                         );
                                         clock.abortListenerMap.delete(abort);
                                     }
-
                                     return { done: true, value: undefined };
                                 },
                             };
@@ -2119,12 +1861,9 @@ function withGlobal(_global) {
                 }
             }
         }
-
         return clock;
     }
-
     /* eslint-enable complexity */
-
     return {
         timers: timers,
         createClock: createClock,
@@ -2132,7 +1871,6 @@ function withGlobal(_global) {
         withGlobal: withGlobal,
     };
 }
-
 /**
  * @typedef {object} FakeTimers
  * @property {Timers} timers
@@ -2140,13 +1878,10 @@ function withGlobal(_global) {
  * @property {Function} install
  * @property {withGlobal} withGlobal
  */
-
 /* eslint-enable complexity */
-
 /** @type {FakeTimers} */
 const defaultImplementation = withGlobal(globalObject);
-
 exports.timers = defaultImplementation.timers;
 exports.createClock = defaultImplementation.createClock;
 exports.install = defaultImplementation.install;
-exports.withGlobal = withGlobal;
+exports.withGlobal = withGlobal;