clear-router 2.7.6 → 2.8.0

package/dist/index.cjs

@@ -1,1098 +1,17 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-let node_async_hooks = require("node:async_hooks");
-let node_module = require("node:module");
-
-//#region src/ClearRequest.ts
-var ClearRequest = class {
-	/**
-	* @param body - Parsed request body
-	*/
-	body;
-	/**
-	* @param query - Parsed query parameters
-	*/
-	query;
-	/**
-	* @param params - Parsed route parameters
-	*/
-	params;
-	route;
-	constructor(init) {
-		Object.assign(this, init);
-	}
-};
-
-//#endregion
-//#region src/Controller.ts
-var Controller = class {
-	ctx;
-	body;
-	query;
-	params;
-	clearRequest;
-};
-
-//#endregion
-//#region src/Route.ts
-var Route = class {
-	ctx;
-	body = {};
-	query = {};
-	params = {};
-	clearRequest;
-	methods;
-	path;
-	registrationPaths;
-	parameters;
-	routeName;
-	handler;
-	middlewares;
-	controllerName;
-	actionName;
-	handlerType;
-	middlewareCount;
-	constructor(methods, path, handler, middlewares = [], options = {}) {
-		this.methods = methods;
-		this.path = path;
-		this.registrationPaths = options.registrationPaths || [path];
-		this.parameters = options.parameters || [];
-		this.handler = handler;
-		this.middlewares = middlewares;
-		this.handlerType = Array.isArray(handler) ? "controller" : "function";
-		this.middlewareCount = middlewares.length;
-		this.controllerName = Array.isArray(handler) ? handler[0]?.name : void 0;
-		this.actionName = Array.isArray(handler) ? handler[1] : typeof handler === "function" ? handler.constructor.name ?? handler.name : void 0;
-		this.onName = options.onName;
-	}
-	onName;
-	name(name) {
-		const previousName = this.routeName;
-		this.routeName = name;
-		this.onName?.(name, this, previousName);
-		return this;
-	}
-	toPath(params = {}) {
-		return this.path.replace(/\/?\{([^{}]+)\}/g, (segment, raw) => {
-			const optional = raw.endsWith("?");
-			const [rawName, rawField] = (optional ? raw.slice(0, -1) : raw).split(":", 2);
-			const name = rawName.trim();
-			const field = rawField?.trim();
-			const value = params[name];
-			const resolved = field && value && typeof value === "object" ? value[field] : value;
-			if (typeof resolved === "undefined" || resolved === null || resolved === "") {
-				if (optional) return "";
-				throw new Error(`Missing required route parameter: ${name}`);
-			}
-			return `${segment.startsWith("/") ? "/" : ""}${encodeURIComponent(String(resolved))}`;
-		}) || "/";
-	}
-};
-
-//#endregion
-//#region src/core/Request.ts
-var Request = class extends ClearRequest {
-	original;
-	method = "GET";
-	path = "/";
-	url = "/";
-	headers = {};
-	constructor(init) {
-		super(init);
-		Object.assign(this, init);
-	}
-	getBody() {
-		return this.body ?? {};
-	}
-	header(name) {
-		if (typeof this.headers.get === "function") return this.headers.get(name) || "";
-		const headers = this.headers;
-		const value = headers[name] ?? headers[name.toLowerCase()];
-		return Array.isArray(value) ? String(value[0] ?? "") : String(value ?? "");
-	}
-	param(name) {
-		return this.params?.[name];
-	}
-	input(name) {
-		return this.body?.[name] ?? this.query?.[name] ?? this.params?.[name];
-	}
-	is(method) {
-		return this.method.toLowerCase() === String(method).toLowerCase();
-	}
-};
-
-//#endregion
-//#region src/core/Response.ts
-var Response = class {
-	body;
-	headers = new Headers();
-	sent = false;
-	statusCode = 200;
-	statusText = "OK";
-	constructor(init) {
-		const { status: _, ...rest } = init ?? {};
-		Object.assign(this, rest);
-		if (init?.headers && !(init.headers instanceof Headers)) this.headers = new Headers(init.headers);
-		if (init?.status && typeof init.status === "number") this.statusCode = init?.status;
-	}
-	status(code) {
-		this.statusCode = code;
-		return this;
-	}
-	setStatusText(text) {
-		this.statusText = text;
-		return this;
-	}
-	code(code) {
-		return this.status(code);
-	}
-	setHeader(name, value) {
-		this.headers.set(name, value);
-		return this;
-	}
-	header(name, value) {
-		return this.setHeader(name, value);
-	}
-	set(name, value) {
-		return this.setHeader(name, value);
-	}
-	type(contentType) {
-		return this.setHeader("Content-Type", contentType);
-	}
-	send(body) {
-		this.body = body;
-		this.sent = true;
-		return this;
-	}
-	json(body) {
-		return this.type("application/json; charset=utf-8").send(body);
-	}
-	html(body) {
-		return this.type("text/html; charset=utf-8").send(body);
-	}
-	text(body) {
-		return this.type("text/plain; charset=utf-8").send(body);
-	}
-	noContent() {
-		return this.status(204).send(null);
-	}
-};
-
-//#endregion
-//#region src/core/plugins.ts
-/**
-* Creates a new plugin
-* 
-* @param plugin 
-* @returns 
-*/
-function definePlugin(plugin) {
-	return plugin;
-}
-
-//#endregion
-//#region src/core/bindings.ts
-const metadataKey = Symbol.for("clear-router:binding-metadata");
-const bindings = /* @__PURE__ */ new WeakMap();
-var Container = class {
-	static registry = /* @__PURE__ */ new Map();
-	static bind(token, value) {
-		this.registry.set(token, value);
-	}
-	static unbind(token) {
-		this.registry.delete(token);
-	}
-	static clear() {
-		this.registry.clear();
-	}
-	static has(token) {
-		return this.registry.has(token) || Boolean(this.findEquivalentToken(token));
-	}
-	static bindings() {
-		return Object.fromEntries(this.registry.entries());
-	}
-	static async resolve(token, ctx, autoDiscover = false) {
-		if (token === Request) return ctx.clearRequest;
-		if (token === Response) return ctx.clearResponse;
-		const binding = this.getBinding(token);
-		if (binding) return this.resolveBinding(binding, ctx, autoDiscover);
-		if (autoDiscover && typeof token === "function") return new token();
-	}
-	static getBinding(token) {
-		if (this.registry.has(token)) return this.registry.get(token);
-		const equivalent = this.findEquivalentToken(token);
-		return equivalent ? this.registry.get(equivalent) : void 0;
-	}
-	static findEquivalentToken(token) {
-		const name = token.name;
-		if (!name) return;
-		const tokenParent = Object.getPrototypeOf(token);
-		const tokenProps = this.getComparableStaticProps(token);
-		for (const registered of this.registry.keys()) {
-			if (registered === token) continue;
-			if (registered.name !== name) continue;
-			const registeredParent = Object.getPrototypeOf(registered);
-			if (tokenParent && registeredParent && tokenParent.name !== registeredParent.name) continue;
-			const registeredProps = this.getComparableStaticProps(registered);
-			if (!this.staticPropsMatch(token, registered, tokenProps, registeredProps)) continue;
-			return registered;
-		}
-	}
-	static getComparableStaticProps(token) {
-		return Object.getOwnPropertyNames(token).filter((prop) => {
-			return ![
-				"length",
-				"name",
-				"prototype",
-				"arguments",
-				"caller"
-			].includes(prop);
-		});
-	}
-	static staticPropsMatch(token, registered, tokenProps, registeredProps) {
-		if (tokenProps.length !== registeredProps.length) return false;
-		for (const prop of tokenProps) {
-			if (!registeredProps.includes(prop)) return false;
-			if (Reflect.get(token, prop) !== Reflect.get(registered, prop)) return false;
-		}
-		return true;
-	}
-	static async resolveBinding(binding, ctx, autoDiscover) {
-		if (!binding) return void 0;
-		if (typeof binding !== "function") return binding;
-		if (isClass(binding)) return new binding();
-		const resolved = await binding(ctx);
-		if (typeof resolved === "function" && autoDiscover && isClass(resolved)) return new resolved();
-		return resolved;
-	}
-};
-function getStandardMetadata(metadata, propertyKey) {
-	const store = metadata && metadata[metadataKey];
-	if (!store) return void 0;
-	return propertyKey ? store[propertyKey] : void 0;
-}
-function getBindingMetadataFromTargets(targets) {
-	for (const { target, propertyKey } of targets) {
-		if (!target) continue;
-		const metadata = getBindingMetadata(target, propertyKey);
-		if (metadata) return metadata;
-		const standardMetadata = getStandardMetadata(target[Symbol.metadata], propertyKey);
-		if (standardMetadata) return standardMetadata;
-	}
-}
-function getBindingMetadata(target, propertyKey) {
-	if (propertyKey) return bindings.get(target)?.get(propertyKey);
-	return bindings.get(target)?.get("__route_handler__");
-}
-function getDesignParamTypes(target, propertyKey) {
-	return Reflect.getMetadata?.("design:paramtypes", target, propertyKey) ?? [];
-}
-function isClass(value) {
-	return typeof value === "function" && /^class\s/.test(Function.prototype.toString.call(value));
-}
-
-//#endregion
-//#region src/core/router.ts
-/**
-* @class clear-router CoreRouter
-* @description Core routing logic for clear-router, shared between all supported adapters (Express.js, H3, etc.)
-* @author 3m1n3nc3
-* @repository https://github.com/arkstack-tmp/clear-router
-*/
-var CoreRouter = class {
-	static routerStateNamespace = "clear-router:core";
-	static stateStoreKey = Symbol.for("clear-router:router-state");
-	static stateBoundKey = Symbol.for("clear-router:router-state-bound");
-	static defaultConfigKey = Symbol.for("clear-router:default-config");
-	static pluginStoreKey = Symbol.for("clear-router:plugins");
-	static pluginPendingKey = Symbol.for("clear-router:plugin-promises");
-	static pluginHttpCtxResolversKey = Symbol.for("clear-router:plugin-http-ctx");
-	static pluginArgumentResolversKey = Symbol.for("clear-router:plugin-argument-resolvers");
-	static requestProvider;
-	static responseProvider;
-	static config = {
-		inferParamName: false,
-		methodOverride: {
-			enabled: true,
-			bodyKeys: ["_method"],
-			headerKeys: ["x-http-method"]
-		},
-		container: {
-			enabled: false,
-			autoDiscover: false
-		}
-	};
-	static groupContext = new node_async_hooks.AsyncLocalStorage();
-	static pluginRequestContext = new node_async_hooks.AsyncLocalStorage();
-	static routes = /* @__PURE__ */ new Set([]);
-	static routesByPathMethod = /* @__PURE__ */ new Map();
-	static routesByMethod = /* @__PURE__ */ new Map();
-	static routesByName = /* @__PURE__ */ new Map();
-	static prefix = "";
-	static groupMiddlewares = [];
-	static globalMiddlewares = [];
-	/**
-	* Resets the router to it's default state
-	*/
-	static reset() {
-		this.routes.clear();
-		this.prefix = "";
-		this.groupMiddlewares = [];
-		this.globalMiddlewares = [];
-		this.routesByPathMethod.clear();
-		this.routesByMethod.clear();
-		this.routesByName.clear();
-		return this;
-	}
-	static createBaseConfig() {
-		return {
-			inferParamName: false,
-			methodOverride: {
-				enabled: true,
-				bodyKeys: ["_method"],
-				headerKeys: ["x-http-method"]
-			},
-			container: {
-				enabled: false,
-				autoDiscover: false
-			}
-		};
-	}
-	static mergeConfig(target, source) {
-		if (!source) return target;
-		if (source.methodOverride) target.methodOverride = {
-			...target.methodOverride || {},
-			...source.methodOverride
-		};
-		if (source.container) target.container = {
-			...target.container || {},
-			...source.container
-		};
-		return target;
-	}
-	static getDefaultConfig() {
-		const g = globalThis;
-		if (!g[this.defaultConfigKey]) g[this.defaultConfigKey] = this.createBaseConfig();
-		return {
-			inferParamName: g[this.defaultConfigKey].inferParamName,
-			methodOverride: { ...g[this.defaultConfigKey].methodOverride },
-			container: { ...g[this.defaultConfigKey].container }
-		};
-	}
-	static resolveStateNamespace() {
-		return String(this.routerStateNamespace || this.name || "clear-router:core");
-	}
-	static getStateStore() {
-		const g = globalThis;
-		if (!g[this.stateStoreKey]) g[this.stateStoreKey] = Object.create(null);
-		return g[this.stateStoreKey];
-	}
-	static getPluginStore() {
-		const g = globalThis;
-		if (!g[this.pluginStoreKey]) g[this.pluginStoreKey] = /* @__PURE__ */ new Set();
-		return g[this.pluginStoreKey];
-	}
-	static getPluginPendingStore() {
-		const g = globalThis;
-		if (!g[this.pluginPendingKey]) g[this.pluginPendingKey] = /* @__PURE__ */ new Set();
-		return g[this.pluginPendingKey];
-	}
-	static getPluginArgumentResolvers() {
-		const g = globalThis;
-		if (!g[this.pluginArgumentResolversKey]) g[this.pluginArgumentResolversKey] = /* @__PURE__ */ new Set();
-		return g[this.pluginArgumentResolversKey];
-	}
-	static getPluginHttpCtxResolvers() {
-		const g = globalThis;
-		if (!g[this.pluginHttpCtxResolversKey]) g[this.pluginHttpCtxResolversKey] = /* @__PURE__ */ new Set();
-		return g[this.pluginHttpCtxResolversKey];
-	}
-	static createDefaultState() {
-		return {
-			config: this.getDefaultConfig(),
-			groupContext: new node_async_hooks.AsyncLocalStorage(),
-			routes: /* @__PURE__ */ new Set([]),
-			routesByPathMethod: /* @__PURE__ */ new Map(),
-			routesByMethod: /* @__PURE__ */ new Map(),
-			routesByName: /* @__PURE__ */ new Map(),
-			prefix: "",
-			groupMiddlewares: [],
-			globalMiddlewares: []
-		};
-	}
-	static bindStateAccessors() {
-		if (Object.prototype.hasOwnProperty.call(this, this.stateBoundKey)) return;
-		const namespace = this.resolveStateNamespace();
-		const store = this.getStateStore();
-		if (!store[namespace]) store[namespace] = this.createDefaultState();
-		for (const key of [
-			"config",
-			"groupContext",
-			"routes",
-			"routesByPathMethod",
-			"routesByMethod",
-			"routesByName",
-			"prefix",
-			"groupMiddlewares",
-			"globalMiddlewares"
-		]) Object.defineProperty(this, key, {
-			get() {
-				const ns = this.resolveStateNamespace();
-				const registry = this.getStateStore();
-				if (!registry[ns]) registry[ns] = this.createDefaultState();
-				return registry[ns][key];
-			},
-			set(value) {
-				const ns = this.resolveStateNamespace();
-				const registry = this.getStateStore();
-				if (!registry[ns]) registry[ns] = this.createDefaultState();
-				registry[ns][key] = value;
-			},
-			configurable: true,
-			enumerable: true
-		});
-		Object.defineProperty(this, this.stateBoundKey, {
-			value: true,
-			configurable: false,
-			enumerable: false,
-			writable: false
-		});
-	}
-	static createDefaultOptionsHandler() {
-		return (ctx) => {
-			const allow = "GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD";
-			if (ctx?.header && ctx?.status && ctx?.body) {
-				ctx.header("Allow", allow);
-				ctx.status(204);
-				return ctx.body(null);
-			}
-			if (ctx?.res?.headers?.set) {
-				ctx.res.headers.set("Allow", allow);
-				ctx.res.status = 204;
-				return;
-			}
-			if (ctx?.res?.set) {
-				ctx.res.set("Allow", allow);
-				ctx.res.sendStatus(204);
-				return;
-			}
-			if (ctx?.reply?.header) {
-				ctx.reply.header("Allow", allow);
-				ctx.reply.code(204).send();
-				return;
-			}
-			if (ctx?.set && "status" in ctx) {
-				ctx.set("Allow", allow);
-				ctx.status = 204;
-				ctx.body = null;
-			}
-		};
-	}
-	/**
-	* Default configuration used for everytime the router is reset
-	* 
-	* @param options 
-	*/
-	static configureDefaults(options) {
-		const g = globalThis;
-		const defaults = this.mergeConfig(g[this.defaultConfigKey] || this.createBaseConfig(), options);
-		g[this.defaultConfigKey] = defaults;
-		const store = this.getStateStore();
-		for (const state of Object.values(store)) state.config = this.mergeConfig(state.config || this.createBaseConfig(), options);
-	}
-	/**
-	* Use a registered plugin
-	* 
-	* @param this 
-	* @param plugin 
-	* @param options 
-	* @returns 
-	*/
-	static async use(plugin, options) {
-		const name = typeof plugin === "function" ? plugin.name : plugin.name;
-		const store = this.getPluginStore();
-		if (name && store.has(name)) return;
-		if (name) store.add(name);
-		const setup = async () => {
-			const ctx = {
-				container: Container,
-				bind: this.createPluginBind(),
-				resolveArguments: (resolver) => {
-					this.getPluginArgumentResolvers().add(resolver);
-				},
-				useHttpContext: (resolver) => {
-					this.getPluginHttpCtxResolvers().add(resolver);
-				},
-				bindings: Container.bindings(),
-				configure: this.configure.bind(this),
-				configureDefaults: this.configureDefaults.bind(this),
-				get request() {
-					return this.getRequest();
-				},
-				get response() {
-					return this.getResponse();
-				},
-				getRequest: () => this.getCurrentPluginRequestContext()?.request,
-				getResponse: () => this.getCurrentPluginRequestContext()?.response,
-				options
-			};
-			if (typeof plugin === "function") await plugin(ctx);
-			else await plugin.setup(ctx);
-		};
-		const pending = this.getPluginPendingStore();
-		const promise = setup();
-		pending.add(promise);
-		try {
-			await promise;
-		} catch (error) {
-			if (name) store.delete(name);
-			throw error;
-		} finally {
-			pending.delete(promise);
-		}
-	}
-	static async pluginsReady() {
-		const pending = Array.from(this.getPluginPendingStore());
-		if (!pending.length) return;
-		await Promise.all(pending);
-	}
-	static getCurrentPluginRequestContext() {
-		return this.pluginRequestContext.getStore();
-	}
-	static createPluginRequestContext(ctx) {
-		const request = ctx.clearRequest;
-		const response = ctx.clearResponse;
-		return {
-			...ctx,
-			ctx,
-			request,
-			response,
-			getBindings: () => Container.bindings()
-		};
-	}
-	static createPluginBind() {
-		const bind = (token, value) => {
-			if (typeof value === "function" && !isClass(value)) {
-				const factory = value;
-				Container.bind(token, (ctx) => factory(this.createPluginRequestContext(ctx)));
-				return;
-			}
-			Container.bind(token, value);
-		};
-		return bind;
-	}
-	static async resolvePluginArguments(ctx, routeContext) {
-		const resolvers = Array.from(this.getPluginArgumentResolvers());
-		if (!resolvers.length) return void 0;
-		const pluginContext = {
-			...this.createPluginRequestContext(ctx),
-			...routeContext
-		};
-		for (const resolver of resolvers) {
-			const args = await resolver(pluginContext);
-			if (Array.isArray(args)) return args;
-		}
-	}
-	static async resolvePluginHttpCtx(ctx) {
-		const resolvers = Array.from(this.getPluginHttpCtxResolvers());
-		if (!resolvers.length) return void 0;
-		const pluginContext = this.createPluginRequestContext(ctx);
-		for (const resolver of resolvers) await resolver(pluginContext);
-	}
-	static ensureState() {
-		this.bindStateAccessors();
-		if (!this.config) this.config = { methodOverride: {
-			enabled: true,
-			bodyKeys: ["_method"],
-			headerKeys: ["x-http-method"]
-		} };
-		if (!this.groupContext) this.groupContext = new node_async_hooks.AsyncLocalStorage();
-		if (!this.routes || Array.isArray(this.routes)) this.routes = new Set(this.routes ?? []);
-		if (!this.routesByPathMethod) this.routesByPathMethod = /* @__PURE__ */ new Map();
-		if (!this.routesByMethod) this.routesByMethod = /* @__PURE__ */ new Map();
-		if (!this.routesByName) this.routesByName = /* @__PURE__ */ new Map();
-		if (typeof this.prefix !== "string") this.prefix = "";
-		if (!Array.isArray(this.groupMiddlewares)) this.groupMiddlewares = [];
-		if (!Array.isArray(this.globalMiddlewares)) this.globalMiddlewares = [];
-	}
-	/**
-	* Normalizes a path by ensuring it starts with a single slash and does not have trailing 
-	* slashes, while preserving dynamic segments and parameters.
-	* 
-	* @param path  The path to normalize.
-	* @returns     The normalized path.
-	*/
-	static normalizePath(path) {
-		return "/" + path.split("/").filter(Boolean).join("/");
-	}
-	static parseRouteParameters(path) {
-		const parameters = [];
-		const seen = /* @__PURE__ */ new Set();
-		const pattern = /\{([^{}]+)\}/g;
-		let match;
-		while ((match = pattern.exec(path)) !== null) {
-			const raw = match[1].trim();
-			const optional = raw.endsWith("?");
-			const [name, field] = (optional ? raw.slice(0, -1) : raw).split(":", 2).map((part) => part.trim());
-			if (!name || seen.has(name)) continue;
-			seen.add(name);
-			parameters.push({
-				name,
-				field: field || void 0,
-				optional
-			});
-		}
-		return parameters;
-	}
-	static expandRoutePath(path) {
-		let paths = [""];
-		const segments = this.normalizePath(path).split("/").filter(Boolean);
-		for (const segment of segments) {
-			const match = segment.match(/^\{([^{}]+)\}$/);
-			if (!match) {
-				paths = paths.map((current) => `${current}/${segment}`);
-				continue;
-			}
-			const raw = match[1].trim();
-			const optional = raw.endsWith("?");
-			const [rawName] = (optional ? raw.slice(0, -1) : raw).split(":", 2);
-			const name = rawName.trim();
-			if (!name) continue;
-			const parameterSegment = `/:${name}`;
-			paths = optional ? paths.flatMap((current) => [current, `${current}${parameterSegment}`]) : paths.map((current) => `${current}${parameterSegment}`);
-		}
-		return paths.map((path) => path || "/");
-	}
-	static routeRegistrationPaths(path) {
-		return this.expandRoutePath(path);
-	}
-	/**
-	* Configures the router with the given options, such as method override settings.
-	* 
-	* @param this 
-	* @param options 
-	* @returns 
-	*/
-	static configure(options) {
-		this.ensureState();
-		this.config = this.mergeConfig(this.getDefaultConfig(), this.config);
-		const container = options?.container;
-		if (container) {
-			if (typeof container.enabled === "boolean") this.config.container.enabled = container.enabled;
-			if (typeof container.autoDiscover === "boolean") this.config.container.autoDiscover = container.autoDiscover;
-		}
-		if (options?.inferParamName) this.config.inferParamName = options?.inferParamName;
-		const override = options?.methodOverride;
-		if (override) {
-			if (typeof override.enabled === "boolean") this.config.methodOverride.enabled = override.enabled;
-			const bodyKeys = override.bodyKeys;
-			if (typeof bodyKeys !== "undefined") this.config.methodOverride.bodyKeys = (Array.isArray(bodyKeys) ? bodyKeys : [bodyKeys]).map((e) => String(e).trim()).filter(Boolean);
-			const headerKeys = override.headerKeys;
-			if (typeof headerKeys !== "undefined") this.config.methodOverride.headerKeys = (Array.isArray(headerKeys) ? headerKeys : [headerKeys]).map((e) => String(e).trim().toLowerCase()).filter(Boolean);
-		}
-	}
-	static resolveMethodOverride(method, headers, body) {
-		this.ensureState();
-		if (!this.config.methodOverride?.enabled || method.toLowerCase() !== "post") return null;
-		let override;
-		const headerValueFor = (key) => {
-			if (typeof headers.get === "function") return headers.get(key);
-			const value = headers?.[key];
-			return Array.isArray(value) ? value[0] : value;
-		};
-		for (const key of this.config.methodOverride?.headerKeys || []) {
-			const value = headerValueFor(key);
-			if (value) {
-				override = value;
-				break;
-			}
-		}
-		if (!override && body && typeof body === "object") for (const key of this.config.methodOverride?.bodyKeys || []) {
-			const value = body[key];
-			if (typeof value !== "undefined" && value !== null && value !== "") {
-				override = value;
-				break;
-			}
-		}
-		const normalized = String(override || "").trim().toLowerCase();
-		if (!normalized) return null;
-		if ([
-			"put",
-			"patch",
-			"delete",
-			"post"
-		].includes(normalized)) return normalized;
-		return null;
-	}
-	/**
-	* Adds a new route to the router.
-	* 
-	* @param this 
-	* @param methods 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static add(methods, path, handler, middlewares) {
-		this.ensureState();
-		const context = this.groupContext.getStore();
-		const activePrefix = context?.prefix ?? this.prefix;
-		const activeGroupMiddlewares = context?.groupMiddlewares ?? this.groupMiddlewares;
-		methods = Array.isArray(methods) ? methods : [methods];
-		middlewares = middlewares ? Array.isArray(middlewares) ? middlewares : [middlewares] : void 0;
-		const fullPath = this.normalizePath(`${activePrefix}/${path}`);
-		const registrationPaths = this.routeRegistrationPaths(fullPath);
-		const parameters = this.parseRouteParameters(fullPath);
-		const route = new Route(methods.includes("options") ? methods : methods.concat("options"), fullPath, handler, [
-			...this.globalMiddlewares,
-			...activeGroupMiddlewares,
-			...middlewares || []
-		], {
-			registrationPaths,
-			parameters,
-			onName: (name, route, previousName) => {
-				if (previousName && this.routesByName.get(previousName) === route) this.routesByName.delete(previousName);
-				this.routesByName.set(name, route);
-			}
-		});
-		if (!methods.includes("options") && !this.routesByPathMethod.get(`OPTIONS ${fullPath}`)) this.options(path, this.createDefaultOptionsHandler());
-		this.routes.add(route);
-		for (const method of methods.map((m) => m.toUpperCase())) {
-			this.routesByPathMethod.set(`${method} ${fullPath}`, route);
-			if (!this.routesByMethod.has(method)) this.routesByMethod.set(method, []);
-			this.routesByMethod.get(method)?.push(route);
-		}
-		return route;
-	}
-	/**
-	* Define a resourceful API controller with standard CRUD routes.
-	* 
-	* @param this 
-	* @param basePath 
-	* @param controller 
-	* @param options 
-	*/
-	static apiResource(basePath, controller, options) {
-		let paramName = "id";
-		if (!!this.config.inferParamName && this.hasPackageInstalled("@h3ravel/support")) {
-			const { str } = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("@h3ravel/support");
-			paramName = str(basePath).singular().afterLast("/").toString();
-		}
-		const actions = {
-			index: {
-				method: "get",
-				path: "/"
-			},
-			show: {
-				method: "get",
-				path: `/:${paramName}`
-			},
-			create: {
-				method: "post",
-				path: "/"
-			},
-			update: {
-				method: "put",
-				path: `/:${paramName}`
-			},
-			destroy: {
-				method: "delete",
-				path: `/:${paramName}`
-			}
-		};
-		const only = options?.only || Object.keys(actions);
-		const except = options?.except || [];
-		const preController = typeof controller === "function" ? new controller() : controller;
-		for (const action of only) {
-			if (except.includes(action)) continue;
-			if (typeof preController[action] === "function") {
-				const { method, path } = actions[action];
-				const actionMiddlewares = typeof options?.middlewares === "object" && !Array.isArray(options.middlewares) ? options.middlewares[action] : options?.middlewares;
-				const name = `${basePath}${path}`.replace(/\/:[^/]+|\/\{[^}]+\}/g, "").replace(/\{(\w+):[^}]+\}/g, "$1").replace(/\/|:|[{}]/g, ".").replace(/\.{2,}/g, ".").replace(/^\.|\.$/g, "");
-				this.add(method, `${basePath}${path}`, [controller, action], Array.isArray(actionMiddlewares) ? actionMiddlewares : actionMiddlewares ? [actionMiddlewares] : void 0).name(name + "." + action.toLowerCase());
-			}
-		}
-	}
-	/**
-	* Adds a new GET route to the router.
-	* 
-	* @param this          The router instance.
-	* @param path          The path for the GET route.
-	* @param handler       The handler function for the GET route.
-	* @param middlewares   Optional middlewares to apply to the GET route.
-	*/
-	static get(path, handler, middlewares) {
-		return this.add("get", path, handler, middlewares);
-	}
-	/**
-	* Adds a new POST route to the router.
-	* 
-	* @param this 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static post(path, handler, middlewares) {
-		return this.add("post", path, handler, middlewares);
-	}
-	/**
-	* Adds a new PUT route to the router.
-	* 
-	* @param this 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static put(path, handler, middlewares) {
-		return this.add("put", path, handler, middlewares);
-	}
-	/**
-	* Adds a new DELETE route to the router.
-	* 
-	* @param this 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static delete(path, handler, middlewares) {
-		return this.add("delete", path, handler, middlewares);
-	}
-	/**
-	* Adds a new PATCH route to the router.
-	* 
-	* @param this 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static patch(path, handler, middlewares) {
-		return this.add("patch", path, handler, middlewares);
-	}
-	/**
-	* Adds a new OPTIONS route to the router.
-	* 
-	* @param this 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static options(path, handler, middlewares) {
-		return this.add("options", path, handler, middlewares);
-	}
-	/**
-	* Adds a new HEAD route to the router.
-	* 
-	* @param this 
-	* @param path 
-	* @param handler 
-	* @param middlewares 
-	*/
-	static head(path, handler, middlewares) {
-		return this.add("head", path, handler, middlewares);
-	}
-	/**
-	* Defines a group of routes with a common prefix.
-	* 
-	* @param this 
-	* @param prefix 
-	* @param callback 
-	* @param middlewares 
-	*/
-	static async group(prefix, callback, middlewares) {
-		this.ensureState();
-		const context = this.groupContext.getStore();
-		const previousPrefix = context?.prefix ?? this.prefix;
-		const previousMiddlewares = context?.groupMiddlewares ?? this.groupMiddlewares;
-		const fullPrefix = [previousPrefix, prefix].filter(Boolean).join("/");
-		const nextContext = {
-			prefix: this.normalizePath(fullPrefix),
-			groupMiddlewares: [...previousMiddlewares, ...middlewares || []]
-		};
-		await this.groupContext.run(nextContext, async () => {
-			await Promise.resolve(callback());
-		});
-	}
-	/**
-	* Adds global middlewares to the router, which will be applied to all routes.
-	* 
-	* @param this 
-	* @param middlewares 
-	* @param callback 
-	*/
-	static middleware(middlewares, callback) {
-		this.ensureState();
-		const prevMiddlewares = this.globalMiddlewares;
-		this.globalMiddlewares = [...prevMiddlewares, ...middlewares || []];
-		callback();
-		this.globalMiddlewares = prevMiddlewares;
-	}
-	static allRoutes(type) {
-		this.ensureState();
-		if (type === "method") return Object.fromEntries(this.routesByMethod.entries());
-		if (type === "path") return Object.fromEntries(this.routesByPathMethod.entries());
-		if (type === "name") return Object.fromEntries(this.routesByName.entries());
-		return Array.from(this.routes).filter((e) => e.methods.length > 1 || e.methods[0] !== "options");
-	}
-	static route(name) {
-		this.ensureState();
-		return this.routesByName.get(name);
-	}
-	static url(name, params) {
-		return this.route(name)?.toPath(params);
-	}
-	/**
-	* Provide a class that will overide the base Request instance
-	* 
-	* @param provider 
-	*/
-	static setRequestProvider(provider) {
-		this.requestProvider = provider;
-	}
-	/**
-	* Provide a class that will overide the base Response instance
-	* 
-	* @param provider 
-	*/
-	static setResponseProvider(provider) {
-		this.responseProvider = provider;
-	}
-	static hasPackageInstalled(name) {
-		try {
-			(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve(name, { paths: [process.cwd()] });
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	static initializeInstance(provider, args) {
-		const isRequest = [
-			"CoreRequest",
-			"Request",
-			"ClearRequest"
-		].includes(provider.name);
-		const isResponse = [
-			"CoreResponse",
-			"Response",
-			"ClearResponse"
-		].includes(provider.name);
-		if (isRequest && this.requestProvider) return new this.requestProvider(args);
-		else if (isResponse && this.responseProvider) return new this.responseProvider(args);
-		return new provider(args);
-	}
-	static resolveHandler(route) {
-		let handlerFunction;
-		let instance = null;
-		let bindingTarget;
-		let bindingMethod;
-		let bindingHandler;
-		let bindingMetadata;
-		if (typeof route.handler === "function") {
-			handlerFunction = route.handler.bind(route);
-			bindingTarget = route.handler;
-			bindingHandler = route.handler;
-		} else if (Array.isArray(route.handler) && route.handler.length === 2) {
-			const [ControllerType, method] = route.handler;
-			if (["function", "object"].includes(typeof ControllerType) && typeof ControllerType[method] === "function") {
-				instance = ControllerType;
-				handlerFunction = ControllerType[method].bind(ControllerType);
-				bindingTarget = ControllerType;
-				bindingMethod = method;
-				bindingHandler = ControllerType[method];
-				bindingMetadata = ControllerType[Symbol.metadata];
-			} else if (typeof ControllerType === "function") {
-				instance = new ControllerType();
-				if (typeof instance[method] === "function") {
-					handlerFunction = instance[method].bind(instance);
-					bindingTarget = ControllerType.prototype;
-					bindingMethod = method;
-					bindingHandler = instance[method];
-					bindingMetadata = ControllerType[Symbol.metadata];
-				} else throw new Error(`Method "${method}" not found in controller instance "${ControllerType.name}"`);
-			} else throw new Error(`Invalid controller type for route: ${route.path}`);
-		} else throw new Error(`Invalid handler format for route: ${route.path}`);
-		return {
-			handlerFunction,
-			instance,
-			bindingTarget,
-			bindingMethod,
-			bindingHandler,
-			bindingMetadata
-		};
-	}
-	static async callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata) {
-		return this.pluginRequestContext.run(this.createPluginRequestContext(ctx), async () => {
-			await this.pluginsReady();
-			await this.resolvePluginHttpCtx(ctx);
-			if (!this.config.container?.enabled) return handlerFunction(ctx, ctx.clearRequest);
-			const designTokens = [...bindingTarget ? getDesignParamTypes(bindingTarget, bindingMethod) : [], ...bindingHandler ? getDesignParamTypes(bindingHandler) : []];
-			const metadata = getBindingMetadataFromTargets([
-				{
-					target: bindingTarget,
-					propertyKey: bindingMethod
-				},
-				{ target: bindingHandler },
-				{
-					target: bindingTarget,
-					propertyKey: "__class__"
-				}
-			]) ?? getStandardMetadata(bindingMetadata, bindingMethod) ?? getStandardMetadata(bindingMetadata, "__class__");
-			const tokens = metadata?.tokens?.length ? metadata.tokens : designTokens;
-			const pluginArgs = await this.resolvePluginArguments(ctx, {
-				target: bindingTarget,
-				method: bindingMethod,
-				handler: bindingHandler,
-				metadata: bindingMetadata,
-				tokens,
-				designTokens
-			});
-			if (pluginArgs?.length) return handlerFunction(...pluginArgs);
-			if (!metadata || !tokens.length) return handlerFunction(ctx, ctx.clearRequest);
-			const args = [];
-			for (const token of tokens) {
-				const resolved = await Container.resolve(token, ctx, Boolean(this.config.container?.autoDiscover));
-				if (typeof resolved === "undefined") return handlerFunction(ctx, ctx.clearRequest);
-				args.push(resolved);
-			}
-			return handlerFunction(...args);
-		});
-	}
-	static bindRequestToInstance(ctx, instance, route, payload) {
-		const clearRequest = ctx.clearRequest instanceof Request ? ctx.clearRequest : this.initializeInstance(Request, {
-			ctx,
-			route,
-			body: payload.body,
-			query: payload.query,
-			params: payload.params,
-			method: String(payload.method || ctx.req?.method || ctx.method || "GET").toUpperCase(),
-			path: String(ctx.path || ctx.req?.path || ctx.req?.url || route.path),
-			url: String(ctx.url || ctx.req?.url || ctx.req?.originalUrl || route.path),
-			headers: ctx.req?.headers || ctx.headers || {},
-			original: ctx.req || ctx.request || ctx
-		});
-		clearRequest.ctx = ctx;
-		clearRequest.route = route;
-		clearRequest.body = payload.body;
-		clearRequest.query = payload.query;
-		clearRequest.params = payload.params;
-		ctx.clearRequest = clearRequest;
-		Container.bind(Request, ctx.clearRequest);
-		if (!(ctx.clearResponse instanceof Response)) {
-			ctx.clearResponse = this.initializeInstance(Response, ctx.response ?? ctx.reply ?? ctx.res);
-			Container.bind(Response, ctx.clearResponse);
-		}
-		if (!instance) return;
-		instance.ctx = ctx;
-		instance.body = payload.body;
-		instance.query = payload.query;
-		instance.params = payload.params;
-		instance.clearRequest = clearRequest;
-	}
-};
-
-//#endregion
-exports.ClearRequest = ClearRequest;
-exports.Controller = Controller;
-exports.CoreRouter = CoreRouter;
-exports.Request = Request;
-exports.Response = Response;
-exports.Route = Route;
-exports.definePlugin = definePlugin;
+const require_ClearRequest = require('./ClearRequest.cjs');
+const require_Controller = require('./Controller.cjs');
+const require_Route = require('./Route.cjs');
+const require_Request = require('./core/Request.cjs');
+const require_Response = require('./core/Response.cjs');
+const require_plugins = require('./core/plugins.cjs');
+const require_router = require('./core/router.cjs');
+require('./core/index.cjs');
+
+exports.ClearRequest = require_ClearRequest.ClearRequest;
+exports.Controller = require_Controller.Controller;
+exports.CoreRouter = require_router.CoreRouter;
+exports.Request = require_Request.Request;
+exports.Response = require_Response.Response;
+exports.Route = require_Route.Route;
+exports.definePlugin = require_plugins.definePlugin;