@eggjs/mock 6.1.0-beta.10 → 6.1.0-beta.11

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

@@ -1,922 +0,0 @@
-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 };