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

package/dist/node_modules/.pnpm/is-unicode-supported@0.1.0/node_modules/is-unicode-supported/index.js

@@ -0,0 +1,14 @@
+import { __commonJS } from "../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/is-unicode-supported@0.1.0/node_modules/is-unicode-supported/index.js
+var require_is_unicode_supported = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/is-unicode-supported@0.1.0/node_modules/is-unicode-supported/index.js": ((exports, module) => {
+	module.exports = () => {
+		if (process.platform !== "win32") return true;
+		return Boolean(process.env.CI) || Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
+	};
+}) });
+
+//#endregion
+export default require_is_unicode_supported();
+
+export { require_is_unicode_supported };

package/dist/node_modules/.pnpm/log-symbols@4.1.0/node_modules/log-symbols/index.js

@@ -0,0 +1,27 @@
+import { __commonJS } from "../../../../../_virtual/rolldown_runtime.js";
+import { require_source } from "../../../chalk@4.1.2/node_modules/chalk/source/index.js";
+import { require_is_unicode_supported } from "../../../is-unicode-supported@0.1.0/node_modules/is-unicode-supported/index.js";
+
+//#region ../../node_modules/.pnpm/log-symbols@4.1.0/node_modules/log-symbols/index.js
+var require_log_symbols = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/log-symbols@4.1.0/node_modules/log-symbols/index.js": ((exports, module) => {
+	const chalk = require_source();
+	const isUnicodeSupported = require_is_unicode_supported();
+	const main = {
+		info: chalk.blue("ℹ"),
+		success: chalk.green("✔"),
+		warning: chalk.yellow("⚠"),
+		error: chalk.red("✖")
+	};
+	const fallback = {
+		info: chalk.blue("i"),
+		success: chalk.green("√"),
+		warning: chalk.yellow("‼"),
+		error: chalk.red("×")
+	};
+	module.exports = isUnicodeSupported() ? main : fallback;
+}) });
+
+//#endregion
+export default require_log_symbols();
+
+export { require_log_symbols };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/index.js

@@ -0,0 +1,12 @@
+import { __commonJS } from "../../../../../_virtual/rolldown_runtime.js";
+import { require_mocha as require_mocha$1 } from "./lib/mocha.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/index.js
+var require_mocha = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/index.js": ((exports, module) => {
+	module.exports = require_mocha$1();
+}) });
+
+//#endregion
+export default require_mocha();
+
+export { require_mocha };

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

@@ -0,0 +1,83 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/context.js
+var require_context = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/context.js": ((exports, module) => {
+	/**
+	* @typedef {import('./runnable.js')} Runnable
+	*/
+	/**
+	* @module Context
+	*/
+	/**
+	* Expose `Context`.
+	*/
+	module.exports = Context;
+	/**
+	* Initialize a new `Context`.
+	*
+	* @private
+	*/
+	function Context() {}
+	/**
+	* Set or get the context `Runnable` to `runnable`.
+	*
+	* @private
+	* @param {Runnable} runnable
+	* @return {Context} context
+	*/
+	Context.prototype.runnable = function(runnable) {
+		if (!arguments.length) return this._runnable;
+		this.test = this._runnable = runnable;
+		return this;
+	};
+	/**
+	* Set or get test timeout `ms`.
+	*
+	* @private
+	* @param {number} ms
+	* @return {Context} self
+	*/
+	Context.prototype.timeout = function(ms) {
+		if (!arguments.length) return this.runnable().timeout();
+		this.runnable().timeout(ms);
+		return this;
+	};
+	/**
+	* Set or get test slowness threshold `ms`.
+	*
+	* @private
+	* @param {number} ms
+	* @return {Context} self
+	*/
+	Context.prototype.slow = function(ms) {
+		if (!arguments.length) return this.runnable().slow();
+		this.runnable().slow(ms);
+		return this;
+	};
+	/**
+	* Mark a test as skipped.
+	*
+	* @private
+	* @throws Pending
+	*/
+	Context.prototype.skip = function() {
+		this.runnable().skip();
+	};
+	/**
+	* Set or get a number of allowed retries on failed tests
+	*
+	* @private
+	* @param {number} n
+	* @return {Context} self
+	*/
+	Context.prototype.retries = function(n) {
+		if (!arguments.length) return this.runnable().retries();
+		this.runnable().retries(n);
+		return this;
+	};
+}) });
+
+//#endregion
+export default require_context();
+
+export { require_context };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/error-constants.js

