@eggjs/core 7.0.0-beta.20 → 7.0.0-beta.22

package/dist/index.js

@@ -1,2425 +1,12 @@
-import BuiltinModule from "node:module";
-import { debuglog, format, inspect } from "node:util";
-import path from "node:path";
-import fs from "node:fs";
-import { stat } from "node:fs/promises";
-import { importModule, importResolve, isESM, isSupportTypeScript } from "@eggjs/utils";
-import assert from "node:assert";
-import { Application, Application as KoaApplication, Context as Context$1, Context as KoaContext, Request as KoaRequest, Request as Request$1, Response as KoaResponse, Response as Response$1 } from "@eggjs/koa";
-import { EggConsoleLogger } from "egg-logger";
-import { EggRouter as Router } from "@eggjs/router";
-import { EOL } from "node:os";
-import { EventEmitter } from "node:events";
-import { isAsyncFunction, isClass, isGeneratorFunction, isObject, isPrimitive, isPromise } from "is-type-of";
-import { Ready } from "get-ready";
-import { Ready as Ready$1 } from "ready-callback";
-import { homedir } from "node-homedir";
-import { exists, getParamNames, readJSON, readJSONSync } from "utility";
-import { extend } from "@eggjs/extend2";
-import { register } from "tsconfig-paths";
-import { pathMatching } from "egg-path-matching";
-import { diff, now } from "performance-ms";
-import globby from "globby";
-
-//#region src/utils/index.ts
-const debug$6 = debuglog("egg/core/utils");
-const extensions = (typeof module !== "undefined" && module.constructor.length > 1 ? module.constructor : BuiltinModule)._extensions;
-const extensionNames = Object.keys(extensions).concat([".cjs", ".mjs"]);
-debug$6("Module extensions: %j", extensionNames);
-function getCalleeFromStack(withLine, stackIndex) {
-	stackIndex = stackIndex === void 0 ? 2 : stackIndex;
-	const limit = Error.stackTraceLimit;
-	const prep = Error.prepareStackTrace;
-	Error.prepareStackTrace = prepareObjectStackTrace;
-	Error.stackTraceLimit = 5;
-	const obj = {};
-	Error.captureStackTrace(obj);
-	let callSite = obj.stack[stackIndex];
-	let fileName = "";
-	if (callSite) {
-		fileName = callSite.getFileName();
-		/* istanbul ignore if */
-		if (fileName && fileName.endsWith("egg-mock/lib/app.js")) {
-			callSite = obj.stack[stackIndex + 1];
-			fileName = callSite.getFileName();
-		}
-	}
-	Error.prepareStackTrace = prep;
-	Error.stackTraceLimit = limit;
-	if (!callSite || !fileName) return "<anonymous>";
-	if (!withLine) return fileName;
-	return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
-}
-var utils_default = {
-	deprecated(message) {
-		if (debug$6.enabled) console.trace("[@eggjs/core/deprecated] %s", message);
-		else {
-			console.log("[@eggjs/core/deprecated] %s", message);
-			console.log("[@eggjs/core/deprecated] set NODE_DEBUG=@eggjs/core/utils can show call stack");
-		}
-	},
-	extensions,
-	extensionNames,
-	async existsPath(filepath) {
-		try {
-			await stat(filepath);
-			return true;
-		} catch {
-			return false;
-		}
-	},
-	async loadFile(filepath) {
-		debug$6("[loadFile:start] filepath: %s", filepath);
-		try {
-			const extname = path.extname(filepath);
-			if (extname && !extensionNames.includes(extname) && extname !== ".ts") return fs.readFileSync(filepath);
-			return await importModule(filepath, { importDefaultOnly: true });
-		} catch (e) {
-			if (!(e instanceof Error)) {
-				console.trace(e);
-				throw e;
-			}
-			const err = /* @__PURE__ */ new Error(`[egg/core] load file: ${filepath}, error: ${e.message}`);
-			err.cause = e;
-			debug$6("[loadFile] handle %s error: %s", filepath, e);
-			throw err;
-		}
-	},
-	resolvePath(filepath, options) {
-		return importResolve(filepath, options);
-	},
-	methods: [
-		"head",
-		"options",
-		"get",
-		"put",
-		"patch",
-		"post",
-		"delete"
-	],
-	async callFn(fn, args, ctx) {
-		args = args || [];
-		if (typeof fn !== "function") return;
-		return ctx ? fn.call(ctx, ...args) : fn(...args);
-	},
-	getCalleeFromStack,
-	getResolvedFilename(filepath, baseDir) {
-		return filepath.replace(baseDir + path.sep, "").replace(/[/\\]/g, "/");
-	}
-};
-/**
-* Capture call site stack from v8.
-* https://github.com/v8/v8/wiki/Stack-Trace-API
-*/
-function prepareObjectStackTrace(_obj, stack) {
-	return stack;
-}
-
-//#endregion
-//#region src/base_context_class.ts
-/**
-* BaseContextClass is a base class that can be extended,
-* it's instantiated in context level,
-* {@link Helper}, {@link Service} is extending it.
-*/
-var BaseContextClass = class {
-	ctx;
-	app;
-	config;
-	service;
-	/**
-	* @since 1.0.0
-	*/
-	constructor(ctx) {
-		/**
-		* @member {Context} BaseContextClass#ctx
-		* @since 1.0.0
-		*/
-		this.ctx = ctx;
-		/**
-		* @member {Application} BaseContextClass#app
-		* @since 1.0.0
-		*/
-		this.app = ctx.app;
-		/**
-		* @member {Config} BaseContextClass#config
-		* @since 1.0.0
-		*/
-		this.config = ctx.app.config;
-		/**
-		* @member {Service} BaseContextClass#service
-		* @since 1.0.0
-		*/
-		this.service = ctx.service;
-	}
-};
-
-//#endregion
-//#region src/utils/timing.ts
-const debug$5 = debuglog("egg/core/utils/timing");
-var Timing = class {
-	#enable;
-	#startTime;
-	#map;
-	#list;
-	constructor() {
-		this.#enable = true;
-		this.#map = /* @__PURE__ */ new Map();
-		this.#list = [];
-		this.init();
-	}
-	init() {
-		this.start("Process Start", Date.now() - Math.floor(process.uptime() * 1e3));
-		this.end("Process Start");
-		if ("scriptStartTime" in process && typeof process.scriptStartTime === "number") {
-			this.start("Script Start", process.scriptStartTime);
-			this.end("Script Start");
-		}
-	}
-	start(name, start) {
-		if (!name || !this.#enable) return;
-		if (this.#map.has(name)) this.end(name);
-		start = start || Date.now();
-		if (!this.#startTime) this.#startTime = start;
-		const item = {
-			name,
-			start,
-			pid: process.pid,
-			index: this.#list.length
-		};
-		this.#map.set(name, item);
-		this.#list.push(item);
-		debug$5("start %j", item);
-		return item;
-	}
-	end(name) {
-		if (!name || !this.#enable) return;
-		const item = this.#map.get(name);
-		assert(item, `should run timing.start('${name}') first`);
-		item.end = Date.now();
-		item.duration = item.end - item.start;
-		debug$5("end %j", item);
-		return item;
-	}
-	enable() {
-		this.#enable = true;
-	}
-	disable() {
-		this.#enable = false;
-	}
-	clear() {
-		this.#map.clear();
-		this.#list = [];
-	}
-	toJSON() {
-		return this.#list;
-	}
-	itemToString(timelineEnd, item, times) {
-		const isEnd = typeof item.duration === "number";
-		const duration = isEnd ? item.duration : timelineEnd - item.start;
-		const offset = item.start - this.#startTime;
-		const status = `${duration}ms${isEnd ? "" : " NOT_END"}`;
-		const timespan = Math.floor(Number((offset * times).toFixed(6)));
-		let timeline = Math.floor(Number((duration * times).toFixed(6)));
-		timeline = timeline > 0 ? timeline : 1;
-		const message = `#${item.index} ${item.name}`;
-		return " ".repeat(timespan) + "▇".repeat(timeline) + ` [${status}] - ${message}`;
-	}
-	toString(prefix = "egg start timeline:", width = 50) {
-		const timelineEnd = Date.now();
-		const timelineDuration = timelineEnd - this.#startTime;
-		let times = 1;
-		if (timelineDuration > width) times = width / timelineDuration;
-		return prefix + EOL + this.#list.map((item) => this.itemToString(timelineEnd, item, times)).join(EOL);
-	}
-};
-
-//#endregion
-//#region src/lifecycle.ts
-const debug$4 = debuglog("egg/core/lifecycle");
-var Lifecycle = class extends EventEmitter {
-	#init;
-	#readyObject;
-	#bootHooks;
-	#boots;
-	#isClosed;
-	#closeFunctionSet;
-	loadReady;
-	bootReady;
-	options;
-	readyTimeout;
-	constructor(options) {
-		super();
-		options.logger = options.logger ?? new EggConsoleLogger();
-		this.options = options;
-		this.#readyObject = new Ready();
-		this.#bootHooks = [];
-		this.#boots = [];
-		this.#closeFunctionSet = /* @__PURE__ */ new Set();
-		this.#isClosed = false;
-		this.#init = false;
-		this.timing.start(`${this.options.app.type} Start`);
-		const eggReadyTimeoutEnv = Number.parseInt(process.env.EGG_READY_TIMEOUT_ENV || "10000");
-		assert(Number.isInteger(eggReadyTimeoutEnv), `process.env.EGG_READY_TIMEOUT_ENV ${process.env.EGG_READY_TIMEOUT_ENV} should be able to parseInt.`);
-		this.readyTimeout = eggReadyTimeoutEnv;
-		this.#initReady();
-		this.on("ready_stat", (data) => {
-			this.logger.info("[egg/core/lifecycle:ready_stat] end ready task %s, remain %j", data.id, data.remain);
-		}).on("ready_timeout", (id) => {
-			this.logger.warn("[egg/core/lifecycle:ready_timeout] %s seconds later %s was still unable to finish.", this.readyTimeout / 1e3, id);
-		});
-		this.ready((err) => {
-			this.triggerDidReady(err);
-			debug$4("app ready");
-			this.timing.end(`${this.options.app.type} Start`);
-		});
-	}
-	ready(flagOrFunction) {
-		if (flagOrFunction === void 0) return this.#readyObject.ready();
-		return this.#readyObject.ready(flagOrFunction);
-	}
-	get app() {
-		return this.options.app;
-	}
-	get logger() {
-		return this.options.logger;
-	}
-	get timing() {
-		return this.app.timing;
-	}
-	legacyReadyCallback(name, opt) {
-		const timingKeyPrefix = "readyCallback";
-		const timing = this.timing;
-		const cb = this.loadReady.readyCallback(name, opt);
-		const timingKey = `${timingKeyPrefix} in ` + utils_default.getResolvedFilename(name, this.app.baseDir);
-		this.timing.start(timingKey);
-		debug$4("register legacyReadyCallback");
-		return function legacyReadyCallback(...args) {
-			timing.end(timingKey);
-			debug$4("end legacyReadyCallback");
-			cb(...args);
-		};
-	}
-	addBootHook(bootHootOrBootClass) {
-		assert(this.#init === false, "do not add hook when lifecycle has been initialized");
-		this.#bootHooks.push(bootHootOrBootClass);
-	}
-	addFunctionAsBootHook(hook, fullPath) {
-		assert(this.#init === false, "do not add hook when lifecycle has been initialized");
-		class Boot {
-			static fullPath;
-			app;
-			constructor(app) {
-				this.app = app;
-			}
-			configDidLoad() {
-				hook(this.app);
-			}
-		}
-		Boot.fullPath = fullPath;
-		this.#bootHooks.push(Boot);
-	}
-	/**
-	* init boots and trigger config did config
-	*/
-	init() {
-		debug$4("%s init lifecycle", this.app.type);
-		assert(this.#init === false, "lifecycle have been init");
-		this.#init = true;
-		this.#boots = this.#bootHooks.map((BootHootOrBootClass) => {
-			let instance = BootHootOrBootClass;
-			if (isClass(BootHootOrBootClass)) {
-				instance = new BootHootOrBootClass(this.app);
-				if (!instance.fullPath && "fullPath" in BootHootOrBootClass) instance.fullPath = BootHootOrBootClass.fullPath;
-			}
-			debug$4("[init] add boot instance: %o", instance.fullPath);
-			return instance;
-		});
-	}
-	registerBeforeStart(scope, name) {
-		debug$4("%s add registerBeforeStart, name: %o", this.options.app.type, name);
-		this.#registerReadyCallback({
-			scope,
-			ready: this.loadReady,
-			timingKeyPrefix: "Before Start",
-			scopeFullName: name
-		});
-	}
-	registerBeforeClose(fn, fullPath) {
-		assert(typeof fn === "function", "argument should be function");
-		assert(this.#isClosed === false, "app has been closed");
-		if (fullPath) fn.fullPath = fullPath;
-		this.#closeFunctionSet.add(fn);
-		debug$4("%s register beforeClose at %o, count: %d", this.app.type, fullPath, this.#closeFunctionSet.size);
-	}
-	async close() {
-		const closeFns = Array.from(this.#closeFunctionSet);
-		debug$4("%s start trigger %d beforeClose functions", this.app.type, closeFns.length);
-		for (const fn of closeFns.reverse()) {
-			debug$4("%s trigger beforeClose at %o", this.app.type, fn.fullPath);
-			await utils_default.callFn(fn);
-			this.#closeFunctionSet.delete(fn);
-		}
-		this.app.emit("close");
-		this.removeAllListeners();
-		this.app.removeAllListeners();
-		this.#isClosed = true;
-		debug$4("%s closed", this.app.type);
-	}
-	triggerConfigWillLoad() {
-		debug$4("trigger configWillLoad start");
-		for (const boot of this.#boots) if (typeof boot.configWillLoad === "function") {
-			debug$4("trigger configWillLoad at %o", boot.fullPath);
-			boot.configWillLoad();
-		}
-		debug$4("trigger configWillLoad end");
-		this.triggerConfigDidLoad();
-	}
-	triggerConfigDidLoad() {
-		debug$4("trigger configDidLoad start");
-		for (const boot of this.#boots) {
-			if (typeof boot.configDidLoad === "function") {
-				debug$4("trigger configDidLoad at %o", boot.fullPath);
-				boot.configDidLoad();
-			}
-			if (typeof boot.beforeClose === "function") {
-				const beforeClose = boot.beforeClose.bind(boot);
-				this.registerBeforeClose(beforeClose, boot.fullPath);
-			}
-		}
-		debug$4("trigger configDidLoad end");
-		this.triggerDidLoad();
-	}
-	triggerDidLoad() {
-		debug$4("trigger didLoad start");
-		debug$4("loadReady start");
-		this.loadReady.start();
-		for (const boot of this.#boots) if (typeof boot.didLoad === "function") {
-			const didLoad = boot.didLoad.bind(boot);
-			this.#registerReadyCallback({
-				scope: didLoad,
-				ready: this.loadReady,
-				timingKeyPrefix: "Did Load",
-				scopeFullName: boot.fullPath + ":didLoad"
-			});
-		}
-	}
-	triggerWillReady() {
-		debug$4("trigger willReady start");
-		debug$4("bootReady start");
-		this.bootReady.start();
-		for (const boot of this.#boots) if (typeof boot.willReady === "function") {
-			const willReady = boot.willReady.bind(boot);
-			this.#registerReadyCallback({
-				scope: willReady,
-				ready: this.bootReady,
-				timingKeyPrefix: "Will Ready",
-				scopeFullName: boot.fullPath + ":willReady"
-			});
-		}
-	}
-	triggerDidReady(err) {
-		debug$4("trigger didReady start");
-		return (async () => {
-			for (const boot of this.#boots) if (typeof boot.didReady === "function") {
-				debug$4("trigger didReady at %o", boot.fullPath);
-				try {
-					await boot.didReady(err);
-				} catch (err$1) {
-					debug$4("trigger didReady error at %o, error: %s", boot.fullPath, err$1);
-					this.emit("error", err$1);
-				}
-			}
-			debug$4("trigger didReady end");
-		})();
-	}
-	triggerServerDidReady() {
-		debug$4("trigger serverDidReady start");
-		return (async () => {
-			for (const boot of this.#boots) {
-				if (typeof boot.serverDidReady !== "function") continue;
-				debug$4("trigger serverDidReady at %o", boot.fullPath);
-				try {
-					await boot.serverDidReady();
-				} catch (err) {
-					debug$4("trigger serverDidReady error at %o, error: %s", boot.fullPath, err);
-					this.emit("error", err);
-				}
-			}
-			debug$4("trigger serverDidReady end");
-		})();
-	}
-	#initReady() {
-		debug$4("loadReady init");
-		this.loadReady = new Ready$1({
-			timeout: this.readyTimeout,
-			lazyStart: true
-		});
-		this.#delegateReadyEvent(this.loadReady);
-		this.loadReady.ready((err) => {
-			debug$4("loadReady end, err: %o", err);
-			debug$4("trigger didLoad end");
-			if (err) this.ready(err);
-			else this.triggerWillReady();
-		});
-		debug$4("bootReady init");
-		this.bootReady = new Ready$1({
-			timeout: this.readyTimeout,
-			lazyStart: true
-		});
-		this.#delegateReadyEvent(this.bootReady);
-		this.bootReady.ready((err) => {
-			debug$4("bootReady end, err: %o", err);
-			debug$4("trigger willReady end");
-			this.ready(err || true);
-		});
-	}
-	#delegateReadyEvent(ready) {
-		ready.once("error", (err) => ready.ready(err));
-		ready.on("ready_timeout", (id) => this.emit("ready_timeout", id));
-		ready.on("ready_stat", (data) => this.emit("ready_stat", data));
-		ready.on("error", (err) => this.emit("error", err));
-	}
-	#registerReadyCallback(args) {
-		const { scope, ready, timingKeyPrefix, scopeFullName } = args;
-		if (typeof scope !== "function") throw new TypeError("boot only support function");
-		const name = scopeFullName || utils_default.getCalleeFromStack(true, 4);
-		const timingKey = `${timingKeyPrefix} in ` + utils_default.getResolvedFilename(name, this.app.baseDir);
-		this.timing.start(timingKey);
-		debug$4("[registerReadyCallback] start name: %o", name);
-		const done = ready.readyCallback(name);
-		process.nextTick(async () => {
-			try {
-				await utils_default.callFn(scope);
-				debug$4("[registerReadyCallback] end name: %o", name);
-				done();
-				this.timing.end(timingKey);
-			} catch (e) {
-				let err = e;
-				if (!(err instanceof Error)) err = new Error(format("%s", err));
-				done(err);
-				this.timing.end(timingKey);
-			}
-		});
-	}
-};
-
-//#endregion
-//#region src/loader/file_loader.ts
-const debug$3 = debuglog("egg/core/file_loader");
-const FULLPATH = Symbol("EGG_LOADER_ITEM_FULLPATH");
-const EXPORTS = Symbol("EGG_LOADER_ITEM_EXPORTS");
-const CaseStyle = {
-	camel: "camel",
-	lower: "lower",
-	upper: "upper"
-};
-/**
-* Load files from directory to target object.
-* @since 1.0.0
-*/
-var FileLoader = class {
-	static get FULLPATH() {
-		return FULLPATH;
-	}
-	static get EXPORTS() {
-		return EXPORTS;
-	}
-	options;
-	/**
-	* @class
-	* @param {Object} options - options
-	* @param {String|Array} options.directory - directories to be loaded
-	* @param {Object} options.target - attach the target object from loaded files
-	* @param {String} options.match - match the files when load, support glob, default to all js files
-	* @param {String} options.ignore - ignore the files when load, support glob
-	* @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
-	* @param {Boolean} options.call - determine whether invoke when exports is function
-	* @param {Boolean} options.override - determine whether override the property when get the same name
-	* @param {Object} options.inject - an object that be the argument when invoke the function
-	* @param {Function} options.filter - a function that filter the exports which can be loaded
-	* @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
-	*/
-	constructor(options) {
-		assert(options.directory, "options.directory is required");
-		assert(options.target, "options.target is required");
-		this.options = {
-			caseStyle: CaseStyle.camel,
-			call: true,
-			override: false,
-			...options
-		};
-		if (this.options.lowercaseFirst === true) {
-			utils_default.deprecated("lowercaseFirst is deprecated, use caseStyle instead");
-			this.options.caseStyle = CaseStyle.lower;
-		}
-	}
-	/**
-	* attach items to target object. Mapping the directory to properties.
-	* `app/controller/group/repository.js` => `target.group.repository`
-	* @returns {Object} target
-	* @since 1.0.0
-	*/
-	async load() {
-		const items = await this.parse();
-		const target = this.options.target;
-		for (const item of items) {
-			debug$3("[load] loading item: fullpath: %s, properties: %o", item.fullpath, item.properties);
-			item.properties.reduce((target$1, property, index) => {
-				let obj;
-				const properties = item.properties.slice(0, index + 1).join(".");
-				if (index === item.properties.length - 1) {
-					if (property in target$1 && !this.options.override) throw new Error(`can't overwrite property '${properties}' from ${target$1[property][FULLPATH]} by ${item.fullpath}`);
-					obj = item.exports;
-					if (obj && !isPrimitive(obj)) {
-						Reflect.set(obj, FULLPATH, item.fullpath);
-						Reflect.set(obj, EXPORTS, true);
-					}
-				} else obj = target$1[property] || {};
-				target$1[property] = obj;
-				if (debug$3.enabled) debug$3("[load] loaded item properties: %o => keys: %j, index: %d", properties, Object.keys(obj), index);
-				return obj;
-			}, target);
-		}
-		return target;
-	}
-	/**
-	* Parse files from given directories, then return an items list, each item contains properties and exports.
-	*
-	* For example, parse `app/controller/group/repository.js`
-	*
-	* ```
-	* module.exports = app => {
-	*   return class RepositoryController extends app.Controller {};
-	* }
-	* ```
-	*
-	* It returns a item
-	*
-	* ```
-	* {
-	*   properties: [ 'group', 'repository' ],
-	*   exports: app => { ... },
-	* }
-	* ```
-	*
-	* `Properties` is an array that contains the directory of a filepath.
-	*
-	* `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
-	* @returns {Array} items
-	* @since 1.0.0
-	*/
-	async parse() {
-		let files = this.options.match;
-		if (files) files = Array.isArray(files) ? files : [files];
-		else files = isSupportTypeScript() ? ["**/*.(js|ts)", "!**/*.d.ts"] : ["**/*.js"];
-		let ignore = this.options.ignore;
-		if (ignore) {
-			ignore = Array.isArray(ignore) ? ignore : [ignore];
-			ignore = ignore.filter((f) => !!f).map((f) => "!" + f);
-			files = files.concat(ignore);
-		}
-		let directories = this.options.directory;
-		if (!Array.isArray(directories)) directories = [directories];
-		const filter = typeof this.options.filter === "function" ? this.options.filter : null;
-		const items = [];
-		debug$3("[parse] parsing directories: %j", directories);
-		for (const directory of directories) {
-			const filepaths = globby.sync(files, { cwd: directory });
-			debug$3("[parse] globby files: %o, cwd: %o => %o", files, directory, filepaths);
-			for (const filepath of filepaths) {
-				const fullpath = path.join(directory, filepath);
-				if (!fs.statSync(fullpath).isFile()) continue;
-				if (filepath.endsWith(".js")) {
-					const filepathTs = filepath.replace(/\.js$/, ".ts");
-					if (filepaths.includes(filepathTs)) {
-						debug$3("[parse] ignore %s, because %s exists", fullpath, filepathTs);
-						continue;
-					}
-				}
-				const properties = getProperties(filepath, this.options.caseStyle);
-				const pathName = directory.split(/[/\\]/).slice(-1) + "." + properties.join(".");
-				const exports = await getExports(fullpath, this.options, pathName);
-				if (exports === null || exports === void 0 || filter && filter(exports) === false) continue;
-				if (isClass(exports)) {
-					exports.prototype.pathName = pathName;
-					exports.prototype.fullPath = fullpath;
-				}
-				items.push({
-					fullpath,
-					properties,
-					exports
-				});
-				debug$3("[parse] parse %s, properties %j, exports %o", fullpath, properties, exports);
-			}
-		}
-		return items;
-	}
-};
-function getProperties(filepath, caseStyle) {
-	if (typeof caseStyle === "function") {
-		const result = caseStyle(filepath);
-		assert(Array.isArray(result), `caseStyle expect an array, but got ${JSON.stringify(result)}`);
-		return result;
-	}
-	return defaultCamelize(filepath, caseStyle);
-}
-async function getExports(fullpath, options, pathName) {
-	let exports = await utils_default.loadFile(fullpath);
-	if (options.initializer) {
-		exports = options.initializer(exports, {
-			path: fullpath,
-			pathName
-		});
-		debug$3("[getExports] after initializer => %o", exports);
-	}
-	if (isGeneratorFunction(exports)) throw new TypeError(`Support for generators was removed, fullpath: ${fullpath}`);
-	if (isClass(exports) || isAsyncFunction(exports)) return exports;
-	if (options.call && typeof exports === "function") {
-		exports = exports(options.inject);
-		if (exports !== null && exports !== void 0) return exports;
-	}
-	return exports;
-}
-function defaultCamelize(filepath, caseStyle) {
-	return filepath.slice(0, filepath.lastIndexOf(".")).split("/").map((property) => {
-		if (!/^[a-z][a-z0-9_-]*$/i.test(property)) throw new Error(`${property} is not match 'a-z0-9_-' in ${filepath}`);
-		property = property.replaceAll(/[_-][a-z]/gi, (s) => s.slice(1).toUpperCase());
-		let first = property[0];
-		if (caseStyle === CaseStyle.lower) first = first.toLowerCase();
-		else if (caseStyle === CaseStyle.upper) first = first.toUpperCase();
-		return first + property.slice(1);
-	});
-}
-
-//#endregion
-//#region src/loader/context_loader.ts
-const CLASS_LOADER = Symbol("classLoader");
-var ClassLoader = class {
-	_cache = /* @__PURE__ */ new Map();
-	_ctx;
-	constructor(options) {
-		assert(options.ctx, "options.ctx is required");
-		const properties = options.properties;
-		this._ctx = options.ctx;
-		for (const property in properties) this.#defineProperty(property, properties[property]);
-	}
-	#defineProperty(property, values) {
-		Object.defineProperty(this, property, { get() {
-			let instance = this._cache.get(property);
-			if (!instance) {
-				instance = getInstance(values, this._ctx);
-				this._cache.set(property, instance);
-			}
-			return instance;
-		} });
-	}
-};
-/**
-* Same as {@link FileLoader}, but it will attach file to `inject[fieldClass]`.
-* The exports will be lazy loaded, such as `ctx.group.repository`.
-* @augments FileLoader
-* @since 1.0.0
-*/
-var ContextLoader = class extends FileLoader {
-	#inject;
-	/**
-	* @class
-	* @param {Object} options - options same as {@link FileLoader}
-	* @param {String} options.fieldClass - determine the field name of inject object.
-	*/
-	constructor(options) {
-		assert(options.property, "options.property is required");
-		assert(options.inject, "options.inject is required");
-		const target = {};
-		if (options.fieldClass) options.inject[options.fieldClass] = target;
-		super({
-			...options,
-			target
-		});
-		this.#inject = this.options.inject;
-		const app = this.#inject;
-		const property = options.property;
-		Object.defineProperty(app.context, property, { get() {
-			const ctx = this;
-			if (!ctx[CLASS_LOADER]) ctx[CLASS_LOADER] = /* @__PURE__ */ new Map();
-			const classLoader = ctx[CLASS_LOADER];
-			let instance = classLoader.get(property);
-			if (!instance) {
-				instance = getInstance(target, ctx);
-				classLoader.set(property, instance);
-			}
-			return instance;
-		} });
-	}
-};
-function getInstance(values, ctx) {
-	const Class = values[EXPORTS] ? values : null;
-	let instance;
-	if (Class) if (isClass(Class)) instance = new Class(ctx);
-	else instance = Class;
-	else if (isPrimitive(values)) instance = values;
-	else instance = new ClassLoader({
-		ctx,
-		properties: values
-	});
-	return instance;
-}
-
-//#endregion
-//#region src/utils/sequencify.ts
-const debug$2 = debuglog("egg/core/utils/sequencify");
-function sequence(tasks, names, result, missing, recursive, nest, optional, parent) {
-	for (const name of names) {
-		if (result.requires[name]) continue;
-		const node = tasks[name];
-		if (!node) {
-			if (optional === true) continue;
-			missing.push(name);
-		} else if (nest.includes(name)) {
-			nest.push(name);
-			recursive.push(...nest.slice(0));
-			nest.pop();
-		} else if (node.dependencies.length > 0 || node.optionalDependencies.length > 0) {
-			nest.push(name);
-			if (node.dependencies.length > 0) sequence(tasks, node.dependencies, result, missing, recursive, nest, optional, name);
-			if (node.optionalDependencies.length > 0) sequence(tasks, node.optionalDependencies, result, missing, recursive, nest, true, name);
-			nest.pop();
-		}
-		if (!optional) {
-			result.requires[name] = true;
-			debug$2("task: %s is enabled by %s", name, parent);
-		}
-		if (!result.sequence.includes(name)) result.sequence.push(name);
-	}
-}
-function sequencify(tasks, names) {
-	const result = {
-		sequence: [],
-		requires: {}
-	};
-	const missing = [];
-	const recursive = [];
-	sequence(tasks, names, result, missing, recursive, [], false, "app");
-	if (missing.length > 0 || recursive.length > 0) result.sequence = [];
-	return {
-		sequence: result.sequence.filter((item) => result.requires[item]),
-		missingTasks: missing,
-		recursiveDependencies: recursive
-	};
-}
-
-//#endregion
-//#region src/loader/egg_loader.ts
-const debug$1 = debuglog("egg/core/loader/egg_loader");
-const originalPrototypes = {
-	request: Request$1.prototype,
-	response: Response$1.prototype,
-	context: Context$1.prototype,
-	application: Application.prototype
-};
-var EggLoader = class {
-	#requiredCount = 0;
-	options;
-	timing;
-	pkg;
-	eggPaths;
-	serverEnv;
-	serverScope;
-	appInfo;
-	dirs;
-	/**
-	* @class
-	* @param {Object} options - options
-	* @param {String} options.baseDir - the directory of application
-	* @param {EggCore} options.app - Application instance
-	* @param {Logger} options.logger - logger
-	* @param {Object} [options.plugins] - custom plugins
-	* @since 1.0.0
-	*/
-	constructor(options) {
-		this.options = options;
-		assert(fs.existsSync(this.options.baseDir), `${this.options.baseDir} not exists`);
-		assert(this.options.app, "options.app is required");
-		assert(this.options.logger, "options.logger is required");
-		this.timing = this.app.timing || new Timing();
-		/**
-		* @member {Object} EggLoader#pkg
-		* @see {@link AppInfo#pkg}
-		* @since 1.0.0
-		*/
-		this.pkg = readJSONSync(path.join(this.options.baseDir, "package.json"));
-		if (process.env.EGG_TYPESCRIPT === "true" || this.pkg.egg && this.pkg.egg.typescript) {
-			const tsConfigFile = path.join(this.options.baseDir, "tsconfig.json");
-			if (fs.existsSync(tsConfigFile)) register({ cwd: this.options.baseDir });
-			else this.logger.info("[@eggjs/core/egg_loader] skip register \"tsconfig-paths\" because tsconfig.json not exists at %s", tsConfigFile);
-		}
-		/**
-		* All framework directories.
-		*
-		* You can extend Application of egg, the entry point is options.app,
-		*
-		* loader will find all directories from the prototype of Application,
-		* you should define `Symbol.for('egg#eggPath')` property.
-		*
-		* ```ts
-		* // src/example.ts
-		* import { Application } from 'egg';
-		* class ExampleApplication extends Application {
-		*   get [Symbol.for('egg#eggPath')]() {
-		*     return baseDir;
-		*   }
-		* }
-		* ```
-		* @member {Array} EggLoader#eggPaths
-		* @see EggLoader#getEggPaths
-		* @since 1.0.0
-		*/
-		this.eggPaths = this.getEggPaths();
-		debug$1("Loaded eggPaths %j", this.eggPaths);
-		/**
-		* @member {String} EggLoader#serverEnv
-		* @see AppInfo#env
-		* @since 1.0.0
-		*/
-		this.serverEnv = this.getServerEnv();
-		debug$1("Loaded serverEnv %j", this.serverEnv);
-		/**
-		* @member {String} EggLoader#serverScope
-		* @see AppInfo#serverScope
-		*/
-		this.serverScope = options.serverScope ?? this.getServerScope();
-		/**
-		* @member {AppInfo} EggLoader#appInfo
-		* @since 1.0.0
-		*/
-		this.appInfo = this.getAppInfo();
-	}
-	get app() {
-		return this.options.app;
-	}
-	get lifecycle() {
-		return this.app.lifecycle;
-	}
-	get logger() {
-		return this.options.logger;
-	}
-	/**
-	* Get {@link AppInfo#env}
-	* @returns {String} env
-	* @see AppInfo#env
-	* @private
-	* @since 1.0.0
-	*/
-	getServerEnv() {
-		let serverEnv = this.options.env;
-		const envPath = path.join(this.options.baseDir, "config/env");
-		if (!serverEnv && fs.existsSync(envPath)) serverEnv = fs.readFileSync(envPath, "utf8").trim();
-		if (!serverEnv && process.env.EGG_SERVER_ENV) serverEnv = process.env.EGG_SERVER_ENV;
-		if (serverEnv) serverEnv = serverEnv.trim();
-		else if (process.env.NODE_ENV === "test") serverEnv = "unittest";
-		else if (process.env.NODE_ENV === "production") serverEnv = "prod";
-		else serverEnv = "local";
-		return serverEnv;
-	}
-	/**
-	* Get {@link AppInfo#scope}
-	* @returns {String} serverScope
-	* @private
-	*/
-	getServerScope() {
-		return process.env.EGG_SERVER_SCOPE ?? "";
-	}
-	/**
-	* Get {@link AppInfo#name}
-	* @returns {String} appname
-	* @private
-	* @since 1.0.0
-	*/
-	getAppname() {
-		if (this.pkg.name) {
-			debug$1("Loaded appname(%s) from package.json", this.pkg.name);
-			return this.pkg.name;
-		}
-		const pkg = path.join(this.options.baseDir, "package.json");
-		throw new Error(`name is required from ${pkg}`);
-	}
-	/**
-	* Get home directory
-	* @returns {String} home directory
-	* @since 3.4.0
-	*/
-	getHomedir() {
-		return process.env.EGG_HOME || homedir() || "/home/admin";
-	}
-	/**
-	* Get app info
-	* @returns {AppInfo} appInfo
-	* @since 1.0.0
-	*/
-	getAppInfo() {
-		const env = this.serverEnv;
-		const scope = this.serverScope;
-		const home = this.getHomedir();
-		const baseDir = this.options.baseDir;
-		/**
-		* Meta information of the application
-		* @class AppInfo
-		*/
-		return {
-			name: this.getAppname(),
-			baseDir,
-			env,
-			scope,
-			HOME: home,
-			pkg: this.pkg,
-			root: env === "local" || env === "unittest" ? baseDir : home
-		};
-	}
-	/**
-	* Get {@link EggLoader#eggPaths}
-	* @returns {Array} framework directories
-	* @see {@link EggLoader#eggPaths}
-	* @private
-	* @since 1.0.0
-	*/
-	getEggPaths() {
-		const EggCore$1 = this.options.EggCoreClass;
-		const eggPaths = [];
-		let proto = this.app;
-		while (proto) {
-			proto = Object.getPrototypeOf(proto);
-			if (proto === Object.prototype || proto === EggCore$1?.prototype) break;
-			const eggPath = Reflect.get(proto, Symbol.for("egg#eggPath"));
-			if (!eggPath) continue;
-			assert(typeof eggPath === "string", "Symbol.for('egg#eggPath') should be string");
-			assert(fs.existsSync(eggPath), `${eggPath} not exists`);
-			const realpath = fs.realpathSync(eggPath);
-			if (!eggPaths.includes(realpath)) eggPaths.unshift(realpath);
-		}
-		return eggPaths;
-	}
-	/** start Plugin loader */
-	lookupDirs;
-	eggPlugins;
-	appPlugins;
-	customPlugins;
-	allPlugins;
-	orderPlugins;
-	/** enable plugins */
-	plugins;
-	/**
-	* Load config/plugin.js from {EggLoader#loadUnits}
-	*
-	* plugin.js is written below
-	*
-	* ```js
-	* {
-	*   'xxx-client': {
-	*     enable: true,
-	*     package: 'xxx-client',
-	*     dep: [],
-	*     env: [],
-	*   },
-	*   // short hand
-	*   'rds': false,
-	*   'depd': {
-	*     enable: true,
-	*     path: 'path/to/depd'
-	*   }
-	* }
-	* ```
-	*
-	* If the plugin has path, Loader will find the module from it.
-	*
-	* Otherwise Loader will lookup follow the order by packageName
-	*
-	* 1. $APP_BASE/node_modules/${package}
-	* 2. $EGG_BASE/node_modules/${package}
-	*
-	* You can call `loader.plugins` that retrieve enabled plugins.
-	*
-	* ```js
-	* loader.plugins['xxx-client'] = {
-	*   name: 'xxx-client',                 // the plugin name, it can be used in `dep`
-	*   package: 'xxx-client',              // the package name of plugin
-	*   enable: true,                       // whether enabled
-	*   path: 'path/to/xxx-client',         // the directory of the plugin package
-	*   dep: [],                            // the dependent plugins, you can use the plugin name
-	*   env: [ 'local', 'unittest' ],       // specify the serverEnv that only enable the plugin in it
-	* }
-	* ```
-	*
-	* `loader.allPlugins` can be used when retrieve all plugins.
-	* @function EggLoader#loadPlugin
-	* @since 1.0.0
-	*/
-	async loadPlugin() {
-		this.timing.start("Load Plugin");
-		this.lookupDirs = this.getLookupDirs();
-		this.allPlugins = {};
-		this.eggPlugins = await this.loadEggPlugins();
-		this.appPlugins = await this.loadAppPlugins();
-		this.customPlugins = this.loadCustomPlugins();
-		this.#extendPlugins(this.allPlugins, this.eggPlugins);
-		this.#extendPlugins(this.allPlugins, this.appPlugins);
-		this.#extendPlugins(this.allPlugins, this.customPlugins);
-		const enabledPluginNames = [];
-		const plugins = {};
-		const env = this.serverEnv;
-		for (const name in this.allPlugins) {
-			const plugin = this.allPlugins[name];
-			plugin.path = this.getPluginPath(plugin);
-			await this.#mergePluginConfig(plugin);
-			if (env && plugin.env.length > 0 && !plugin.env.includes(env)) {
-				this.logger.info("[egg/core] Plugin %o is disabled by env unmatched, require env(%o) but got env is %o", name, plugin.env, env);
-				plugin.enable = false;
-				continue;
-			}
-			plugins[name] = plugin;
-			if (plugin.enable) enabledPluginNames.push(name);
-		}
-		this.orderPlugins = this.getOrderPlugins(plugins, enabledPluginNames, this.appPlugins);
-		const enablePlugins = {};
-		for (const plugin of this.orderPlugins) enablePlugins[plugin.name] = plugin;
-		debug$1("Loaded enable plugins: %j", Object.keys(enablePlugins));
-		/**
-		* Retrieve enabled plugins
-		* @member {Object} EggLoader#plugins
-		* @since 1.0.0
-		*/
-		this.plugins = enablePlugins;
-		this.timing.end("Load Plugin");
-	}
-	async loadAppPlugins() {
-		const appPlugins = await this.readPluginConfigs(path.join(this.options.baseDir, "config/plugin.default"));
-		debug$1("Loaded app plugins: %j", Object.keys(appPlugins).map((k) => `${k}:${appPlugins[k].enable}`));
-		return appPlugins;
-	}
-	async loadEggPlugins() {
-		const eggPluginConfigPaths = this.eggPaths.map((eggPath) => path.join(eggPath, "config/plugin.default"));
-		const eggPlugins = await this.readPluginConfigs(eggPluginConfigPaths);
-		debug$1("Loaded egg plugins: %j", Object.keys(eggPlugins).map((k) => `${k}:${eggPlugins[k].enable}`));
-		return eggPlugins;
-	}
-	loadCustomPlugins() {
-		let customPlugins = {};
-		const configPaths = [];
-		if (process.env.EGG_PLUGINS) try {
-			customPlugins = JSON.parse(process.env.EGG_PLUGINS);
-			configPaths.push("<process.env.EGG_PLUGINS>");
-		} catch (e) {
-			debug$1("parse EGG_PLUGINS failed, %s", e);
-		}
-		if (this.options.plugins) {
-			customPlugins = {
-				...customPlugins,
-				...this.options.plugins
-			};
-			configPaths.push("<options.plugins>");
-		}
-		if (customPlugins) {
-			const configPath = configPaths.join(" or ");
-			for (const name in customPlugins) this.#normalizePluginConfig(customPlugins, name, configPath);
-			debug$1("Loaded custom plugins: %o", customPlugins);
-		}
-		return customPlugins;
-	}
-	async readPluginConfigs(configPaths) {
-		if (!Array.isArray(configPaths)) configPaths = [configPaths];
-		const newConfigPaths = [];
-		for (const filename of this.getTypeFiles("plugin")) for (let configPath of configPaths) {
-			configPath = path.join(path.dirname(configPath), filename);
-			newConfigPaths.push(configPath);
-		}
-		const plugins = {};
-		for (const configPath of newConfigPaths) {
-			let filepath = this.resolveModule(configPath);
-			if (configPath.endsWith("plugin.default") && !filepath) filepath = this.resolveModule(configPath.replace(/plugin\.default$/, "plugin"));
-			if (!filepath) {
-				debug$1("[readPluginConfigs:ignore] plugin config not found %o", configPath);
-				continue;
-			}
-			const config = await utils_default.loadFile(filepath);
-			for (const name in config) this.#normalizePluginConfig(config, name, filepath);
-			this.#extendPlugins(plugins, config);
-		}
-		return plugins;
-	}
-	#normalizePluginConfig(plugins, name, configPath) {
-		const plugin = plugins[name];
-		if (typeof plugin === "boolean") {
-			plugins[name] = {
-				name,
-				enable: plugin,
-				dependencies: [],
-				optionalDependencies: [],
-				env: [],
-				from: configPath
-			};
-			return;
-		}
-		if (!("enable" in plugin)) Reflect.set(plugin, "enable", true);
-		plugin.name = name;
-		plugin.dependencies = plugin.dependencies || [];
-		plugin.optionalDependencies = plugin.optionalDependencies || [];
-		plugin.env = plugin.env || [];
-		plugin.from = plugin.from || configPath;
-		depCompatible(plugin);
-	}
-	async #mergePluginConfig(plugin) {
-		let pkg;
-		let config;
-		const pluginPackage = path.join(plugin.path, "package.json");
-		if (await utils_default.existsPath(pluginPackage)) {
-			pkg = await readJSON(pluginPackage);
-			config = pkg.eggPlugin;
-			if (pkg.version) plugin.version = pkg.version;
-			plugin.path = await this.#formatPluginPathFromPackageJSON(plugin.path, pkg);
-		}
-		const logger = this.options.logger;
-		if (!config) {
-			logger.warn(`[@eggjs/core/egg_loader] pkg.eggPlugin is missing in ${pluginPackage}`);
-			return;
-		}
-		if (config.name && config.strict !== false && config.name !== plugin.name) logger.warn(`[@eggjs/core/egg_loader] pluginName(${plugin.name}) is different from pluginConfigName(${config.name})`);
-		depCompatible(config);
-		for (const key of [
-			"dependencies",
-			"optionalDependencies",
-			"env"
-		]) {
-			const values = config[key];
-			const existsValues = Reflect.get(plugin, key);
-			if (Array.isArray(values) && !existsValues?.length) Reflect.set(plugin, key, values);
-		}
-	}
-	getOrderPlugins(allPlugins, enabledPluginNames, appPlugins) {
-		if (enabledPluginNames.length === 0) return [];
-		const result = sequencify(allPlugins, enabledPluginNames);
-		debug$1("Got plugins %j after sequencify", result);
-		if (result.sequence.length === 0) {
-			const err = /* @__PURE__ */ new Error(`sequencify plugins has problem, missing: [${result.missingTasks}], recursive: [${result.recursiveDependencies}]`);
-			for (const missName of result.missingTasks) {
-				const requires = [];
-				for (const name in allPlugins) if (allPlugins[name].dependencies.includes(missName)) requires.push(name);
-				err.message += `\n\t>> Plugin [${missName}] is disabled or missed, but is required by [${requires}]`;
-			}
-			err.name = "PluginSequencifyError";
-			throw err;
-		}
-		const implicitEnabledPlugins = [];
-		const requireMap = {};
-		for (const name of result.sequence) {
-			for (const depName of allPlugins[name].dependencies) {
-				if (!requireMap[depName]) requireMap[depName] = [];
-				requireMap[depName].push(name);
-			}
-			if (!allPlugins[name].enable) {
-				implicitEnabledPlugins.push(name);
-				allPlugins[name].enable = true;
-				allPlugins[name].implicitEnable = true;
-			}
-		}
-		for (const [name, dependents] of Object.entries(requireMap)) allPlugins[name].dependents = dependents;
-		if (implicitEnabledPlugins.length > 0) {
-			let message = implicitEnabledPlugins.map((name) => `  - ${name} required by [${requireMap[name]}]`).join("\n");
-			this.options.logger.info(`Following plugins will be enabled implicitly.\n${message}`);
-			const disabledPlugins = implicitEnabledPlugins.filter((name) => appPlugins[name] && appPlugins[name].enable === false);
-			if (disabledPlugins.length > 0) {
-				message = disabledPlugins.map((name) => `  - ${name} required by [${requireMap[name]}]`).join("\n");
-				this.options.logger.warn(`Following plugins will be enabled implicitly that is disabled by application.\n${message}`);
-			}
-		}
-		return result.sequence.map((name) => allPlugins[name]);
-	}
-	getLookupDirs() {
-		const lookupDirs = /* @__PURE__ */ new Set();
-		lookupDirs.add(this.options.baseDir);
-		for (let i = this.eggPaths.length - 1; i >= 0; i--) {
-			const eggPath = this.eggPaths[i];
-			lookupDirs.add(eggPath);
-		}
-		lookupDirs.add(process.cwd());
-		return lookupDirs;
-	}
-	getPluginPath(plugin) {
-		if (plugin.path) return plugin.path;
-		if (plugin.package) assert(isValidatePackageName(plugin.package), `plugin ${plugin.name} invalid, use 'path' instead of package: "${plugin.package}"`);
-		return this.#resolvePluginPath(plugin);
-	}
-	#resolvePluginPath(plugin) {
-		const name = plugin.package || plugin.name;
-		try {
-			const pluginPkgFile = utils_default.resolvePath(`${name}/package.json`, { paths: [...this.lookupDirs] });
-			return path.dirname(pluginPkgFile);
-		} catch (err) {
-			debug$1("[resolvePluginPath] error: %o, plugin info: %o", err, plugin);
-			throw new Error(`Can not find plugin ${name} in "${[...this.lookupDirs].join(", ")}"`, { cause: err });
-		}
-	}
-	async #formatPluginPathFromPackageJSON(pluginPath, pluginPkg) {
-		let realPluginPath = pluginPath;
-		const exports = pluginPkg.eggPlugin?.exports;
-		if (exports) {
-			if (isESM) {
-				if (exports.import) realPluginPath = path.join(pluginPath, exports.import);
-			} else if (exports.require) realPluginPath = path.join(pluginPath, exports.require);
-			if (exports.typescript && isSupportTypeScript() && !await exists(realPluginPath)) {
-				realPluginPath = path.join(pluginPath, exports.typescript);
-				debug$1("[formatPluginPathFromPackageJSON] use typescript path %o", realPluginPath);
-			}
-		} else if (pluginPkg.exports?.["."] && pluginPkg.type === "module") {
-			let defaultExport = pluginPkg.exports["."];
-			if (typeof defaultExport === "string") realPluginPath = path.dirname(path.join(pluginPath, defaultExport));
-			else if (defaultExport?.import) {
-				if (typeof defaultExport.import === "string") realPluginPath = path.dirname(path.join(pluginPath, defaultExport.import));
-				else if (defaultExport.import.default) realPluginPath = path.dirname(path.join(pluginPath, defaultExport.import.default));
-			}
-			debug$1("[formatPluginPathFromPackageJSON] resolve plugin path from %o to %o, defaultExport: %o", pluginPath, realPluginPath, defaultExport);
-		}
-		return realPluginPath;
-	}
-	#extendPlugins(targets, plugins) {
-		if (!plugins) return;
-		for (const name in plugins) {
-			const plugin = plugins[name];
-			let targetPlugin = targets[name];
-			if (!targetPlugin) {
-				targetPlugin = {};
-				targets[name] = targetPlugin;
-			}
-			if (targetPlugin.package && targetPlugin.package === plugin.package) this.logger.warn("[@eggjs/core] plugin %s has been defined that is %j, but you define again in %s", name, targetPlugin, plugin.from);
-			if (plugin.path || plugin.package) {
-				delete targetPlugin.path;
-				delete targetPlugin.package;
-			}
-			for (const [prop, value] of Object.entries(plugin)) {
-				if (value === void 0) continue;
-				if (Reflect.get(targetPlugin, prop) && Array.isArray(value) && value.length === 0) continue;
-				Reflect.set(targetPlugin, prop, value);
-			}
-		}
-	}
-	/** end Plugin loader */
-	/** start Config loader */
-	configMeta;
-	config;
-	/**
-	* Load config/config.js
-	*
-	* Will merge config.default.js 和 config.${env}.js
-	*
-	* @function EggLoader#loadConfig
-	* @since 1.0.0
-	*/
-	async loadConfig() {
-		this.timing.start("Load Config");
-		this.configMeta = {};
-		const target = {
-			middleware: [],
-			coreMiddleware: []
-		};
-		const appConfig = await this.#preloadAppConfig();
-		for (const filename of this.getTypeFiles("config")) for (const unit of this.getLoadUnits()) {
-			const isApp = unit.type === "app";
-			const config = await this.#loadConfig(unit.path, filename, isApp ? void 0 : appConfig, unit.type);
-			if (!config) continue;
-			debug$1("[loadConfig] Loaded config %s/%s, %j", unit.path, filename, config);
-			extend(true, target, config);
-		}
-		const envConfig = this.#loadConfigFromEnv();
-		debug$1("[loadConfig] Loaded config from env, %j", envConfig);
-		extend(true, target, envConfig);
-		target.coreMiddleware = target.coreMiddleware || [];
-		target.coreMiddlewares = target.coreMiddleware;
-		target.appMiddleware = target.middleware || [];
-		target.appMiddlewares = target.appMiddleware;
-		this.config = target;
-		debug$1("[loadConfig] all config: %o", this.config);
-		this.timing.end("Load Config");
-	}
-	async #preloadAppConfig() {
-		const names = ["config.default", `config.${this.serverEnv}`];
-		const target = {};
-		for (const filename of names) {
-			const config = await this.#loadConfig(this.options.baseDir, filename, void 0, "app");
-			if (!config) continue;
-			extend(true, target, config);
-		}
-		return target;
-	}
-	async #loadConfig(dirpath, filename, extraInject, type) {
-		const isPlugin = type === "plugin";
-		const isApp = type === "app";
-		let filepath = this.resolveModule(path.join(dirpath, "config", filename));
-		if (filename === "config.default" && !filepath) filepath = this.resolveModule(path.join(dirpath, "config/config"));
-		if (!filepath) return;
-		const config = await this.loadFile(filepath, this.appInfo, extraInject);
-		if (!config) return;
-		if (isPlugin || isApp) assert(!config.coreMiddleware, "Can not define coreMiddleware in app or plugin");
-		if (!isApp) assert(!config.middleware, "Can not define middleware in " + filepath);
-		this.#setConfigMeta(config, filepath);
-		return config;
-	}
-	#loadConfigFromEnv() {
-		const envConfigStr = process.env.EGG_APP_CONFIG;
-		if (!envConfigStr) return;
-		try {
-			const envConfig = JSON.parse(envConfigStr);
-			this.#setConfigMeta(envConfig, "<process.env.EGG_APP_CONFIG>");
-			return envConfig;
-		} catch {
-			this.options.logger.warn("[egg-loader] process.env.EGG_APP_CONFIG is not invalid JSON: %s", envConfigStr);
-		}
-	}
-	#setConfigMeta(config, filepath) {
-		config = extend(true, {}, config);
-		this.#setConfig(config, filepath);
-		extend(true, this.configMeta, config);
-	}
-	#setConfig(obj, filepath) {
-		for (const key of Object.keys(obj)) {
-			const val = obj[key];
-			if (key === "console" && val && typeof val.Console === "function" && val.Console === console.Console) {
-				obj[key] = filepath;
-				continue;
-			}
-			if (val && Object.getPrototypeOf(val) === Object.prototype && Object.keys(val).length > 0) {
-				this.#setConfig(val, filepath);
-				continue;
-			}
-			obj[key] = filepath;
-		}
-	}
-	/** end Config loader */
-	/** start Extend loader */
-	/**
-	* mixin Agent.prototype
-	* @function EggLoader#loadAgentExtend
-	* @since 1.0.0
-	*/
-	async loadAgentExtend() {
-		await this.loadExtend("agent", this.app);
-	}
-	/**
-	* mixin Application.prototype
-	* @function EggLoader#loadApplicationExtend
-	* @since 1.0.0
-	*/
-	async loadApplicationExtend() {
-		await this.loadExtend("application", this.app);
-	}
-	/**
-	* mixin Request.prototype
-	* @function EggLoader#loadRequestExtend
-	* @since 1.0.0
-	*/
-	async loadRequestExtend() {
-		await this.loadExtend("request", this.app.request);
-	}
-	/**
-	* mixin Response.prototype
-	* @function EggLoader#loadResponseExtend
-	* @since 1.0.0
-	*/
-	async loadResponseExtend() {
-		await this.loadExtend("response", this.app.response);
-	}
-	/**
-	* mixin Context.prototype
-	* @function EggLoader#loadContextExtend
-	* @since 1.0.0
-	*/
-	async loadContextExtend() {
-		await this.loadExtend("context", this.app.context);
-	}
-	/**
-	* mixin app.Helper.prototype
-	* @function EggLoader#loadHelperExtend
-	* @since 1.0.0
-	*/
-	async loadHelperExtend() {
-		if (this.app.Helper) await this.loadExtend("helper", this.app.Helper.prototype);
-	}
-	/**
-	* Find all extend file paths by name
-	* can be override in top level framework to support load `app/extends/{name}.js`
-	*
-	* @param {String} name - filename which may be `app/extend/{name}.js`
-	* @returns {Array} filepaths extend file paths
-	* @private
-	*/
-	getExtendFilePaths(name) {
-		return this.getLoadUnits().map((unit) => path.join(unit.path, "app/extend", name));
-	}
-	/**
-	* Loader app/extend/xx.js to `prototype`,
-	* @function loadExtend
-	* @param {String} name - filename which may be `app/extend/{name}.js`
-	* @param {Object} proto - prototype that mixed
-	* @since 1.0.0
-	*/
-	async loadExtend(name, proto) {
-		this.timing.start(`Load extend/${name}.js`);
-		const filepaths = this.getExtendFilePaths(name);
-		const needUnittest = "EGG_MOCK_SERVER_ENV" in process.env && this.serverEnv !== "unittest";
-		const length = filepaths.length;
-		for (let i = 0; i < length; i++) {
-			const filepath = filepaths[i];
-			filepaths.push(filepath + `.${this.serverEnv}`);
-			if (needUnittest) filepaths.push(filepath + ".unittest");
-		}
-		debug$1("loadExtend %s, filepaths: %j", name, filepaths);
-		const mergeRecord = /* @__PURE__ */ new Map();
-		for (const rawFilepath of filepaths) {
-			const filepath = this.resolveModule(rawFilepath);
-			if (!filepath) continue;
-			if (filepath.endsWith("/index.js")) this.app.deprecate(`app/extend/${name}/index.js is deprecated, use app/extend/${name}.js instead`);
-			else if (filepath.endsWith("/index.ts")) this.app.deprecate(`app/extend/${name}/index.ts is deprecated, use app/extend/${name}.ts instead`);
-			let ext = await this.requireFile(filepath);
-			if (isClass(ext)) ext = ext.prototype;
-			const properties = Object.getOwnPropertyNames(ext).concat(Object.getOwnPropertySymbols(ext)).filter((name$1) => name$1 !== "constructor");
-			for (const property of properties) {
-				if (mergeRecord.has(property)) debug$1("Property: \"%s\" already exists in \"%s\"，it will be redefined by \"%s\"", property, mergeRecord.get(property), filepath);
-				let descriptor = Object.getOwnPropertyDescriptor(ext, property);
-				let originalDescriptor = Object.getOwnPropertyDescriptor(proto, property);
-				if (!originalDescriptor) {
-					const originalProto = originalPrototypes[name];
-					if (originalProto) originalDescriptor = Object.getOwnPropertyDescriptor(originalProto, property);
-				}
-				if (originalDescriptor) {
-					descriptor = { ...descriptor };
-					if (!descriptor.set && originalDescriptor.set) descriptor.set = originalDescriptor.set;
-					if (!descriptor.get && originalDescriptor.get) descriptor.get = originalDescriptor.get;
-				}
-				Object.defineProperty(proto, property, descriptor);
-				mergeRecord.set(property, filepath);
-			}
-			debug$1("merge %j to %s from %s", properties, name, filepath);
-		}
-		this.timing.end(`Load extend/${name}.js`);
-	}
-	/** end Extend loader */
-	/** start Custom loader */
-	/**
-	* load app.js
-	*
-	* @example
-	* - old:
-	*
-	* ```js
-	* module.exports = function(app) {
-	*   doSomething();
-	* }
-	* ```
-	*
-	* - new:
-	*
-	* ```js
-	* module.exports = class Boot {
-	*   constructor(app) {
-	*     this.app = app;
-	*   }
-	*   configDidLoad() {
-	*     doSomething();
-	*   }
-	* }
-	* @since 1.0.0
-	*/
-	async loadCustomApp() {
-		await this.#loadBootHook("app");
-		this.lifecycle.triggerConfigWillLoad();
-	}
-	/**
-	* Load agent.js, same as {@link EggLoader#loadCustomApp}
-	*/
-	async loadCustomAgent() {
-		await this.#loadBootHook("agent");
-		this.lifecycle.triggerConfigWillLoad();
-	}
-	loadBootHook() {}
-	async #loadBootHook(fileName) {
-		this.timing.start(`Load ${fileName}.js`);
-		for (const unit of this.getLoadUnits()) {
-			const bootFile = path.join(unit.path, fileName);
-			const bootFilePath = this.resolveModule(bootFile);
-			if (!bootFilePath) {
-				debug$1("[loadBootHook:ignore] %o not found", bootFile);
-				continue;
-			}
-			debug$1("[loadBootHook:success] %o => %o", bootFile, bootFilePath);
-			const bootHook = await this.requireFile(bootFilePath);
-			if (isClass(bootHook)) {
-				bootHook.prototype.fullPath = bootFilePath;
-				this.lifecycle.addBootHook(bootHook);
-				debug$1("[loadBootHook] add BootHookClass from %o", bootFilePath);
-			} else if (typeof bootHook === "function") {
-				this.lifecycle.addFunctionAsBootHook(bootHook, bootFilePath);
-				debug$1("[loadBootHook] add bootHookFunction from %o", bootFilePath);
-			} else this.options.logger.warn("[@eggjs/core/egg_loader] %s must exports a boot class", bootFilePath);
-		}
-		this.lifecycle.init();
-		this.timing.end(`Load ${fileName}.js`);
-	}
-	/** end Custom loader */
-	/** start Service loader */
-	/**
-	* Load app/service
-	* @function EggLoader#loadService
-	* @param {Object} options - LoaderOptions
-	* @since 1.0.0
-	*/
-	async loadService(options) {
-		this.timing.start("Load Service");
-		const servicePaths = this.getLoadUnits().map((unit) => path.join(unit.path, "app/service"));
-		options = {
-			call: true,
-			caseStyle: CaseStyle.lower,
-			fieldClass: "serviceClasses",
-			directory: servicePaths,
-			...options
-		};
-		debug$1("[loadService] options: %o", options);
-		await this.loadToContext(servicePaths, "service", options);
-		this.timing.end("Load Service");
-	}
-	/** end Service loader */
-	/** start Middleware loader */
-	/**
-	* Load app/middleware
-	*
-	* app.config.xx is the options of the middleware xx that has same name as config
-	*
-	* @function EggLoader#loadMiddleware
-	* @param {Object} opt - LoaderOptions
-	* @example
-	* ```js
-	* // app/middleware/status.js
-	* module.exports = function(options, app) {
-	*   // options == app.config.status
-	*   return async next => {
-	*     await next();
-	*   }
-	* }
-	* ```
-	* @since 1.0.0
-	*/
-	async loadMiddleware(opt) {
-		this.timing.start("Load Middleware");
-		const app = this.app;
-		const middlewarePaths = this.getLoadUnits().map((unit) => path.join(unit.path, "app/middleware"));
-		opt = {
-			call: false,
-			override: true,
-			caseStyle: CaseStyle.lower,
-			directory: middlewarePaths,
-			...opt
-		};
-		await this.loadToApp(middlewarePaths, "middlewares", opt);
-		debug$1("[loadMiddleware] middlewarePaths: %j", middlewarePaths);
-		for (const name in app.middlewares) Object.defineProperty(app.middleware, name, {
-			get() {
-				return app.middlewares[name];
-			},
-			enumerable: false,
-			configurable: false
-		});
-		this.options.logger.info("Use coreMiddleware order: %j", this.config.coreMiddleware);
-		this.options.logger.info("Use appMiddleware order: %j", this.config.appMiddleware);
-		const middlewareNames = this.config.coreMiddleware.concat(this.config.appMiddleware);
-		debug$1("[loadMiddleware] middlewareNames: %j", middlewareNames);
-		const middlewaresMap = /* @__PURE__ */ new Map();
-		for (const name of middlewareNames) {
-			const createMiddleware = app.middlewares[name];
-			if (!createMiddleware) throw new TypeError(`Middleware ${name} not found`);
-			if (middlewaresMap.has(name)) throw new TypeError(`Middleware ${name} redefined`);
-			middlewaresMap.set(name, true);
-			const options = this.config[name] || {};
-			let mw$1 = createMiddleware(options, app);
-			assert(typeof mw$1 === "function", `Middleware ${name} must be a function, but actual is ${inspect(mw$1)}`);
-			if (isGeneratorFunction(mw$1)) {
-				const fullpath = Reflect.get(createMiddleware, FULLPATH);
-				throw new TypeError(`Support for generators was removed, middleware: ${name}, fullpath: ${fullpath}`);
-			}
-			mw$1._name = name;
-			mw$1 = wrapMiddleware(mw$1, options);
-			if (mw$1) {
-				if (debug$1.enabled) mw$1 = debugMiddlewareWrapper(mw$1);
-				app.use(mw$1);
-				debug$1("[loadMiddleware] Use middleware: %s with options: %j", name, options);
-				this.options.logger.info("[@eggjs/core/egg_loader] Use middleware: %s", name);
-			} else this.options.logger.info("[@eggjs/core/egg_loader] Disable middleware: %s", name);
-		}
-		this.options.logger.info("[@eggjs/core/egg_loader] Loaded middleware from %j", middlewarePaths);
-		this.timing.end("Load Middleware");
-		const mw = this.app.router.middleware();
-		Reflect.set(mw, "_name", "routerMiddleware");
-		this.app.use(mw);
-	}
-	/** end Middleware loader */
-	/** start Controller loader */
-	/**
-	* Load app/controller
-	* @param {Object} opt - LoaderOptions
-	* @since 1.0.0
-	*/
-	async loadController(opt) {
-		this.timing.start("Load Controller");
-		const controllerBase = path.join(this.options.baseDir, "app/controller");
-		opt = {
-			caseStyle: CaseStyle.lower,
-			directory: controllerBase,
-			initializer: (obj, opt$1) => {
-				if (isGeneratorFunction(obj)) throw new TypeError(`Support for generators was removed, fullpath: ${opt$1.path}`);
-				if (!isClass(obj) && !isAsyncFunction(obj) && typeof obj === "function") {
-					obj = obj(this.app);
-					debug$1("[loadController] after init(app) => %o, meta: %j", obj, opt$1);
-					if (isGeneratorFunction(obj)) throw new TypeError(`Support for generators was removed, fullpath: ${opt$1.path}`);
-				}
-				if (isClass(obj)) {
-					obj.prototype.pathName = opt$1.pathName;
-					obj.prototype.fullPath = opt$1.path;
-					return wrapControllerClass(obj, opt$1.path);
-				}
-				if (isObject(obj)) return wrapObject(obj, opt$1.path);
-				if (isAsyncFunction(obj)) return wrapObject({ "module.exports": obj }, opt$1.path)["module.exports"];
-				return obj;
-			},
-			...opt
-		};
-		await this.loadToApp(controllerBase, "controller", opt);
-		debug$1("[loadController] app.controller => %o", this.app.controller);
-		this.options.logger.info("[@eggjs/core/egg_loader] Controller loaded: %s", controllerBase);
-		this.timing.end("Load Controller");
-	}
-	/** end Controller loader */
-	/** start Router loader */
-	/**
-	* Load app/router.js
-	* @function EggLoader#loadRouter
-	* @since 1.0.0
-	*/
-	async loadRouter() {
-		this.timing.start("Load Router");
-		await this.loadFile(path.join(this.options.baseDir, "app/router"));
-		this.timing.end("Load Router");
-	}
-	/** end Router loader */
-	/** start CustomLoader loader */
-	async loadCustomLoader() {
-		assert(this.config, "should loadConfig first");
-		const customLoader = this.config.customLoader || {};
-		for (const property of Object.keys(customLoader)) {
-			const loaderConfig = { ...customLoader[property] };
-			assert(loaderConfig.directory, `directory is required for config.customLoader.${property}`);
-			let directory;
-			if (loaderConfig.loadunit === true) directory = this.getLoadUnits().map((unit) => path.join(unit.path, loaderConfig.directory));
-			else directory = path.join(this.appInfo.baseDir, loaderConfig.directory);
-			const inject = loaderConfig.inject || "app";
-			debug$1("[loadCustomLoader] loaderConfig: %o, inject: %o, directory: %o", loaderConfig, inject, directory);
-			switch (inject) {
-				case "ctx": {
-					assert(!(property in this.app.context), `customLoader should not override ctx.${property}`);
-					const options = {
-						caseStyle: CaseStyle.lower,
-						fieldClass: `${property}Classes`,
-						...loaderConfig,
-						directory
-					};
-					await this.loadToContext(directory, property, options);
-					break;
-				}
-				case "app": {
-					assert(!(property in this.app), `customLoader should not override app.${property}`);
-					const options = {
-						caseStyle: CaseStyle.lower,
-						initializer: (Clazz) => {
-							return isClass(Clazz) ? new Clazz(this.app) : Clazz;
-						},
-						...loaderConfig,
-						directory
-					};
-					await this.loadToApp(directory, property, options);
-					break;
-				}
-				default: throw new Error("inject only support app or ctx");
-			}
-		}
-	}
-	/** end CustomLoader loader */
-	/**
-	* Load single file, will invoke when export is function
-	*
-	* @param {String} filepath - fullpath
-	* @param {Array} inject - pass rest arguments into the function when invoke
-	* @returns {Object} exports
-	* @example
-	* ```js
-	* app.loader.loadFile(path.join(app.options.baseDir, 'config/router.js'));
-	* ```
-	* @since 1.0.0
-	*/
-	async loadFile(filepath, ...inject) {
-		const fullpath = filepath && this.resolveModule(filepath);
-		if (!fullpath) return null;
-		if (inject.length === 0) inject = [this.app];
-		let mod = await this.requireFile(fullpath);
-		if (typeof mod === "function" && !isClass(mod)) {
-			mod = mod(...inject);
-			if (isPromise(mod)) mod = await mod;
-		}
-		return mod;
-	}
-	/**
-	* @param {String} filepath - fullpath
-	* @private
-	*/
-	async requireFile(filepath) {
-		const timingKey = `Require(${this.#requiredCount++}) ${utils_default.getResolvedFilename(filepath, this.options.baseDir)}`;
-		this.timing.start(timingKey);
-		const mod = await utils_default.loadFile(filepath);
-		this.timing.end(timingKey);
-		return mod;
-	}
-	/**
-	* Get all loadUnit
-	*
-	* loadUnit is a directory that can be loaded by EggLoader, it has the same structure.
-	* loadUnit has a path and a type(app, framework, plugin).
-	*
-	* The order of the loadUnits:
-	*
-	* 1. plugin
-	* 2. framework
-	* 3. app
-	*
-	* @returns {Array} loadUnits
-	* @since 1.0.0
-	*/
-	getLoadUnits() {
-		if (this.dirs) return this.dirs;
-		this.dirs = [];
-		if (this.orderPlugins) for (const plugin of this.orderPlugins) this.dirs.push({
-			path: plugin.path,
-			type: "plugin"
-		});
-		for (const eggPath of this.eggPaths) this.dirs.push({
-			path: eggPath,
-			type: "framework"
-		});
-		this.dirs.push({
-			path: this.options.baseDir,
-			type: "app"
-		});
-		debug$1("Loaded dirs %j", this.dirs);
-		return this.dirs;
-	}
-	/**
-	* Load files using {@link FileLoader}, inject to {@link Application}
-	* @param {String|Array} directory - see {@link FileLoader}
-	* @param {String} property - see {@link FileLoader}, e.g.: 'controller', 'middlewares'
-	* @param {Object} options - see {@link FileLoader}
-	* @since 1.0.0
-	*/
-	async loadToApp(directory, property, options) {
-		const target = {};
-		Reflect.set(this.app, property, target);
-		const loadOptions = {
-			...options,
-			directory: options?.directory ?? directory,
-			target,
-			inject: this.app
-		};
-		const timingKey = `Load "${String(property)}" to Application`;
-		this.timing.start(timingKey);
-		await new FileLoader(loadOptions).load();
-		this.timing.end(timingKey);
-	}
-	/**
-	* Load files using {@link ContextLoader}
-	* @param {String|Array} directory - see {@link ContextLoader}
-	* @param {String} property - see {@link ContextLoader}
-	* @param {Object} options - see {@link ContextLoader}
-	* @since 1.0.0
-	*/
-	async loadToContext(directory, property, options) {
-		const loadOptions = {
-			...options,
-			directory: options?.directory || directory,
-			property,
-			inject: this.app
-		};
-		const timingKey = `Load "${String(property)}" to Context`;
-		this.timing.start(timingKey);
-		await new ContextLoader(loadOptions).load();
-		this.timing.end(timingKey);
-	}
-	/**
-	* @member {FileLoader} EggLoader#FileLoader
-	* @since 1.0.0
-	*/
-	get FileLoader() {
-		return FileLoader;
-	}
-	/**
-	* @member {ContextLoader} EggLoader#ContextLoader
-	* @since 1.0.0
-	*/
-	get ContextLoader() {
-		return ContextLoader;
-	}
-	getTypeFiles(filename) {
-		const files = [`${filename}.default`];
-		if (this.serverScope) files.push(`${filename}.${this.serverScope}`);
-		if (this.serverEnv === "default") return files;
-		files.push(`${filename}.${this.serverEnv}`);
-		if (this.serverScope) files.push(`${filename}.${this.serverScope}_${this.serverEnv}`);
-		return files;
-	}
-	resolveModule(filepath) {
-		let fullPath;
-		try {
-			fullPath = utils_default.resolvePath(filepath);
-		} catch {
-			return;
-		}
-		return fullPath;
-	}
-};
-function depCompatible(plugin) {
-	if (plugin.dep && !(Array.isArray(plugin.dependencies) && plugin.dependencies.length > 0)) {
-		plugin.dependencies = plugin.dep;
-		delete plugin.dep;
-	}
-}
-function isValidatePackageName(name) {
-	if (name.startsWith(".")) return false;
-	if (name.startsWith("/")) return false;
-	if (name.includes(":")) return false;
-	return true;
-}
-function wrapMiddleware(mw, options) {
-	if (options.enable === false) return null;
-	if (!options.match && !options.ignore) return mw;
-	const match = pathMatching(options);
-	const fn = (ctx, next) => {
-		if (!match(ctx)) return next();
-		return mw(ctx, next);
-	};
-	fn._name = `${mw._name}middlewareWrapper`;
-	return fn;
-}
-function debugMiddlewareWrapper(mw) {
-	const fn = async (ctx, next) => {
-		const startTime = now();
-		debug$1("[debugMiddlewareWrapper] [%s %s] enter middleware: %s", ctx.method, ctx.url, mw._name);
-		await mw(ctx, next);
-		const rt = diff(startTime);
-		debug$1("[debugMiddlewareWrapper] [%s %s] after middleware: %s [%sms]", ctx.method, ctx.url, mw._name, rt);
-	};
-	fn._name = `${mw._name}DebugWrapper`;
-	return fn;
-}
-function wrapControllerClass(Controller, fullPath) {
-	let proto = Controller.prototype;
-	const ret = {};
-	while (proto !== Object.prototype) {
-		const keys = Object.getOwnPropertyNames(proto);
-		for (const key of keys) {
-			if (key === "constructor") continue;
-			const d = Object.getOwnPropertyDescriptor(proto, key);
-			if (typeof d?.value === "function" && !Object.hasOwn(ret, key)) {
-				const controllerMethodName = `${Controller.name}.${key}`;
-				if (isGeneratorFunction(d.value)) throw new TypeError(`Support for generators was removed, controller \`${controllerMethodName}\`, fullpath: ${fullPath}`);
-				ret[key] = controllerMethodToMiddleware(Controller, key);
-				ret[key][FULLPATH] = `${fullPath}#${controllerMethodName}()`;
-			}
-		}
-		proto = Object.getPrototypeOf(proto);
-	}
-	return ret;
-}
-function controllerMethodToMiddleware(Controller, key) {
-	return function classControllerMiddleware(...args) {
-		const controller = new Controller(this);
-		if (!this.app.config.controller?.supportParams) args = [this];
-		return controller[key](...args);
-	};
-}
-function wrapObject(obj, fullPath, prefix) {
-	const keys = Object.keys(obj);
-	const ret = {};
-	prefix = prefix ?? "";
-	for (const key of keys) {
-		const controllerMethodName = `${prefix}${key}`;
-		const item = obj[key];
-		if (isGeneratorFunction(item)) throw new TypeError(`Support for generators was removed, controller \`${controllerMethodName}\`, fullpath: ${fullPath}`);
-		if (typeof item === "function") {
-			if (getParamNames(item)[0] === "next") throw new Error(`controller \`${controllerMethodName}\` should not use next as argument from file ${fullPath}`);
-			ret[key] = objectFunctionToMiddleware(item);
-			ret[key][FULLPATH] = `${fullPath}#${controllerMethodName}()`;
-		} else if (isObject(item)) ret[key] = wrapObject(item, fullPath, `${controllerMethodName}.`);
-	}
-	debug$1("[wrapObject] fullPath: %s, prefix: %s => %o", fullPath, prefix, ret);
-	return ret;
-}
-function objectFunctionToMiddleware(func) {
-	async function objectControllerMiddleware(...args) {
-		if (!this.app.config.controller?.supportParams) args = [this];
-		return await func.apply(this, args);
-	}
-	for (const key in func) Reflect.set(objectControllerMiddleware, key, Reflect.get(func, key));
-	return objectControllerMiddleware;
-}
-
-//#endregion
-//#region src/singleton.ts
-var Singleton = class {
-	clients = /* @__PURE__ */ new Map();
-	app;
-	create;
-	name;
-	options;
-	constructor(options) {
-		assert(options.name, "[egg/core/singleton] Singleton#constructor options.name is required");
-		assert(options.app, "[egg/core/singleton] Singleton#constructor options.app is required");
-		assert(options.create, "[egg/core/singleton] Singleton#constructor options.create is required");
-		assert(!(options.name in options.app), `[egg/core/singleton] ${options.name} is already exists in app`);
-		this.app = options.app;
-		this.name = options.name;
-		this.create = options.create;
-		this.options = options.app.config[this.name] ?? {};
-	}
-	init() {
-		return isAsyncFunction(this.create) ? this.initAsync() : this.initSync();
-	}
-	initSync() {
-		const options = this.options;
-		assert(!(options.client && options.clients), `[egg/core/singleton] ${this.name} can not set options.client and options.clients both`);
-		if (options.client) {
-			const client = this.createInstance(options.client, options.name);
-			this.#setClientToApp(client);
-			this.#extendDynamicMethods(client);
-			return;
-		}
-		if (options.clients) {
-			for (const id of Object.keys(options.clients)) {
-				const client = this.createInstance(options.clients[id], id);
-				this.clients.set(id, client);
-			}
-			this.#setClientToApp(this);
-			return;
-		}
-		this.#setClientToApp(this);
-	}
-	async initAsync() {
-		const options = this.options;
-		assert(!(options.client && options.clients), `[egg/core/singleton] ${this.name} can not set options.client and options.clients both`);
-		if (options.client) {
-			const client = await this.createInstanceAsync(options.client, options.name);
-			this.#setClientToApp(client);
-			this.#extendDynamicMethods(client);
-			return;
-		}
-		if (options.clients) {
-			await Promise.all(Object.keys(options.clients).map((id) => {
-				return this.createInstanceAsync(options.clients[id], id).then((client) => this.clients.set(id, client));
-			}));
-			this.#setClientToApp(this);
-			return;
-		}
-		this.#setClientToApp(this);
-	}
-	#setClientToApp(client) {
-		Reflect.set(this.app, this.name, client);
-	}
-	/**
-	* @deprecated please use `getSingletonInstance(id)` instead
-	*/
-	get(id) {
-		return this.clients.get(id);
-	}
-	/**
-	* Get singleton instance by id
-	*/
-	getSingletonInstance(id) {
-		return this.clients.get(id);
-	}
-	createInstance(config, clientName) {
-		assert(!isAsyncFunction(this.create), `[egg/core/singleton] ${this.name} only support asynchronous creation, please use createInstanceAsync`);
-		config = {
-			...this.options.default,
-			...config
-		};
-		return this.create(config, this.app, clientName);
-	}
-	async createInstanceAsync(config, clientName) {
-		config = {
-			...this.options.default,
-			...config
-		};
-		return await this.create(config, this.app, clientName);
-	}
-	#extendDynamicMethods(client) {
-		assert(!client.createInstance, "[egg/core/singleton] singleton instance should not have createInstance method");
-		assert(!client.createInstanceAsync, "[egg/core/singleton] singleton instance should not have createInstanceAsync method");
-		try {
-			let extendable = client;
-			if (!Object.isExtensible(client) || Object.isFrozen(client)) extendable = client.__proto__ || client;
-			extendable.createInstance = this.createInstance.bind(this);
-			extendable.createInstanceAsync = this.createInstanceAsync.bind(this);
-		} catch (err) {
-			this.app.coreLogger.warn("[egg/core/singleton] %s dynamic create is disabled because of client is un-extendable", this.name);
-			this.app.coreLogger.warn(err);
-		}
-	}
-};
-
-//#endregion
-//#region src/egg.ts
-const debug = debuglog("egg/core/egg");
-const EGG_LOADER = Symbol.for("egg#loader");
-var Request = class extends KoaRequest {};
-var Response = class extends KoaResponse {};
-var Context = class extends KoaContext {
-	/**
-	* Returns map of URL parameters for given `path` and `paramNames`.
-	* @example
-	* ##### ctx.params.id {string}
-	*
-	* `GET /api/users/1` => `'1'`
-	*
-	* ##### ctx.params.per_page {string}
-	*
-	* The number of every page, `GET /api/users?per_page=20` => `20`
-	*/
-	params;
-	/**
-	* Returns array of router regexp url path captures.
-	*/
-	captures;
-	/**
-	* Returns the name of the matched router.
-	*/
-	routerName;
-	/**
-	* Returns the path of the matched router.
-	*/
-	routerPath;
-};
-var EggCore = class EggCore extends KoaApplication {
-	options;
-	timing;
-	console;
-	BaseContextClass;
-	Controller;
-	Service;
-	Helper;
-	lifecycle;
-	loader;
-	#closePromise;
-	#router;
-	/** auto inject on loadService() */
-	serviceClasses = {};
-	/** auto inject on loadController() */
-	controller = {};
-	/** auto inject on loadMiddleware() */
-	middlewares = {};
-	/**
-	* @class
-	* @param {Object} options - options
-	* @param {String} [options.baseDir] - the directory of application
-	* @param {String} [options.type] - whether it's running in app worker or agent worker
-	* @param {Object} [options.plugins] - custom plugins
-	* @since 1.0.0
-	*/
-	constructor(options = {}) {
-		options.baseDir = options.baseDir ?? process.cwd();
-		options.type = options.type ?? "application";
-		assert(typeof options.baseDir === "string", "options.baseDir required, and must be a string");
-		assert(options.type === "application" || options.type === "agent", "options.type should be application or agent");
-		super();
-		this.timing = new Timing();
-		/**
-		* @member {Object} EggCore#options
-		* @private
-		* @since 1.0.0
-		*/
-		this.options = options;
-		/**
-		* logging for EggCore, avoid using console directly
-		* @member {Logger} EggCore#console
-		* @private
-		* @since 1.0.0
-		*/
-		this.console = new EggConsoleLogger();
-		/**
-		* @member {BaseContextClass} EggCore#BaseContextClass
-		* @since 1.0.0
-		*/
-		this.BaseContextClass = BaseContextClass;
-		/**
-		* Retrieve base controller
-		* @member {Controller} EggCore#Controller
-		* @since 1.0.0
-		*/
-		this.Controller = this.BaseContextClass;
-		/**
-		* Retrieve base service
-		* @member {Service} EggCore#Service
-		* @since 1.0.0
-		*/
-		this.Service = this.BaseContextClass;
-		this.lifecycle = new Lifecycle({
-			baseDir: options.baseDir,
-			app: this,
-			logger: this.console
-		});
-		this.lifecycle.on("error", (err) => this.emit("error", err));
-		this.lifecycle.on("ready_timeout", (id) => this.emit("ready_timeout", id));
-		this.lifecycle.on("ready_stat", (data) => this.emit("ready_stat", data));
-		/**
-		* The loader instance, the default class is {@link EggLoader}.
-		* If you want define
-		* @member {EggLoader} EggCore#loader
-		* @since 1.0.0
-		*/
-		const Loader = this[EGG_LOADER];
-		assert(Loader, "Symbol.for('egg#loader') is required");
-		this.loader = new Loader({
-			baseDir: options.baseDir,
-			app: this,
-			plugins: options.plugins,
-			logger: this.console,
-			serverScope: options.serverScope,
-			env: options.env ?? "",
-			EggCoreClass: EggCore
-		});
-	}
-	get logger() {
-		return this.console;
-	}
-	get coreLogger() {
-		return this.console;
-	}
-	/**
-	* create a singleton instance
-	* @param {String} name - unique name for singleton
-	* @param {Function|AsyncFunction} create - method will be invoked when singleton instance create
-	*/
-	addSingleton(name, create) {
-		const initPromise = new Singleton({
-			name,
-			create,
-			app: this
-		}).init();
-		if (initPromise) this.lifecycle.registerBeforeStart(async () => {
-			await initPromise;
-		}, `${name}-singleton-init`);
-	}
-	/**
-	* override koa's app.use, support generator function
-	* @since 1.0.0
-	*/
-	use(fn) {
-		assert(typeof fn === "function", "app.use() requires a function");
-		debug("[use] add middleware: %o", fn._name || fn.name || "-");
-		this.middleware.push(fn);
-		return this;
-	}
-	/**
-	* Whether `application` or `agent`
-	* @member {String}
-	* @since 1.0.0
-	*/
-	get type() {
-		return this.options.type;
-	}
-	/**
-	* The current directory of application
-	* @member {String}
-	* @see {@link AppInfo#baseDir}
-	* @since 1.0.0
-	*/
-	get baseDir() {
-		return this.options.baseDir;
-	}
-	/**
-	* Alias to {@link https://npmjs.com/package/depd}
-	* @member {Function}
-	* @since 1.0.0
-	*/
-	get deprecate() {
-		return utils_default.deprecated;
-	}
-	/**
-	* The name of application
-	* @member {String}
-	* @see {@link AppInfo#name}
-	* @since 1.0.0
-	*/
-	get name() {
-		return this.loader ? this.loader.pkg.name : "";
-	}
-	/**
-	* Retrieve enabled plugins
-	* @member {Object}
-	* @since 1.0.0
-	*/
-	get plugins() {
-		return this.loader ? this.loader.plugins : {};
-	}
-	/**
-	* The configuration of application
-	* @member {Config}
-	* @since 1.0.0
-	*/
-	get config() {
-		return this.loader ? this.loader.config : {};
-	}
-	/**
-	* Execute scope after loaded and before app start.
-	*
-	* Notice:
-	* This method is now NOT recommended and regarded as a deprecated one,
-	* For plugin development, we should use `didLoad` instead.
-	* For application development, we should use `willReady` instead.
-	*
-	* @see https://eggjs.org/en/advanced/loader.html#beforestart
-	*
-	* @param  {Function} scope function will execute before app start
-	* @param {string} [name] scope name, default is empty string
-	*/
-	beforeStart(scope, name) {
-		this.deprecate("`beforeStart` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
-		this.lifecycle.registerBeforeStart(scope, name ?? "");
-	}
-	ready(flagOrFunction) {
-		if (flagOrFunction === void 0) return this.lifecycle.ready();
-		return this.lifecycle.ready(flagOrFunction);
-	}
-	/**
-	* If a client starts asynchronously, you can register `readyCallback`,
-	* then the application will wait for the callback to ready
-	*
-	* It will log when the callback is not invoked after 10s
-	*
-	* Recommend to use {@link EggCore#beforeStart}
-	* @since 1.0.0
-	*
-	* @param {String} name - readyCallback task name
-	* @param {object} opts -
-	*   - {Number} [timeout=10000] - emit `ready_timeout` when it doesn't finish but reach the timeout
-	*   - {Boolean} [isWeakDep=false] - whether it's a weak dependency
-	* @returns {Function} - a callback
-	* @example
-	* const done = app.readyCallback('mysql');
-	* mysql.ready(done);
-	*/
-	readyCallback(name, opts) {
-		this.deprecate("`readyCallback` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
-		return this.lifecycle.legacyReadyCallback(name, opts);
-	}
-	/**
-	* Register a function that will be called when app close.
-	*
-	* Notice:
-	* This method is now NOT recommended directly used,
-	* Developers SHOULDN'T use app.beforeClose directly now,
-	* but in the form of class to implement beforeClose instead.
-	*
-	* @see https://eggjs.org/en/advanced/loader.html#beforeclose
-	*
-	* @param {Function} fn - the function that can be generator function or async function.
-	*/
-	beforeClose(fn, name) {
-		this.deprecate("`beforeClose` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
-		this.lifecycle.registerBeforeClose(fn, name);
-	}
-	/**
-	* Close all, it will close
-	* - callbacks registered by beforeClose
-	* - emit `close` event
-	* - remove add listeners
-	*
-	* If error is thrown when it's closing, the promise will reject.
-	* It will also reject after following call.
-	* @returns {Promise} promise
-	* @since 1.0.0
-	*/
-	async close() {
-		if (this.#closePromise) return this.#closePromise;
-		this.#closePromise = this.lifecycle.close();
-		return this.#closePromise;
-	}
-	/**
-	* get router
-	* @member {Router} EggCore#router
-	* @since 1.0.0
-	*/
-	get router() {
-		if (this.#router) return this.#router;
-		this.#router = new Router({ sensitive: true }, this);
-		return this.#router;
-	}
-	/**
-	* Alias to {@link Router#url}
-	* @param {String} name - Router name
-	* @param {Object} params - more parameters
-	* @returns {String} url
-	*/
-	url(name, params) {
-		return this.router.url(name, params);
-	}
-	head(...args) {
-		this.router.head.apply(this.router, args);
-		return this;
-	}
-	get(...args) {
-		this.router.get.apply(this.router, args);
-		return this;
-	}
-	put(...args) {
-		this.router.put.apply(this.router, args);
-		return this;
-	}
-	patch(...args) {
-		this.router.patch.apply(this.router, args);
-		return this;
-	}
-	post(...args) {
-		this.router.post.apply(this.router, args);
-		return this;
-	}
-	delete(...args) {
-		this.router.delete.apply(this.router, args);
-		return this;
-	}
-	del(...args) {
-		this.router.del.apply(this.router, args);
-		return this;
-	}
-	all(...args) {
-		this.router.all.apply(this.router, args);
-		return this;
-	}
-	resources(...args) {
-		this.router.resources.apply(this.router, args);
-		return this;
-	}
-	redirect(source, destination, status = 301) {
-		this.router.redirect(source, destination, status);
-		return this;
-	}
-	register(path$1, methods, middleware, opts) {
-		this.router.register(path$1, methods, middleware, opts);
-		return this;
-	}
-	get [EGG_LOADER]() {
-		return EggLoader;
-	}
-};
-
-//#endregion
-export { BaseContextClass, CaseStyle, ClassLoader, Context, ContextLoader, EGG_LOADER, EXPORTS, EggCore, EggLoader, FULLPATH, FileLoader, KoaApplication, KoaContext, KoaRequest, KoaResponse, Lifecycle, Request, Response, Router, Singleton, Timing, sequencify, utils_default as utils };
+import utils from "./utils/index.js";
+export { utils };
+export * from "./egg.js";
+export * from "./base_context_class.js";
+export * from "./lifecycle.js";
+export * from "./singleton.js";
+export * from "./loader/egg_loader.js";
+export * from "./loader/file_loader.js";
+export * from "./loader/context_loader.js";
+export * from "./utils/sequencify.js";
+export * from "./utils/timing.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE1BQU0sa0JBQWtCLENBQUM7QUFFckMsT0FBTyxFQUFFLEtBQUssRUFBRSxDQUFDO0FBRWpCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQkFBbUIsQ0FBQyJ9