@eggjs/mock 6.1.0-beta.3 → 6.1.0-beta.5

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/runner.js

@@ -0,0 +1,922 @@
+import { __commonJS, __require } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "./utils.js";
+import { require_pending } from "./pending.js";
+import { require_src } from "../../../../debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/index.js";
+import { require_error_constants } from "./error-constants.js";
+import { require_errors } from "./errors.js";
+import { require_runnable } from "./runnable.js";
+import { require_suite } from "./suite.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/runner.js
+var require_runner = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/runner.js": ((exports, module) => {
+	/**
+	* @typedef {import('./types.d.ts').RunnerOptions} RunnerOptions
+	*/
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var EventEmitter = __require("node:events").EventEmitter;
+	var Pending = require_pending();
+	var utils = require_utils();
+	var debug = require_src()("mocha:runner");
+	var Runnable = require_runnable();
+	var Suite = require_suite();
+	var HOOK_TYPE_BEFORE_EACH = Suite.constants.HOOK_TYPE_BEFORE_EACH;
+	var HOOK_TYPE_AFTER_EACH = Suite.constants.HOOK_TYPE_AFTER_EACH;
+	var HOOK_TYPE_AFTER_ALL = Suite.constants.HOOK_TYPE_AFTER_ALL;
+	var HOOK_TYPE_BEFORE_ALL = Suite.constants.HOOK_TYPE_BEFORE_ALL;
+	var EVENT_ROOT_SUITE_RUN = Suite.constants.EVENT_ROOT_SUITE_RUN;
+	var STATE_FAILED = Runnable.constants.STATE_FAILED;
+	var STATE_PASSED = Runnable.constants.STATE_PASSED;
+	var STATE_PENDING = Runnable.constants.STATE_PENDING;
+	var stackFilter = utils.stackTraceFilter();
+	var stringify = utils.stringify;
+	const { createInvalidExceptionError, createUnsupportedError, createFatalError, isMochaError } = require_errors();
+	const { constants: errorConstants } = require_error_constants();
+	/**
+	* Non-enumerable globals.
+	* @private
+	* @readonly
+	*/
+	var globals = [
+		"setTimeout",
+		"clearTimeout",
+		"setInterval",
+		"clearInterval",
+		"XMLHttpRequest",
+		"Date",
+		"setImmediate",
+		"clearImmediate"
+	];
+	var constants = utils.defineConstants(
+		/**
+		* {@link Runner}-related constants. Used by reporters. Each event emits the corresponding object, unless otherwise indicated.
+		* @example
+		* const Mocha = require('mocha');
+		* const Base = Mocha.reporters.Base;
+		* const {
+		*   EVENT_HOOK_BEGIN,
+		*   EVENT_TEST_PASS,
+		*   EVENT_TEST_FAIL,
+		*   EVENT_TEST_END
+		* } = Mocha.Runner.constants
+		*
+		* function MyReporter(runner, options) {
+		*   Base.call(this, runner, options);
+		*
+		*   runner.on(EVENT_HOOK_BEGIN, function(hook) {
+		*     console.log('hook called: ', hook.title);
+		*   });
+		*
+		*   runner.on(EVENT_TEST_PASS, function(test) {
+		*     console.log('pass: %s', test.fullTitle());
+		*   });
+		*
+		*   runner.on(EVENT_TEST_FAIL, function(test, err) {
+		*     console.log('fail: %s -- error: %s', test.fullTitle(), err.message);
+		*   });
+		*
+		*   runner.on(EVENT_TEST_END, function() {
+		*     console.log('end: %d/%d', runner.stats.passes, runner.stats.tests);
+		*   });
+		* }
+		*
+		* module.exports = MyReporter;
+		*
+		* @public
+		* @memberof Runner
+		* @readonly
+		* @alias constants
+		* @static
+		* @enum {string}
+		*/
+		{
+			EVENT_HOOK_BEGIN: "hook",
+			EVENT_HOOK_END: "hook end",
+			EVENT_RUN_BEGIN: "start",
+			EVENT_DELAY_BEGIN: "waiting",
+			EVENT_DELAY_END: "ready",
+			EVENT_RUN_END: "end",
+			EVENT_SUITE_BEGIN: "suite",
+			EVENT_SUITE_END: "suite end",
+			EVENT_TEST_BEGIN: "test",
+			EVENT_TEST_END: "test end",
+			EVENT_TEST_FAIL: "fail",
+			EVENT_TEST_PASS: "pass",
+			EVENT_TEST_PENDING: "pending",
+			EVENT_TEST_RETRY: "retry",
+			STATE_IDLE: "idle",
+			STATE_RUNNING: "running",
+			STATE_STOPPED: "stopped"
+		}
+	);
+	var Runner = class extends EventEmitter {
+		/**
+		* Initialize a `Runner` at the Root {@link Suite}, which represents a hierarchy of {@link Suite|Suites} and {@link Test|Tests}.
+		*
+		* @extends external:EventEmitter
+		* @public
+		* @class
+		* @param {Suite} suite - Root suite
+		* @param {Object} [opts] - Settings object
+		* @param {boolean} [opts.cleanReferencesAfterRun] - Whether to clean references to test fns and hooks when a suite is done.
+		* @param {boolean} [opts.delay] - Whether to delay execution of root suite until ready.
+		* @param {boolean} [opts.dryRun] - Whether to report tests without running them.
+		* @param {boolean} [opts.failZero] - Whether to fail test run if zero tests encountered.
+		*/
+		constructor(suite, opts = {}) {
+			super();
+			var self = this;
+			this._globals = [];
+			this._abort = false;
+			this.suite = suite;
+			this._opts = opts;
+			this.state = constants.STATE_IDLE;
+			this.total = suite.total();
+			this.failures = 0;
+			/**
+			* @type {Map<EventEmitter,Map<string,Set<EventListener>>>}
+			*/
+			this._eventListeners = /* @__PURE__ */ new Map();
+			this.on(constants.EVENT_TEST_END, function(test) {
+				if (test.type === "test" && test.retriedTest() && test.parent) {
+					var idx = test.parent.tests && test.parent.tests.indexOf(test.retriedTest());
+					if (idx > -1) test.parent.tests[idx] = test;
+				}
+				self.checkGlobals(test);
+			});
+			this.on(constants.EVENT_HOOK_END, function(hook) {
+				self.checkGlobals(hook);
+			});
+			this._defaultGrep = /.*/;
+			this.grep(this._defaultGrep);
+			this.globals(this.globalProps());
+			this.uncaught = this._uncaught.bind(this);
+			this.unhandled = (reason, promise) => {
+				if (isMochaError(reason)) {
+					debug("trapped unhandled rejection coming out of Mocha; forwarding to uncaught handler:", reason);
+					this.uncaught(reason);
+				} else {
+					debug("trapped unhandled rejection from (probably) user code; re-emitting on process");
+					this._removeEventListener(process, "unhandledRejection", this.unhandled);
+					try {
+						process.emit("unhandledRejection", reason, promise);
+					} finally {
+						this._addEventListener(process, "unhandledRejection", this.unhandled);
+					}
+				}
+			};
+		}
+	};
+	/**
+	* Wrapper for setImmediate, process.nextTick, or browser polyfill.
+	*
+	* @param {Function} fn
+	* @private
+	*/
+	Runner.immediately = global.setImmediate || process.nextTick;
+	/**
+	* Replacement for `target.on(eventName, listener)` that does bookkeeping to remove them when this runner instance is disposed.
+	* @param {EventEmitter} target - The `EventEmitter`
+	* @param {string} eventName - The event name
+	* @param {string} fn - Listener function
+	* @private
+	*/
+	Runner.prototype._addEventListener = function(target, eventName, listener) {
+		debug("_addEventListener(): adding for event %s; %d current listeners", eventName, target.listenerCount(eventName));
+		/* istanbul ignore next */
+		if (this._eventListeners.has(target) && this._eventListeners.get(target).has(eventName) && this._eventListeners.get(target).get(eventName).has(listener)) {
+			debug("warning: tried to attach duplicate event listener for %s", eventName);
+			return;
+		}
+		target.on(eventName, listener);
+		const targetListeners = this._eventListeners.has(target) ? this._eventListeners.get(target) : /* @__PURE__ */ new Map();
+		const targetEventListeners = targetListeners.has(eventName) ? targetListeners.get(eventName) : /* @__PURE__ */ new Set();
+		targetEventListeners.add(listener);
+		targetListeners.set(eventName, targetEventListeners);
+		this._eventListeners.set(target, targetListeners);
+	};
+	/**
+	* Replacement for `target.removeListener(eventName, listener)` that also updates the bookkeeping.
+	* @param {EventEmitter} target - The `EventEmitter`
+	* @param {string} eventName - The event name
+	* @param {function} listener - Listener function
+	* @private
+	*/
+	Runner.prototype._removeEventListener = function(target, eventName, listener) {
+		target.removeListener(eventName, listener);
+		if (this._eventListeners.has(target)) {
+			const targetListeners = this._eventListeners.get(target);
+			if (targetListeners.has(eventName)) {
+				const targetEventListeners = targetListeners.get(eventName);
+				targetEventListeners.delete(listener);
+				if (!targetEventListeners.size) targetListeners.delete(eventName);
+			}
+			if (!targetListeners.size) this._eventListeners.delete(target);
+		} else debug("trying to remove listener for untracked object %s", target);
+	};
+	/**
+	* Removes all event handlers set during a run on this instance.
+	* Remark: this does _not_ clean/dispose the tests or suites themselves.
+	*/
+	Runner.prototype.dispose = function() {
+		this.removeAllListeners();
+		this._eventListeners.forEach((targetListeners, target) => {
+			targetListeners.forEach((targetEventListeners, eventName) => {
+				targetEventListeners.forEach((listener) => {
+					target.removeListener(eventName, listener);
+				});
+			});
+		});
+		this._eventListeners.clear();
+	};
+	/**
+	* Run tests with full titles matching `re`. Updates runner.total
+	* with number of tests matched.
+	*
+	* @public
+	* @memberof Runner
+	* @param {RegExp} re
+	* @param {boolean} invert
+	* @return {Runner} Runner instance.
+	*/
+	Runner.prototype.grep = function(re, invert) {
+		debug("grep(): setting to %s", re);
+		this._grep = re;
+		this._invert = invert;
+		this.total = this.grepTotal(this.suite);
+		return this;
+	};
+	/**
+	* Returns the number of tests matching the grep search for the
+	* given suite.
+	*
+	* @memberof Runner
+	* @public
+	* @param {Suite} suite
+	* @return {number}
+	*/
+	Runner.prototype.grepTotal = function(suite) {
+		var self = this;
+		var total = 0;
+		suite.eachTest(function(test) {
+			var match = self._grep.test(test.fullTitle());
+			if (self._invert) match = !match;
+			if (match) total++;
+		});
+		return total;
+	};
+	/**
+	* Return a list of global properties.
+	*
+	* @return {Array}
+	* @private
+	*/
+	Runner.prototype.globalProps = function() {
+		var props = Object.keys(global);
+		for (var i = 0; i < globals.length; ++i) {
+			if (~props.indexOf(globals[i])) continue;
+			props.push(globals[i]);
+		}
+		return props;
+	};
+	/**
+	* Allow the given `arr` of globals.
+	*
+	* @public
+	* @memberof Runner
+	* @param {Array} arr
+	* @return {Runner} Runner instance.
+	*/
+	Runner.prototype.globals = function(arr) {
+		if (!arguments.length) return this._globals;
+		debug("globals(): setting to %O", arr);
+		this._globals = this._globals.concat(arr);
+		return this;
+	};
+	/**
+	* Check for global variable leaks.
+	*
+	* @private
+	*/
+	Runner.prototype.checkGlobals = function(test) {
+		if (!this.checkLeaks) return;
+		var ok = this._globals;
+		var globals$1 = this.globalProps();
+		var leaks;
+		if (test) ok = ok.concat(test._allowedGlobals || []);
+		if (this.prevGlobalsLength === globals$1.length) return;
+		this.prevGlobalsLength = globals$1.length;
+		leaks = filterLeaks(ok, globals$1);
+		this._globals = this._globals.concat(leaks);
+		if (leaks.length) {
+			var msg = `global leak(s) detected: ${leaks.map((e) => `'${e}'`).join(", ")}`;
+			this.fail(test, new Error(msg));
+		}
+	};
+	/**
+	* Fail the given `test`.
+	*
+	* If `test` is a hook, failures work in the following pattern:
+	* - If bail, run corresponding `after each` and `after` hooks,
+	*   then exit
+	* - Failed `before` hook skips all tests in a suite and subsuites,
+	*   but jumps to corresponding `after` hook
+	* - Failed `before each` hook skips remaining tests in a
+	*   suite and jumps to corresponding `after each` hook,
+	*   which is run only once
+	* - Failed `after` hook does not alter execution order
+	* - Failed `after each` hook skips remaining tests in a
+	*   suite and subsuites, but executes other `after each`
+	*   hooks
+	*
+	* @private
+	* @param {Runnable} test
+	* @param {Error} err
+	* @param {boolean} [force=false] - Whether to fail a pending test.
+	*/
+	Runner.prototype.fail = function(test, err, force) {
+		force = force === true;
+		if (test.isPending() && !force) return;
+		if (this.state === constants.STATE_STOPPED) {
+			if (err.code === errorConstants.MULTIPLE_DONE) throw err;
+			throw createFatalError("Test failed after root suite execution completed!", err);
+		}
+		++this.failures;
+		debug("total number of failures: %d", this.failures);
+		test.state = STATE_FAILED;
+		if (!isError(err)) err = thrown2Error(err);
+		if (!this.fullStackTrace) {
+			const alreadyFiltered = /* @__PURE__ */ new Set();
+			let currentErr = err;
+			while (currentErr && currentErr.stack && !alreadyFiltered.has(currentErr)) {
+				alreadyFiltered.add(currentErr);
+				try {
+					currentErr.stack = stackFilter(currentErr.stack);
+				} catch (ignore) {}
+				currentErr = currentErr.cause;
+			}
+		}
+		this.emit(constants.EVENT_TEST_FAIL, test, err);
+	};
+	/**
+	* Run hook `name` callbacks and then invoke `fn()`.
+	*
+	* @private
+	* @param {string} name
+	* @param {Function} fn
+	*/
+	Runner.prototype.hook = function(name, fn) {
+		if (this._opts.dryRun) return fn();
+		var suite = this.suite;
+		var hooks = suite.getHooks(name);
+		var self = this;
+		function next(i) {
+			var hook = hooks[i];
+			if (!hook) return fn();
+			self.currentRunnable = hook;
+			if (name === HOOK_TYPE_BEFORE_ALL) hook.ctx.currentTest = hook.parent.tests[0];
+			else if (name === HOOK_TYPE_AFTER_ALL) hook.ctx.currentTest = hook.parent.tests[hook.parent.tests.length - 1];
+			else hook.ctx.currentTest = self.test;
+			setHookTitle(hook);
+			hook.allowUncaught = self.allowUncaught;
+			self.emit(constants.EVENT_HOOK_BEGIN, hook);
+			if (!hook.listeners("error").length) self._addEventListener(hook, "error", function(err) {
+				self.fail(hook, err);
+			});
+			hook.run(function cbHookRun(err) {
+				var testError = hook.error();
+				if (testError) self.fail(self.test, testError);
+				if (hook.pending) if (name === HOOK_TYPE_AFTER_EACH) {
+					if (self.test) self.test.pending = true;
+				} else if (name === HOOK_TYPE_BEFORE_EACH) {
+					if (self.test) self.test.pending = true;
+					self.emit(constants.EVENT_HOOK_END, hook);
+					hook.pending = false;
+					return fn(/* @__PURE__ */ new Error("abort hookDown"));
+				} else if (name === HOOK_TYPE_BEFORE_ALL) {
+					suite.tests.forEach(function(test) {
+						test.pending = true;
+					});
+					suite.suites.forEach(function(suite$1) {
+						suite$1.pending = true;
+					});
+					hooks = [];
+				} else {
+					hook.pending = false;
+					var errForbid = createUnsupportedError("`this.skip` forbidden");
+					self.fail(hook, errForbid);
+					return fn(errForbid);
+				}
+				else if (err) {
+					self.fail(hook, err);
+					return fn(err);
+				}
+				self.emit(constants.EVENT_HOOK_END, hook);
+				delete hook.ctx.currentTest;
+				setHookTitle(hook);
+				next(++i);
+			});
+			function setHookTitle(hook$1) {
+				hook$1.originalTitle = hook$1.originalTitle || hook$1.title;
+				if (hook$1.ctx && hook$1.ctx.currentTest) hook$1.title = `${hook$1.originalTitle} for "${hook$1.ctx.currentTest.title}"`;
+				else {
+					var parentTitle;
+					if (hook$1.parent.title) parentTitle = hook$1.parent.title;
+					else parentTitle = hook$1.parent.root ? "{root}" : "";
+					hook$1.title = `${hook$1.originalTitle} in "${parentTitle}"`;
+				}
+			}
+		}
+		Runner.immediately(function() {
+			next(0);
+		});
+	};
+	/**
+	* Run hook `name` for the given array of `suites`
+	* in order, and callback `fn(err, errSuite)`.
+	*
+	* @private
+	* @param {string} name
+	* @param {Array} suites
+	* @param {Function} fn
+	*/
+	Runner.prototype.hooks = function(name, suites, fn) {
+		var self = this;
+		var orig = this.suite;
+		function next(suite) {
+			self.suite = suite;
+			if (!suite) {
+				self.suite = orig;
+				return fn();
+			}
+			self.hook(name, function(err) {
+				if (err) {
+					var errSuite = self.suite;
+					self.suite = orig;
+					return fn(err, errSuite);
+				}
+				next(suites.pop());
+			});
+		}
+		next(suites.pop());
+	};
+	/**
+	* Run 'afterEach' hooks from bottom up.
+	*
+	* @param {String} name
+	* @param {Function} fn
+	* @private
+	*/
+	Runner.prototype.hookUp = function(name, fn) {
+		var suites = [this.suite].concat(this.parents()).reverse();
+		this.hooks(name, suites, fn);
+	};
+	/**
+	* Run 'beforeEach' hooks from top level down.
+	*
+	* @param {String} name
+	* @param {Function} fn
+	* @private
+	*/
+	Runner.prototype.hookDown = function(name, fn) {
+		var suites = [this.suite].concat(this.parents());
+		this.hooks(name, suites, fn);
+	};
+	/**
+	* Return an array of parent Suites from
+	* closest to furthest.
+	*
+	* @return {Array}
+	* @private
+	*/
+	Runner.prototype.parents = function() {
+		var suite = this.suite;
+		var suites = [];
+		while (suite.parent) {
+			suite = suite.parent;
+			suites.push(suite);
+		}
+		return suites;
+	};
+	/**
+	* Run the current test and callback `fn(err)`.
+	*
+	* @param {Function} fn
+	* @private
+	*/
+	Runner.prototype.runTest = function(fn) {
+		if (this._opts.dryRun) return Runner.immediately(fn);
+		var self = this;
+		var test = this.test;
+		if (!test) return;
+		if (this.asyncOnly) test.asyncOnly = true;
+		this._addEventListener(test, "error", function(err) {
+			self.fail(test, err);
+		});
+		if (this.allowUncaught) {
+			test.allowUncaught = true;
+			return test.run(fn);
+		}
+		try {
+			test.run(fn);
+		} catch (err) {
+			fn(err);
+		}
+	};
+	/**
+	* Run tests in the given `suite` and invoke the callback `fn()` when complete.
+	*
+	* @private
+	* @param {Suite} suite
+	* @param {Function} fn
+	*/
+	Runner.prototype.runTests = function(suite, fn) {
+		var self = this;
+		var tests = suite.tests.slice();
+		var test;
+		function hookErr(_, errSuite, after) {
+			var orig = self.suite;
+			self.suite = after ? errSuite.parent : errSuite;
+			if (self.suite) self.hookUp(HOOK_TYPE_AFTER_EACH, function(err2, errSuite2) {
+				self.suite = orig;
+				if (err2) return hookErr(err2, errSuite2, true);
+				fn(errSuite);
+			});
+			else {
+				self.suite = orig;
+				fn(errSuite);
+			}
+		}
+		function next(err, errSuite) {
+			if (self.failures && suite._bail) tests = [];
+			if (self._abort) return fn();
+			if (err) return hookErr(err, errSuite, true);
+			test = tests.shift();
+			if (!test) return fn();
+			var match = self._grep.test(test.fullTitle());
+			if (self._invert) match = !match;
+			if (!match) {
+				if (self._grep !== self._defaultGrep) Runner.immediately(next);
+				else next();
+				return;
+			}
+			if (test.isPending()) {
+				if (self.forbidPending) self.fail(test, /* @__PURE__ */ new Error("Pending test forbidden"), true);
+				else {
+					test.state = STATE_PENDING;
+					self.emit(constants.EVENT_TEST_PENDING, test);
+				}
+				self.emit(constants.EVENT_TEST_END, test);
+				return next();
+			}
+			self.emit(constants.EVENT_TEST_BEGIN, self.test = test);
+			self.hookDown(HOOK_TYPE_BEFORE_EACH, function(err$1, errSuite$1) {
+				if (test.isPending()) {
+					if (self.forbidPending) self.fail(test, /* @__PURE__ */ new Error("Pending test forbidden"), true);
+					else {
+						test.state = STATE_PENDING;
+						self.emit(constants.EVENT_TEST_PENDING, test);
+					}
+					self.emit(constants.EVENT_TEST_END, test);
+					var origSuite = self.suite;
+					self.suite = errSuite$1 || self.suite;
+					return self.hookUp(HOOK_TYPE_AFTER_EACH, function(e, eSuite) {
+						self.suite = origSuite;
+						next(e, eSuite);
+					});
+				}
+				if (err$1) return hookErr(err$1, errSuite$1, false);
+				self.currentRunnable = self.test;
+				self.runTest(function(err$2) {
+					test = self.test;
+					if (test.pending) {
+						if (self.forbidPending) self.fail(test, /* @__PURE__ */ new Error("Pending test forbidden"), true);
+						else {
+							test.state = STATE_PENDING;
+							self.emit(constants.EVENT_TEST_PENDING, test);
+						}
+						self.emit(constants.EVENT_TEST_END, test);
+						return self.hookUp(HOOK_TYPE_AFTER_EACH, next);
+					} else if (err$2) {
+						var retry = test.currentRetry();
+						if (retry < test.retries()) {
+							var clonedTest = test.clone();
+							clonedTest.currentRetry(retry + 1);
+							tests.unshift(clonedTest);
+							self.emit(constants.EVENT_TEST_RETRY, test, err$2);
+							return self.hookUp(HOOK_TYPE_AFTER_EACH, next);
+						} else self.fail(test, err$2);
+						self.emit(constants.EVENT_TEST_END, test);
+						return self.hookUp(HOOK_TYPE_AFTER_EACH, next);
+					}
+					test.state = STATE_PASSED;
+					self.emit(constants.EVENT_TEST_PASS, test);
+					self.emit(constants.EVENT_TEST_END, test);
+					self.hookUp(HOOK_TYPE_AFTER_EACH, next);
+				});
+			});
+		}
+		this.next = next;
+		this.hookErr = hookErr;
+		next();
+	};
+	/**
+	* Run the given `suite` and invoke the callback `fn()` when complete.
+	*
+	* @private
+	* @param {Suite} suite
+	* @param {Function} fn
+	*/
+	Runner.prototype.runSuite = function(suite, fn) {
+		var i = 0;
+		var self = this;
+		var total = this.grepTotal(suite);
+		debug("runSuite(): running %s", suite.fullTitle());
+		if (!total || self.failures && suite._bail) {
+			debug("runSuite(): bailing");
+			return fn();
+		}
+		this.emit(constants.EVENT_SUITE_BEGIN, this.suite = suite);
+		function next(errSuite) {
+			if (errSuite) {
+				if (errSuite === suite) return done();
+				return done(errSuite);
+			}
+			if (self._abort) return done();
+			var curr = suite.suites[i++];
+			if (!curr) return done();
+			if (self._grep !== self._defaultGrep) Runner.immediately(function() {
+				self.runSuite(curr, next);
+			});
+			else self.runSuite(curr, next);
+		}
+		function done(errSuite) {
+			self.suite = suite;
+			self.nextSuite = next;
+			delete self.test;
+			self.hook(HOOK_TYPE_AFTER_ALL, function() {
+				self.emit(constants.EVENT_SUITE_END, suite);
+				fn(errSuite);
+			});
+		}
+		this.nextSuite = next;
+		this.hook(HOOK_TYPE_BEFORE_ALL, function(err) {
+			if (err) return done();
+			self.runTests(suite, next);
+		});
+	};
+	/**
+	* Handle uncaught exceptions within runner.
+	*
+	* This function is bound to the instance as `Runner#uncaught` at instantiation
+	* time. It's intended to be listening on the `Process.uncaughtException` event.
+	* In order to not leak EE listeners, we need to ensure no more than a single
+	* `uncaughtException` listener exists per `Runner`.  The only way to do
+	* this--because this function needs the context (and we don't have lambdas)--is
+	* to use `Function.prototype.bind`. We need strict equality to unregister and
+	* _only_ unregister the _one_ listener we set from the
+	* `Process.uncaughtException` event; would be poor form to just remove
+	* everything. See {@link Runner#run} for where the event listener is registered
+	* and unregistered.
+	* @param {Error} err - Some uncaught error
+	* @private
+	*/
+	Runner.prototype._uncaught = function(err) {
+		if (!(this instanceof Runner)) throw createFatalError("Runner#uncaught() called with invalid context", this);
+		if (err instanceof Pending) {
+			debug("uncaught(): caught a Pending");
+			return;
+		}
+		if (this.allowUncaught && !utils.isBrowser()) {
+			debug("uncaught(): bubbling exception due to --allow-uncaught");
+			throw err;
+		}
+		if (this.state === constants.STATE_STOPPED) {
+			debug("uncaught(): throwing after run has completed!");
+			throw err;
+		}
+		if (err) debug("uncaught(): got truthy exception %O", err);
+		else {
+			debug("uncaught(): undefined/falsy exception");
+			err = createInvalidExceptionError("Caught falsy/undefined exception which would otherwise be uncaught. No stack trace found; try a debugger", err);
+		}
+		if (!isError(err)) {
+			err = thrown2Error(err);
+			debug("uncaught(): converted \"error\" %o to Error", err);
+		}
+		err.uncaught = true;
+		var runnable = this.currentRunnable;
+		if (!runnable) {
+			runnable = new Runnable("Uncaught error outside test suite");
+			debug("uncaught(): no current Runnable; created a phony one");
+			runnable.parent = this.suite;
+			if (this.state === constants.STATE_RUNNING) {
+				debug("uncaught(): failing gracefully");
+				this.fail(runnable, err);
+			} else {
+				debug("uncaught(): test run has not yet started; unrecoverable");
+				this.emit(constants.EVENT_RUN_BEGIN);
+				this.fail(runnable, err);
+				this.emit(constants.EVENT_RUN_END);
+			}
+			return;
+		}
+		runnable.clearTimeout();
+		if (runnable.isFailed()) {
+			debug("uncaught(): Runnable has already failed");
+			return;
+		} else if (runnable.isPending()) {
+			debug("uncaught(): pending Runnable wound up failing!");
+			this.fail(runnable, err, true);
+			return;
+		}
+		if (runnable.isPassed()) {
+			debug("uncaught(): Runnable has already passed; bailing gracefully");
+			this.fail(runnable, err);
+			this.abort();
+		} else {
+			debug("uncaught(): forcing Runnable to complete with Error");
+			return runnable.callback(err);
+		}
+	};
+	/**
+	* Run the root suite and invoke `fn(failures)`
+	* on completion.
+	*
+	* @public
+	* @memberof Runner
+	* @param {Function} fn - Callback when finished
+	* @param {RunnerOptions} [opts] - For subclasses
+	* @returns {Runner} Runner instance.
+	*/
+	Runner.prototype.run = function(fn, opts = {}) {
+		var rootSuite = this.suite;
+		var options = opts.options || {};
+		debug("run(): got options: %O", options);
+		fn = fn || function() {};
+		const end = () => {
+			if (!this.total && this._opts.failZero) this.failures = 1;
+			debug("run(): root suite completed; emitting %s", constants.EVENT_RUN_END);
+			this.emit(constants.EVENT_RUN_END);
+		};
+		const begin = () => {
+			debug("run(): emitting %s", constants.EVENT_RUN_BEGIN);
+			this.emit(constants.EVENT_RUN_BEGIN);
+			debug("run(): emitted %s", constants.EVENT_RUN_BEGIN);
+			this.runSuite(rootSuite, end);
+		};
+		const prepare = () => {
+			debug("run(): starting");
+			if (rootSuite.hasOnly()) {
+				rootSuite.filterOnly();
+				debug("run(): filtered exclusive Runnables");
+			}
+			this.state = constants.STATE_RUNNING;
+			if (this._opts.delay) {
+				this.emit(constants.EVENT_DELAY_END);
+				debug("run(): \"delay\" ended");
+			}
+			return begin();
+		};
+		if (this._opts.cleanReferencesAfterRun) this.on(constants.EVENT_SUITE_END, (suite) => {
+			suite.cleanReferences();
+		});
+		this.on(constants.EVENT_RUN_END, function() {
+			this.state = constants.STATE_STOPPED;
+			debug("run(): emitted %s", constants.EVENT_RUN_END);
+			fn(this.failures);
+		});
+		this._removeEventListener(process, "uncaughtException", this.uncaught);
+		this._removeEventListener(process, "unhandledRejection", this.unhandled);
+		this._addEventListener(process, "uncaughtException", this.uncaught);
+		this._addEventListener(process, "unhandledRejection", this.unhandled);
+		if (this._opts.delay) {
+			this.emit(constants.EVENT_DELAY_BEGIN, rootSuite);
+			rootSuite.once(EVENT_ROOT_SUITE_RUN, prepare);
+			debug("run(): waiting for green light due to --delay");
+		} else Runner.immediately(prepare);
+		return this;
+	};
+	/**
+	* Toggle partial object linking behavior; used for building object references from
+	* unique ID's. Does nothing in serial mode, because the object references already exist.
+	* Subclasses can implement this (e.g., `ParallelBufferedRunner`)
+	* @abstract
+	* @param {boolean} [value] - If `true`, enable partial object linking, otherwise disable
+	* @returns {Runner}
+	* @chainable
+	* @public
+	* @example
+	* // this reporter needs proper object references when run in parallel mode
+	* class MyReporter {
+	*   constructor(runner) {
+	*     runner.linkPartialObjects(true)
+	*       .on(EVENT_SUITE_BEGIN, suite => {
+	*         // this Suite may be the same object...
+	*       })
+	*       .on(EVENT_TEST_BEGIN, test => {
+	*         // ...as the `test.parent` property
+	*       });
+	*   }
+	* }
+	*/
+	Runner.prototype.linkPartialObjects = function() {
+		return this;
+	};
+	Runner.prototype.runAsync = async function runAsync(opts = {}) {
+		return new Promise((resolve) => {
+			this.run(resolve, opts);
+		});
+	};
+	/**
+	* Cleanly abort execution.
+	*
+	* @memberof Runner
+	* @public
+	* @return {Runner} Runner instance.
+	*/
+	Runner.prototype.abort = function() {
+		debug("abort(): aborting");
+		this._abort = true;
+		return this;
+	};
+	/**
+	* Returns `true` if Mocha is running in parallel mode.  For reporters.
+	*
+	* Subclasses should return an appropriate value.
+	* @public
+	* @returns {false}
+	*/
+	Runner.prototype.isParallelMode = function isParallelMode() {
+		return false;
+	};
+	/**
+	* Configures an alternate reporter for worker processes to use. Subclasses
+	* using worker processes should implement this.
+	* @public
+	* @param {string} path - Absolute path to alternate reporter for worker processes to use
+	* @returns {Runner}
+	* @throws When in serial mode
+	* @chainable
+	* @abstract
+	*/
+	Runner.prototype.workerReporter = function() {
+		throw createUnsupportedError("workerReporter() not supported in serial mode");
+	};
+	/**
+	* Filter leaks with the given globals flagged as `ok`.
+	*
+	* @private
+	* @param {Array} ok
+	* @param {Array} globals
+	* @return {Array}
+	*/
+	function filterLeaks(ok, globals$1) {
+		return globals$1.filter(function(key) {
+			if (/^\d+/.test(key)) return false;
+			if (global.navigator && /^getInterface/.test(key)) return false;
+			if (global.navigator && /^\d+/.test(key)) return false;
+			if (/^mocha-/.test(key)) return false;
+			return !ok.filter(function(ok$1) {
+				if (~ok$1.indexOf("*")) return key.indexOf(ok$1.split("*")[0]) === 0;
+				return key === ok$1;
+			}).length && (!global.navigator || key !== "onerror");
+		});
+	}
+	/**
+	* Check if argument is an instance of Error object or a duck-typed equivalent.
+	*
+	* @private
+	* @param {Object} err - object to check
+	* @param {string} err.message - error message
+	* @returns {boolean}
+	*/
+	function isError(err) {
+		return err instanceof Error || err && typeof err.message === "string";
+	}
+	/**
+	*
+	* Converts thrown non-extensible type into proper Error.
+	*
+	* @private
+	* @param {*} thrown - Non-extensible type thrown by code
+	* @return {Error}
+	*/
+	function thrown2Error(err) {
+		return /* @__PURE__ */ new Error(`the ${utils.canonicalType(err)} ${stringify(err)} was thrown, throw an Error :)`);
+	}
+	Runner.constants = constants;
+	/**
+	* Node.js' `EventEmitter`
+	* @external EventEmitter
+	* @see {@link https://nodejs.org/api/events.html#events_class_eventemitter}
+	*/
+	module.exports = Runner;
+}) });
+
+//#endregion
+export default require_runner();
+
+export { require_runner };