@@ -0,0 +1,35 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/error-constants.js
+var require_error_constants = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/error-constants.js": ((exports, module) => {
+	/**
+	* When Mocha throws exceptions (or rejects `Promise`s), it attempts to assign a `code` property to the `Error` object, for easier handling. These are the potential values of `code`.
+	* @public
+	* @namespace
+	* @memberof module:lib/errors
+	*/
+	var constants = {
+		FATAL: "ERR_MOCHA_FATAL",
+		INVALID_ARG_TYPE: "ERR_MOCHA_INVALID_ARG_TYPE",
+		INVALID_ARG_VALUE: "ERR_MOCHA_INVALID_ARG_VALUE",
+		INVALID_EXCEPTION: "ERR_MOCHA_INVALID_EXCEPTION",
+		INVALID_INTERFACE: "ERR_MOCHA_INVALID_INTERFACE",
+		INVALID_REPORTER: "ERR_MOCHA_INVALID_REPORTER",
+		MULTIPLE_DONE: "ERR_MOCHA_MULTIPLE_DONE",
+		NO_FILES_MATCH_PATTERN: "ERR_MOCHA_NO_FILES_MATCH_PATTERN",
+		UNSUPPORTED: "ERR_MOCHA_UNSUPPORTED",
+		INSTANCE_ALREADY_RUNNING: "ERR_MOCHA_INSTANCE_ALREADY_RUNNING",
+		INSTANCE_ALREADY_DISPOSED: "ERR_MOCHA_INSTANCE_ALREADY_DISPOSED",
+		FORBIDDEN_EXCLUSIVITY: "ERR_MOCHA_FORBIDDEN_EXCLUSIVITY",
+		INVALID_PLUGIN_IMPLEMENTATION: "ERR_MOCHA_INVALID_PLUGIN_IMPLEMENTATION",
+		INVALID_PLUGIN_DEFINITION: "ERR_MOCHA_INVALID_PLUGIN_DEFINITION",
+		TIMEOUT: "ERR_MOCHA_TIMEOUT",
+		UNPARSABLE_FILE: "ERR_MOCHA_UNPARSABLE_FILE"
+	};
+	module.exports = { constants };
+}) });
+
+//#endregion
+export default require_error_constants();
+
+export { require_error_constants };

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

@@ -0,0 +1,392 @@
+import { __commonJS, __require } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_error_constants } from "./error-constants.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/errors.js
+var require_errors = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/errors.js": ((exports, module) => {
+	/**
+	* @typedef {import('./mocha.js')} Mocha
+	* @typedef {import('./runnable.js')} Runnable
+	* @typedef {import('./types.d.ts').MochaTimeoutError} MochaTimeoutError
+	* @typedef {import('./types.d.ts').PluginDefinition} PluginDefinition
+	*/
+	const { format } = __require("node:util");
+	const { constants } = require_error_constants();
+	/**
+	* Contains error codes, factory functions to create throwable error objects,
+	* and warning/deprecation functions.
+	* @module
+	*/
+	/**
+	* process.emitWarning or a polyfill
+	* @see https://nodejs.org/api/process.html#process_process_emitwarning_warning_options
+	* @ignore
+	*/
+	const emitWarning = (msg, type) => {
+		if (process.emitWarning) process.emitWarning(msg, type);
+		else
+ /* istanbul ignore next */
+		process.nextTick(function() {
+			console.warn(type + ": " + msg);
+		});
+	};
+	/**
+	* Show a deprecation warning. Each distinct message is only displayed once.
+	* Ignores empty messages.
+	*
+	* @param {string} [msg] - Warning to print
+	* @private
+	*/
+	const deprecate = (msg) => {
+		msg = String(msg);
+		if (msg && !deprecate.cache[msg]) {
+			deprecate.cache[msg] = true;
+			emitWarning(msg, "DeprecationWarning");
+		}
+	};
+	deprecate.cache = {};
+	/**
+	* Show a generic warning.
+	* Ignores empty messages.
+	*
+	* @param {string} [msg] - Warning to print
+	* @private
+	*/
+	const warn = (msg) => {
+		if (msg) emitWarning(msg);
+	};
+	/**
+	* A set containing all string values of all Mocha error constants, for use by {@link isMochaError}.
+	* @private
+	*/
+	const MOCHA_ERRORS = new Set(Object.values(constants));
+	/**
+	* Creates an error object to be thrown when no files to be tested could be found using specified pattern.
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @param {string} pattern - User-specified argument value.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createNoFilesMatchPatternError(message, pattern) {
+		var err = new Error(message);
+		err.code = constants.NO_FILES_MATCH_PATTERN;
+		err.pattern = pattern;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when the reporter specified in the options was not found.
+	*
+	* @public
+	* @param {string} message - Error message to be displayed.
+	* @param {string} reporter - User-specified reporter value.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createInvalidReporterError(message, reporter) {
+		var err = new TypeError(message);
+		err.code = constants.INVALID_REPORTER;
+		err.reporter = reporter;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when the interface specified in the options was not found.
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @param {string} ui - User-specified interface value.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createInvalidInterfaceError(message, ui) {
+		var err = new Error(message);
+		err.code = constants.INVALID_INTERFACE;
+		err.interface = ui;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when a behavior, option, or parameter is unsupported.
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createUnsupportedError(message) {
+		var err = new Error(message);
+		err.code = constants.UNSUPPORTED;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when an argument is missing.
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @param {string} argument - Argument name.
+	* @param {string} expected - Expected argument datatype.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createMissingArgumentError(message, argument, expected) {
+		return createInvalidArgumentTypeError(message, argument, expected);
+	}
+	/**
+	* Creates an error object to be thrown when an argument did not use the supported type
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @param {string} argument - Argument name.
+	* @param {string} expected - Expected argument datatype.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createInvalidArgumentTypeError(message, argument, expected) {
+		var err = new TypeError(message);
+		err.code = constants.INVALID_ARG_TYPE;
+		err.argument = argument;
+		err.expected = expected;
+		err.actual = typeof argument;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when an argument did not use the supported value
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @param {string} argument - Argument name.
+	* @param {string} value - Argument value.
+	* @param {string} [reason] - Why value is invalid.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createInvalidArgumentValueError(message, argument, value, reason) {
+		var err = new TypeError(message);
+		err.code = constants.INVALID_ARG_VALUE;
+		err.argument = argument;
+		err.value = value;
+		err.reason = typeof reason !== "undefined" ? reason : "is invalid";
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when an exception was caught, but the `Error` is falsy or undefined.
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createInvalidExceptionError(message, value) {
+		var err = new Error(message);
+		err.code = constants.INVALID_EXCEPTION;
+		err.valueType = typeof value;
+		err.value = value;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when an unrecoverable error occurs.
+	*
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @returns {Error} instance detailing the error condition
+	*/
+	function createFatalError(message, value) {
+		var err = new Error(message);
+		err.code = constants.FATAL;
+		err.valueType = typeof value;
+		err.value = value;
+		return err;
+	}
+	/**
+	* Dynamically creates a plugin-type-specific error based on plugin type
+	* @param {string} message - Error message
+	* @param {"reporter"|"ui"} pluginType - Plugin type. Future: expand as needed
+	* @param {string} [pluginId] - Name/path of plugin, if any
+	* @throws When `pluginType` is not known
+	* @public
+	* @static
+	* @returns {Error}
+	*/
+	function createInvalidLegacyPluginError(message, pluginType, pluginId) {
+		switch (pluginType) {
+			case "reporter": return createInvalidReporterError(message, pluginId);
+			case "ui": return createInvalidInterfaceError(message, pluginId);
+			default: throw new Error("unknown pluginType \"" + pluginType + "\"");
+		}
+	}
+	/**
+	* **DEPRECATED**.  Use {@link createInvalidLegacyPluginError} instead  Dynamically creates a plugin-type-specific error based on plugin type
+	* @deprecated
+	* @param {string} message - Error message
+	* @param {"reporter"|"interface"} pluginType - Plugin type. Future: expand as needed
+	* @param {string} [pluginId] - Name/path of plugin, if any
+	* @throws When `pluginType` is not known
+	* @public
+	* @static
+	* @returns {Error}
+	*/
+	function createInvalidPluginError(...args) {
+		deprecate("Use createInvalidLegacyPluginError() instead");
+		return createInvalidLegacyPluginError(...args);
+	}
+	/**
+	* Creates an error object to be thrown when a mocha object's `run` method is executed while it is already disposed.
+	* @param {string} message The error message to be displayed.
+	* @param {boolean} cleanReferencesAfterRun the value of `cleanReferencesAfterRun`
+	* @param {Mocha} instance the mocha instance that throw this error
+	* @static
+	*/
+	function createMochaInstanceAlreadyDisposedError(message, cleanReferencesAfterRun, instance) {
+		var err = new Error(message);
+		err.code = constants.INSTANCE_ALREADY_DISPOSED;
+		err.cleanReferencesAfterRun = cleanReferencesAfterRun;
+		err.instance = instance;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when a mocha object's `run` method is called while a test run is in progress.
+	* @param {string} message The error message to be displayed.
+	* @static
+	* @public
+	*/
+	function createMochaInstanceAlreadyRunningError(message, instance) {
+		var err = new Error(message);
+		err.code = constants.INSTANCE_ALREADY_RUNNING;
+		err.instance = instance;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when done() is called multiple times in a test
+	*
+	* @public
+	* @param {Runnable} runnable - Original runnable
+	* @param {Error} [originalErr] - Original error, if any
+	* @returns {Error} instance detailing the error condition
+	* @static
+	*/
+	function createMultipleDoneError(runnable, originalErr) {
+		var title;
+		try {
+			title = format("<%s>", runnable.fullTitle());
+			if (runnable.parent.root) title += " (of root suite)";
+		} catch (ignored) {
+			title = format("<%s> (of unknown suite)", runnable.title);
+		}
+		var message = format("done() called multiple times in %s %s", runnable.type ? runnable.type : "unknown runnable", title);
+		if (runnable.file) message += format(" of file %s", runnable.file);
+		if (originalErr) message += format("; in addition, done() received error: %s", originalErr);
+		var err = new Error(message);
+		err.code = constants.MULTIPLE_DONE;
+		err.valueType = typeof originalErr;
+		err.value = originalErr;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when `.only()` is used with
+	* `--forbid-only`.
+	* @static
+	* @public
+	* @param {Mocha} mocha - Mocha instance
+	* @returns {Error} Error with code {@link constants.FORBIDDEN_EXCLUSIVITY}
+	*/
+	function createForbiddenExclusivityError(mocha) {
+		var err = /* @__PURE__ */ new Error(mocha.isWorker ? "`.only` is not supported in parallel mode" : "`.only` forbidden by --forbid-only");
+		err.code = constants.FORBIDDEN_EXCLUSIVITY;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when a plugin definition is invalid
+	* @static
+	* @param {string} msg - Error message
+	* @param {PluginDefinition} [pluginDef] - Problematic plugin definition
+	* @public
+	* @returns {Error} Error with code {@link constants.INVALID_PLUGIN_DEFINITION}
+	*/
+	function createInvalidPluginDefinitionError(msg, pluginDef) {
+		const err = new Error(msg);
+		err.code = constants.INVALID_PLUGIN_DEFINITION;
+		err.pluginDef = pluginDef;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when a plugin implementation (user code) is invalid
+	* @static
+	* @param {string} msg - Error message
+	* @param {Object} [opts] - Plugin definition and user-supplied implementation
+	* @param {PluginDefinition} [opts.pluginDef] - Plugin Definition
+	* @param {*} [opts.pluginImpl] - Plugin Implementation (user-supplied)
+	* @public
+	* @returns {Error} Error with code {@link constants.INVALID_PLUGIN_DEFINITION}
+	*/
+	function createInvalidPluginImplementationError(msg, { pluginDef, pluginImpl } = {}) {
+		const err = new Error(msg);
+		err.code = constants.INVALID_PLUGIN_IMPLEMENTATION;
+		err.pluginDef = pluginDef;
+		err.pluginImpl = pluginImpl;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when a runnable exceeds its allowed run time.
+	* @static
+	* @param {string} msg - Error message
+	* @param {number} [timeout] - Timeout in ms
+	* @param {string} [file] - File, if given
+	* @returns {MochaTimeoutError}
+	*/
+	function createTimeoutError(msg, timeout, file) {
+		const err = new Error(msg);
+		err.code = constants.TIMEOUT;
+		err.timeout = timeout;
+		err.file = file;
+		return err;
+	}
+	/**
+	* Creates an error object to be thrown when file is unparsable
+	* @public
+	* @static
+	* @param {string} message - Error message to be displayed.
+	* @returns {Error} Error with code {@link constants.UNPARSABLE_FILE}
+	*/
+	function createUnparsableFileError(message) {
+		var err = new Error(message);
+		err.code = constants.UNPARSABLE_FILE;
+		return err;
+	}
+	/**
+	* Returns `true` if an error came out of Mocha.
+	* _Can suffer from false negatives, but not false positives._
+	* @static
+	* @public
+	* @param {*} err - Error, or anything
+	* @returns {boolean}
+	*/
+	const isMochaError = (err) => Boolean(err && typeof err === "object" && MOCHA_ERRORS.has(err.code));
+	module.exports = {
+		createFatalError,
+		createForbiddenExclusivityError,
+		createInvalidArgumentTypeError,
+		createInvalidArgumentValueError,
+		createInvalidExceptionError,
+		createInvalidInterfaceError,
+		createInvalidLegacyPluginError,
+		createInvalidPluginDefinitionError,
+		createInvalidPluginError,
+		createInvalidPluginImplementationError,
+		createInvalidReporterError,
+		createMissingArgumentError,
+		createMochaInstanceAlreadyDisposedError,
+		createMochaInstanceAlreadyRunningError,
+		createMultipleDoneError,
+		createNoFilesMatchPatternError,
+		createTimeoutError,
+		createUnparsableFileError,
+		createUnsupportedError,
+		deprecate,
+		isMochaError,
+		warn
+	};
+}) });
+
+//#endregion
+export default require_errors();
+
+export { require_errors };

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

@@ -0,0 +1,86 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "./utils.js";
+import { require_runnable } from "./runnable.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/hook.js
+var require_hook = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/hook.js": ((exports, module) => {
+	var Runnable = require_runnable();
+	const { inherits, constants } = require_utils();
+	const { MOCHA_ID_PROP_NAME } = constants;
+	/**
+	* Expose `Hook`.
+	*/
+	module.exports = Hook;
+	/**
+	* Initialize a new `Hook` with the given `title` and callback `fn`
+	*
+	* @class
+	* @extends Runnable
+	* @param {String} title
+	* @param {Function} fn
+	*/
+	function Hook(title, fn) {
+		Runnable.call(this, title, fn);
+		this.type = "hook";
+	}
+	/**
+	* Inherit from `Runnable.prototype`.
+	*/
+	inherits(Hook, Runnable);
+	/**
+	* Resets the state for a next run.
+	*/
+	Hook.prototype.reset = function() {
+		Runnable.prototype.reset.call(this);
+		delete this._error;
+	};
+	/**
+	* Get or set the test `err`.
+	*
+	* @memberof Hook
+	* @public
+	* @param {Error} err
+	* @return {Error}
+	*/
+	Hook.prototype.error = function(err) {
+		if (!arguments.length) {
+			err = this._error;
+			this._error = null;
+			return err;
+		}
+		this._error = err;
+	};
+	/**
+	* Returns an object suitable for IPC.
+	* Functions are represented by keys beginning with `$$`.
+	* @private
+	* @returns {Object}
+	*/
+	Hook.prototype.serialize = function serialize() {
+		return {
+			$$currentRetry: this.currentRetry(),
+			$$fullTitle: this.fullTitle(),
+			$$isPending: Boolean(this.isPending()),
+			$$titlePath: this.titlePath(),
+			ctx: this.ctx && this.ctx.currentTest ? { currentTest: {
+				title: this.ctx.currentTest.title,
+				[MOCHA_ID_PROP_NAME]: this.ctx.currentTest.id
+			} } : {},
+			duration: this.duration,
+			file: this.file,
+			parent: {
+				$$fullTitle: this.parent.fullTitle(),
+				[MOCHA_ID_PROP_NAME]: this.parent.id
+			},
+			state: this.state,
+			title: this.title,
+			type: this.type,
+			[MOCHA_ID_PROP_NAME]: this.id
+		};
+	};
+}) });
+
+//#endregion
+export default require_hook();
+
+export { require_hook };