@arkstack/common 0.18.12 → 0.19.1

package/dist/dist-DwGScrDq.js

@@ -0,0 +1,3819 @@
+import { createRequire } from "node:module";
+import { createJiti } from "jiti";
+import "@arkstack/contract";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { readdir, stat } from "node:fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import "node:crypto";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/ClearRequest.mjs
+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 ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/Route.mjs
+/**
+* Parse the placeholder parameters declared in a domain/host pattern such as
+* `{account}.example.com`. Mirrors the path parameter syntax (supporting the
+* optional `{name?}` form) so domain parameters feel consistent with path ones.
+*
+* @param pattern
+* @returns
+*/
+const parseDomainParameters = (pattern) => {
+	if (!pattern) return [];
+	const parameters = [];
+	const seen = /* @__PURE__ */ new Set();
+	const matcher = /\{([^{}]+)\}/g;
+	let match;
+	while ((match = matcher.exec(pattern)) !== 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;
+};
+/**
+* @class clear-router Route
+* @description A route describes a single enpoint on clear-router
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-hq/clear-router
+*/
+var Route = class Route {
+	ctx;
+	body = {};
+	query = {};
+	params = {};
+	clearRequest;
+	methods;
+	path;
+	registrationPaths;
+	parameters;
+	routeName;
+	handler;
+	middlewares;
+	controllerName;
+	actionName;
+	handlerType;
+	middlewareCount;
+	domainPattern;
+	domainParameters;
+	constraints = {};
+	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.domainPattern = options.domain;
+		this.domainParameters = parseDomainParameters(options.domain);
+		this.onName = options.onName;
+		this.normalizeMiddleware = options.normalizeMiddleware;
+	}
+	onName;
+	normalizeMiddleware;
+	static currentResolvers;
+	/**
+	* Wire the resolvers used by the static `current*` accessors. Called once by
+	* `CoreRouter` so `Route.current()` reflects the active request.
+	*
+	* @internal
+	* @param resolvers
+	*/
+	static bindCurrentResolvers(resolvers) {
+		Route.currentResolvers = resolvers;
+	}
+	/**
+	* Get the route currently being dispatched, if any.
+	*
+	* @returns
+	*/
+	static current() {
+		return Route.currentResolvers?.current();
+	}
+	/**
+	* Get the name of the route currently being dispatched.
+	*
+	* @returns
+	*/
+	static currentRouteName() {
+		return Route.currentResolvers?.currentRouteName() ?? "";
+	}
+	/**
+	* Get the action (controller@method or `Closure`) of the route currently
+	* being dispatched.
+	*
+	* @returns
+	*/
+	static currentRouteAction() {
+		return Route.currentResolvers?.currentRouteAction() ?? "";
+	}
+	/**
+	* The route action expressed as `Controller@method` for controller routes or
+	* `Closure` for callback routes.
+	*/
+	get action() {
+		if (this.handlerType === "controller") {
+			const method = String(this.actionName ?? "");
+			return this.controllerName ? `${this.controllerName}@${method}` : method;
+		}
+		return "Closure";
+	}
+	/**
+	* Set the route name
+	*
+	* @param name
+	* @returns
+	*/
+	name(name) {
+		const previousName = this.routeName;
+		this.routeName = name;
+		this.onName?.(name, this, previousName);
+		return this;
+	}
+	/**
+	* Constrain the route to a host pattern such as `{account}.example.com`.
+	* Any `{placeholder}` segments are exposed as route parameters once matched.
+	*
+	* @param pattern
+	* @returns
+	*/
+	domain(pattern) {
+		this.domainPattern = pattern;
+		this.domainParameters = parseDomainParameters(pattern);
+		return this;
+	}
+	/**
+	* Constrain one or more route parameters with a regular expression. Accepts
+	* either `where(name, pattern)` or `where({ name: pattern, ... })`.
+	*
+	* @param name
+	* @param pattern
+	* @returns
+	*/
+	where(name, pattern) {
+		if (typeof name === "object") Object.assign(this.constraints, name);
+		else if (typeof pattern !== "undefined") this.constraints[name] = pattern;
+		return this;
+	}
+	/**
+	* Constrain the given parameters to numeric values.
+	*
+	* @param names
+	* @returns
+	*/
+	whereNumber(...names) {
+		return this.applyConstraint(names, "[0-9]+");
+	}
+	/**
+	* Constrain the given parameters to alphabetic values.
+	*
+	* @param names
+	* @returns
+	*/
+	whereAlpha(...names) {
+		return this.applyConstraint(names, "[a-zA-Z]+");
+	}
+	/**
+	* Constrain the given parameters to alphanumeric values.
+	*
+	* @param names
+	* @returns
+	*/
+	whereAlphaNumeric(...names) {
+		return this.applyConstraint(names, "[a-zA-Z0-9]+");
+	}
+	/**
+	* Constrain the given parameters to UUID values.
+	*
+	* @param names
+	* @returns
+	*/
+	whereUuid(...names) {
+		return this.applyConstraint(names, "[\\da-fA-F]{8}-[\\da-fA-F]{4}-[\\da-fA-F]{4}-[\\da-fA-F]{4}-[\\da-fA-F]{12}");
+	}
+	/**
+	* Constrain the given parameters to ULID values.
+	*
+	* @param names
+	* @returns
+	*/
+	whereUlid(...names) {
+		return this.applyConstraint(names, "[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}");
+	}
+	/**
+	* Constrain a parameter to one of the given values.
+	*
+	* @param name
+	* @param values
+	* @returns
+	*/
+	whereIn(name, values) {
+		const escaped = values.map((value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, (match) => `\\${match}`));
+		this.constraints[name] = escaped.join("|");
+		return this;
+	}
+	applyConstraint(names, pattern) {
+		for (const name of names) this.constraints[name] = pattern;
+		return this;
+	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	*
+	* @param middlewares
+	* @returns
+	*/
+	middleware(middlewares) {
+		const normalized = (Array.isArray(middlewares) ? middlewares : [middlewares]).map((middleware) => this.normalizeMiddleware?.(middleware) ?? middleware);
+		this.middlewares.push(...normalized);
+		this.middlewareCount = this.middlewares.length;
+		return this;
+	}
+	/**
+	* Resolve the route's domain pattern into a concrete host using the given
+	* parameters.
+	*
+	* @param params
+	* @returns
+	*/
+	resolveDomainHost(params) {
+		return this.domainPattern.replace(/\{([^{}]+)\}/g, (_, raw) => {
+			const optional = raw.endsWith("?");
+			const name = (optional ? raw.slice(0, -1) : raw).split(":", 2)[0].trim();
+			const value = params[name];
+			if (typeof value === "undefined" || value === null || value === "") {
+				if (optional) return "";
+				throw new Error(`Missing required route domain parameter: ${name}`);
+			}
+			return encodeURIComponent(String(value));
+		});
+	}
+	/**
+	* Get the path generated and accessible by this route
+	*
+	* @param params
+	* @returns
+	*/
+	toPath(params = {}) {
+		const resolved = 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))}`;
+		}) || "/";
+		if (!this.domainPattern) return resolved;
+		return `//${this.resolveDomainHost(params)}${resolved}`;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/core/helpers.mjs
+const wrap = (value) => {
+	if (value === null || value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+};
+/**
+* 
+* Dynamically imports a file at the given path with full TypeScript support,
+* including `tsconfig.json` path aliases. 
+*
+* @param filePath - The path to the file to import. 
+* @returns The imported module typed as `T`.
+*
+* @example
+* const config = await importFile<AppConfig>('./config/app.ts')
+*/
+const importFile = async (filePath, userOptions, resolveOptions) => {
+	const resolvedPath = resolve(filePath);
+	return await createJiti(pathToFileURL(resolvedPath).href, {
+		...userOptions,
+		interopDefault: false,
+		tsconfigPaths: true
+	}).import(resolvedPath, resolveOptions);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/RouteGroup.mjs
+/**
+* @class clear-router RouteGroup
+* @description A route group describes a collection of routes on clear-router
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-hq/clear-router
+*/
+var RouteGroup = class {
+	checks = [];
+	conditions = [];
+	registration;
+	routes = /* @__PURE__ */ new Set();
+	unfilteredSources = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+		this.registration = this.register();
+	}
+	/**
+	* Returning a falsy value will stop route group registration
+	* 
+	* @param condition 
+	* @returns 
+	*/
+	when(condition) {
+		this.conditions.push(condition);
+		const unfilteredSources = Array.from(this.unfilteredSources);
+		if (unfilteredSources.length) this.checks.push(this.registration.then(async () => {
+			for (const source of unfilteredSources) if (!await condition(source)) {
+				this.rollback();
+				break;
+			}
+		}));
+		return this;
+	}
+	/**
+	* Register one or more middleware that will be executed before every route in the group.
+	*
+	* @param middlewares
+	* @returns
+	*/
+	middleware(middlewares) {
+		this.checks.push(this.registration.then(() => {
+			for (const route of this.routes) route.middleware(middlewares);
+		}));
+		return this;
+	}
+	/**
+	* Attaches callbacks for the resolution and/or rejection of the RouteGroup.
+	* 
+	* @param onfulfilled 
+	* @param onrejected 
+	* @returns 
+	*/
+	then(onfulfilled, onrejected) {
+		return Promise.all([this.registration, ...this.checks]).then(() => void 0).then(onfulfilled, onrejected);
+	}
+	/**
+	* Register the routes
+	*/
+	async register() {
+		const current = this.options.context.getStore();
+		const previousPrefix = current?.prefix ?? this.options.defaultPrefix;
+		const previousMiddlewares = current?.groupMiddlewares ?? this.options.defaultMiddlewares;
+		const fullPrefix = [previousPrefix, this.options.prefix].filter(Boolean).join("/");
+		const nextContext = {
+			prefix: this.options.normalizePath(fullPrefix),
+			groupMiddlewares: [...previousMiddlewares, ...this.options.middlewares || []],
+			domain: this.options.domain ?? current?.domain,
+			routeCollectors: [...current?.routeCollectors ?? [], this.routes]
+		};
+		await this.options.context.run(nextContext, async () => {
+			for (const entry of Array.isArray(this.options.source) ? this.options.source : [this.options.source]) {
+				if (typeof entry === "function") {
+					if (!this.conditions.length) this.unfilteredSources.add(entry);
+					else if (!await this.accepts(entry)) continue;
+					await Promise.resolve(entry());
+					continue;
+				}
+				const resolved = await this.resolveFiles(entry);
+				if (!resolved.directory && !await this.accepts(entry)) continue;
+				for (const file of resolved.files) {
+					if (resolved.directory && !await this.accepts(file)) continue;
+					await importFile(file);
+				}
+			}
+		});
+	}
+	/**
+	* Rollback the route registration
+	*/
+	rollback() {
+		for (const route of this.routes) this.options.removeRoute(route);
+	}
+	/**
+	* Check whether a callback or path should be registered.
+	* 
+	* @param source 
+	* @returns 
+	*/
+	async accepts(source) {
+		for (const condition of this.conditions) if (!await condition(source)) return false;
+		return true;
+	}
+	/**
+	* Resolve files from the group path
+	* 
+	* @param source 
+	* @returns 
+	*/
+	async resolveFiles(source) {
+		const resolved = isAbsolute(source) ? source : resolve(process.cwd(), source);
+		let sourceStat;
+		try {
+			sourceStat = await stat(resolved);
+		} catch {
+			throw new Error(`Route group source not found: ${source}`);
+		}
+		if (sourceStat.isFile()) return {
+			directory: false,
+			files: [resolved]
+		};
+		if (!sourceStat.isDirectory()) throw new Error(`Route group source must be a file or directory: ${source}`);
+		return {
+			directory: true,
+			files: await this.readDirectory(resolved)
+		};
+	}
+	/**
+	* Read all the files in the configured directory
+	* 
+	* @param directory 
+	* @returns 
+	*/
+	async readDirectory(directory) {
+		const entries = await readdir(directory, { withFileTypes: true });
+		const files = [];
+		for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+			const path = join(directory, entry.name);
+			if (entry.isDirectory()) files.push(...await this.readDirectory(path));
+			else if (entry.isFile() && /\.(?:[cm]?[jt]s)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) files.push(path);
+		}
+		return files;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/RouteRegistrar.mjs
+/**
+* @class clear-router RouteRegistrar
+* @description Fluent builder returned by `Router.domain()` that lets routes be
+* grouped under a shared host pattern (and optionally a prefix/middlewares),
+* mirroring Laravel's route attribute registrar.
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-hq/clear-router
+*/
+var RouteRegistrar = class {
+	attributes;
+	constructor(makeGroup, attributes = {}) {
+		this.makeGroup = makeGroup;
+		this.attributes = {
+			domain: attributes.domain,
+			prefix: attributes.prefix ?? "",
+			middlewares: attributes.middlewares ?? []
+		};
+	}
+	/**
+	* Constrain the grouped routes to a host pattern such as `{account}.example.com`.
+	*
+	* @param pattern
+	* @returns
+	*/
+	domain(pattern) {
+		this.attributes.domain = pattern;
+		return this;
+	}
+	/**
+	* Prepend a path prefix to the grouped routes.
+	*
+	* @param prefix
+	* @returns
+	*/
+	prefix(prefix) {
+		this.attributes.prefix = prefix;
+		return this;
+	}
+	/**
+	* Register one or more middleware shared by the grouped routes.
+	*
+	* @param middlewares
+	* @returns
+	*/
+	middleware(middlewares) {
+		this.attributes.middlewares = [...this.attributes.middlewares, ...Array.isArray(middlewares) ? middlewares : [middlewares]];
+		return this;
+	}
+	group(prefixOrSource, sourceOrMiddlewares, middlewares) {
+		let prefix = this.attributes.prefix;
+		let source;
+		let extraMiddlewares;
+		if (typeof prefixOrSource === "string") {
+			prefix = prefixOrSource;
+			source = sourceOrMiddlewares;
+			extraMiddlewares = middlewares;
+		} else {
+			source = prefixOrSource;
+			extraMiddlewares = sourceOrMiddlewares;
+		}
+		return this.makeGroup(prefix, source, [...this.attributes.middlewares, ...extraMiddlewares ?? []], { domain: this.attributes.domain });
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/core/Request.mjs
+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 ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/core/Response.mjs
+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 ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/core/bindings.mjs
+const metadataKey$1 = Symbol.for("clear-router:binding-metadata");
+const bindings = /* @__PURE__ */ new WeakMap();
+var InjectionToken = class {
+	key;
+	constructor(description) {
+		this.description = description;
+		this.key = Symbol(description);
+	}
+	toString() {
+		return `InjectionToken(${this.description})`;
+	}
+};
+var ContainerResolutionError = class extends Error {
+	constructor(message, path) {
+		super(`${message}\nResolution path: ${path.map(describeToken).join(" -> ")}`);
+		this.path = path;
+		this.name = "ContainerResolutionError";
+	}
+};
+var Container = class Container {
+	static activeScope = new AsyncLocalStorage();
+	static containers = /* @__PURE__ */ new Set();
+	static globalContainer = new Container();
+	registry = /* @__PURE__ */ new Map();
+	instances = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	constructor(parent, context, requestScope = false) {
+		this.parent = parent;
+		this.context = context;
+		this.requestScope = requestScope;
+	}
+	static get global() {
+		return this.globalContainer;
+	}
+	static current() {
+		return this.activeScope.getStore() ?? this.globalContainer;
+	}
+	static run(container, callback) {
+		return this.activeScope.run(container, callback);
+	}
+	static create(parent = this.globalContainer) {
+		const container = new Container(parent);
+		this.containers.add(container);
+		return container;
+	}
+	createRequestScope(ctx) {
+		return new Container(this, ctx, true);
+	}
+	static bind(token, value, options) {
+		this.globalContainer.bind(token, value, options);
+	}
+	static unbind(token) {
+		this.globalContainer.unbind(token);
+	}
+	static clear() {
+		this.globalContainer.clear();
+		for (const container of this.containers) container.clear();
+	}
+	static has(token) {
+		return this.current().has(token);
+	}
+	static bindings() {
+		return this.current().bindings();
+	}
+	static async resolve(token, ctx, autoDiscover = false) {
+		return this.current().resolve(token, ctx, autoDiscover);
+	}
+	bind(token, value, options) {
+		this.registry.set(token, normalizeProvider(value, options));
+		this.instances.delete(token);
+	}
+	unbind(token) {
+		this.registry.delete(token);
+		this.instances.delete(token);
+	}
+	clear() {
+		this.registry.clear();
+		this.instances.clear();
+		this.pending.clear();
+	}
+	has(token) {
+		return Boolean(this.findProvider(token));
+	}
+	entries() {
+		const entries = /* @__PURE__ */ new Map();
+		for (const container of this.lineage().reverse()) for (const [token, provider] of container.registry) entries.set(token, provider);
+		return entries;
+	}
+	bindings() {
+		return Object.fromEntries(Array.from(this.entries(), ([token, provider]) => [describeToken(token), provider]));
+	}
+	async resolve(token, ctx = this.context, autoDiscover = false) {
+		return this.resolveToken(token, ctx, {
+			autoDiscover,
+			stack: []
+		});
+	}
+	async resolveOrFail(token, ctx = this.context, autoDiscover = false) {
+		const resolved = await this.resolve(token, ctx, autoDiscover);
+		if (typeof resolved === "undefined") throw new ContainerResolutionError(`Cannot resolve ${describeToken(token)}`, [token]);
+		return resolved;
+	}
+	async resolveToken(token, ctx, state) {
+		if (token === Request) return ctx?.clearRequest;
+		if (token === Response) return ctx?.clearResponse;
+		if (state.stack.includes(token)) throw new ContainerResolutionError(`Circular dependency detected while resolving ${describeToken(token)}`, [...state.stack, token]);
+		const nextState = {
+			...state,
+			stack: [...state.stack, token]
+		};
+		const found = this.findProvider(token);
+		if (found) return this.resolveProvider(found.token, found.provider, found.owner, ctx, nextState);
+		if (state.autoDiscover && typeof token === "function") return this.instantiate(token, void 0, ctx, nextState);
+	}
+	findProvider(token) {
+		if (this.registry.has(token)) return {
+			token,
+			provider: this.registry.get(token),
+			owner: this
+		};
+		const equivalent = this.findEquivalentToken(token);
+		if (equivalent) return {
+			token: equivalent,
+			provider: this.registry.get(equivalent),
+			owner: this
+		};
+		return this.parent?.findProvider(token);
+	}
+	async resolveProvider(token, provider, owner, ctx, state) {
+		if ("useExisting" in provider) return this.resolveToken(provider.useExisting, ctx, state);
+		const cache = provider.scope === "singleton" ? owner : provider.scope === "request" ? this.findRequestScope() : void 0;
+		if (cache?.instances.has(token)) return cache.instances.get(token);
+		if (cache?.pending.has(token)) return cache.pending.get(token);
+		const create = async () => {
+			if ("useValue" in provider) return provider.useValue;
+			if ("useClass" in provider) return this.instantiate(provider.useClass, provider.dependencies, ctx, state);
+			return provider.useFactory(ctx);
+		};
+		if (!cache) return create();
+		const promise = create();
+		cache.pending.set(token, promise);
+		try {
+			const resolved = await promise;
+			if (typeof resolved !== "undefined") cache.instances.set(token, resolved);
+			return resolved;
+		} finally {
+			cache.pending.delete(token);
+		}
+	}
+	async instantiate(Type, dependencies, ctx, state) {
+		const tokens = dependencies ?? getInjectTokens(Type);
+		const args = [];
+		for (const dependency of tokens) {
+			const resolved = await this.resolveToken(dependency, ctx, state);
+			if (typeof resolved === "undefined") throw new ContainerResolutionError(`Cannot resolve ${describeToken(dependency)} required by ${describeToken(Type)}`, [...state.stack, dependency]);
+			args.push(resolved);
+		}
+		return new Type(...args);
+	}
+	findRequestScope() {
+		if (this.requestScope) return this;
+		return this.parent?.findRequestScope();
+	}
+	lineage() {
+		return [this, ...this.parent?.lineage() ?? []];
+	}
+	findEquivalentToken(token) {
+		if (typeof token !== "function") return void 0;
+		const name = token.name;
+		if (!name) return void 0;
+		const tokenParent = Object.getPrototypeOf(token);
+		const tokenProps = this.getComparableStaticProps(token);
+		for (const registered of this.registry.keys()) {
+			if (typeof registered !== "function" || registered === token || 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)) return registered;
+		}
+	}
+	getComparableStaticProps(token) {
+		return Object.getOwnPropertyNames(token).filter((prop) => {
+			return ![
+				"length",
+				"name",
+				"prototype",
+				"arguments",
+				"caller"
+			].includes(prop);
+		});
+	}
+	staticPropsMatch(token, registered, tokenProps, registeredProps) {
+		if (tokenProps.length !== registeredProps.length) return false;
+		for (const prop of tokenProps) if (!registeredProps.includes(prop) || Reflect.get(token, prop) !== Reflect.get(registered, prop)) return false;
+		return true;
+	}
+};
+function normalizeProvider(value, options) {
+	if (isProvider(value)) return {
+		scope: "transient",
+		...value
+	};
+	if (isClass(value)) return {
+		useClass: value,
+		scope: options?.scope ?? "transient"
+	};
+	if (typeof value === "function") return {
+		useFactory: value,
+		scope: options?.scope ?? "transient"
+	};
+	return { useValue: value };
+}
+function isProvider(value) {
+	return Boolean(value && typeof value === "object" && ("useValue" in value || "useClass" in value || "useFactory" in value || "useExisting" in value));
+}
+function getInjectTokens(Type) {
+	return Type.inject ?? getDesignParamTypes(Type);
+}
+function describeToken(token) {
+	if (token instanceof InjectionToken) return token.toString();
+	if (typeof token === "symbol") return token.description ?? token.toString();
+	return token.name || "<anonymous class>";
+}
+function getStandardMetadata$1(metadata, propertyKey) {
+	const store = metadata && metadata[metadataKey$1];
+	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$1(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 ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/decorators/middleware.mjs
+const CLASS_KEY = "__class__";
+const metadataKey = Symbol.for("clear-router:middleware-metadata");
+const store = /* @__PURE__ */ new WeakMap();
+/**
+* Collect the decorator-declared middleware for a controller route handler,
+* ordered class-level first then method-level. Returns an empty array for
+* non-controller (callback) handlers or handlers without any decorators.
+*
+* @param handler
+* @returns
+*/
+function getControllerMiddlewares(handler) {
+	if (!Array.isArray(handler) || handler.length !== 2) return [];
+	const [controller, method] = handler;
+	if (!controller) return [];
+	const constructor = typeof controller === "function" ? controller : controller.constructor;
+	const prototype = typeof controller === "function" ? controller.prototype : Object.getPrototypeOf(controller);
+	const standardMetadata = constructor?.[Symbol.metadata];
+	const classMiddlewares = getMiddlewareMetadata(constructor, CLASS_KEY) ?? getMiddlewareMetadata(prototype, CLASS_KEY) ?? getStandardMetadata(standardMetadata, CLASS_KEY) ?? [];
+	const methodMiddlewares = getMiddlewareMetadata(prototype, method) ?? getMiddlewareMetadata(constructor, method) ?? getStandardMetadata(standardMetadata, method) ?? [];
+	return [...classMiddlewares, ...methodMiddlewares];
+}
+function getMiddlewareMetadata(target, propertyKey) {
+	if (!target) return void 0;
+	return store.get(target)?.get(propertyKey);
+}
+function getStandardMetadata(metadata, propertyKey) {
+	const record = metadata && metadata[metadataKey];
+	return record ? record[propertyKey] : void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/ResourceRouteSelection.mjs
+var ResourceRouteSelection = class {
+	constructor(routes) {
+		this.routes = routes;
+	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	* 
+	* @param middlewares 
+	* @returns 
+	*/
+	middleware(middlewares) {
+		for (const route of this.routes) route.middleware(middlewares);
+		return this;
+	}
+	all() {
+		return this.routes;
+	}
+	first() {
+		return this.routes[0];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/ResourceRoutes.mjs
+/**
+* @class clear-router ResourceRoutes
+* @description A ResourceRoutes creates a collection of resourceful routes in a single call
+* @author 3m1n3nc3
+* @repository https://github.com/arkstack-hq/clear-router
+*/
+var ResourceRoutes = class ResourceRoutes {
+	static actions = {
+		index: {
+			method: "get",
+			path: "/"
+		},
+		show: {
+			method: "get",
+			path: "/:{param}"
+		},
+		create: {
+			method: "post",
+			path: "/"
+		},
+		update: {
+			method: "put",
+			path: "/:{param}"
+		},
+		destroy: {
+			method: "delete",
+			path: "/:{param}"
+		}
+	};
+	routes = {};
+	options;
+	chainedMiddlewares = [];
+	constructor(basePath, controller, paramName, options, registerRoute, removeRoute) {
+		this.basePath = basePath;
+		this.controller = controller;
+		this.paramName = paramName;
+		this.registerRoute = registerRoute;
+		this.removeRoute = removeRoute;
+		this.options = options ?? {};
+	}
+	register() {
+		this.clear();
+		const preController = typeof this.controller === "function" ? new this.controller() : this.controller;
+		for (const action of this.selectedActions()) {
+			if (typeof preController[action] !== "function") continue;
+			const definition = this.definitionFor(action);
+			const route = this.registerRoute({
+				action,
+				method: definition.method,
+				path: `${this.basePath}${definition.path}`,
+				handler: [this.controller, action],
+				middlewares: this.resolveActionMiddlewares(action),
+				name: `${this.nameFor(definition.path)}.${action.toLowerCase()}`
+			});
+			this.routes[action] = route;
+		}
+		for (const middlewares of this.chainedMiddlewares) this.middleware(middlewares, false);
+		return this;
+	}
+	/**
+	* Only register routes for the provided actions.
+	* 
+	* @param action 
+	* @param actions 
+	* @returns 
+	*/
+	only(action, ...actions) {
+		this.options.only = Array.from(new Set(wrap(action).concat(actions)));
+		return this.register();
+	}
+	/**
+	* Register all resource routes except the provided actions.
+	* 
+	* @param action 
+	* @param actions 
+	* @returns 
+	*/
+	except(action, ...actions) {
+		this.options.except = Array.from(new Set(wrap(action).concat(actions)));
+		return this.register();
+	}
+	/**
+	* Register one or more middleware that will be executed before the route.
+	* 
+	* @param middlewares 
+	* @param remember 
+	* @returns 
+	*/
+	middleware(middlewares, remember = true) {
+		if (remember) this.chainedMiddlewares.push(middlewares);
+		for (const route of Object.values(this.routes)) route?.middleware(middlewares);
+		return this;
+	}
+	action(action) {
+		return this.routes[action];
+	}
+	index() {
+		return this.routes.index;
+	}
+	show() {
+		return this.routes.show;
+	}
+	create() {
+		return this.routes.create;
+	}
+	update() {
+		return this.routes.update;
+	}
+	destroy() {
+		return this.routes.destroy;
+	}
+	get() {
+		return this.byMethod("get");
+	}
+	post() {
+		return this.byMethod("post");
+	}
+	put() {
+		return this.byMethod("put");
+	}
+	delete() {
+		return this.byMethod("delete");
+	}
+	selectedActions() {
+		const actions = this.options.only?.length ? this.options.only : Object.keys(ResourceRoutes.actions);
+		const except = new Set(this.options.except ?? []);
+		return actions.filter((action) => !except.has(action));
+	}
+	definitionFor(action) {
+		const definition = ResourceRoutes.actions[action];
+		return {
+			method: definition.method,
+			path: definition.path.replace("{param}", this.paramName)
+		};
+	}
+	resolveActionMiddlewares(action) {
+		const middlewares = this.isActionMiddlewareMap(this.options.middlewares) ? this.options.middlewares[action] : this.options.middlewares;
+		return Array.isArray(middlewares) ? middlewares : middlewares ? [middlewares] : void 0;
+	}
+	isActionMiddlewareMap(middlewares) {
+		if (!middlewares || Array.isArray(middlewares) || typeof middlewares !== "object") return false;
+		return Object.keys(ResourceRoutes.actions).some((action) => action in middlewares);
+	}
+	nameFor(path) {
+		return `${this.basePath}${path}`.replace(/\/:[^/]+|\/\{[^}]+\}/g, "").replace(/\{(\w+):[^}]+\}/g, "$1").replace(/\/|:|[{}]/g, ".").replace(/\.{2,}/g, ".").replace(/^\.|\.$/g, "");
+	}
+	byMethod(method) {
+		return new ResourceRouteSelection(Object.values(this.routes).filter((route) => Boolean(route?.methods.includes(method))));
+	}
+	clear() {
+		for (const route of Object.values(this.routes)) if (route) this.removeRoute(route);
+		for (const key of Object.keys(this.routes)) delete this.routes[key];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/clear-router@2.9.3_@h3ravel+support@2.2.7_@types+node@25.6.2_h3@2.0.1-rc.22__express@5._15be2e62531296a83319dbccad2fa4ea/node_modules/clear-router/dist/core/CoreRouter.mjs
+/**
+* @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-hq/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 requestProvider;
+	static responseProvider;
+	static domainMatcherCache = /* @__PURE__ */ new Map();
+	static constraintRegexCache = /* @__PURE__ */ new Map();
+	static routePatterns = /* @__PURE__ */ new Map();
+	static config = {
+		inferParamName: false,
+		methodOverride: {
+			enabled: true,
+			bodyKeys: ["_method"],
+			headerKeys: ["x-http-method"]
+		},
+		container: {
+			enabled: false,
+			autoDiscover: false,
+			strict: false
+		}
+	};
+	static groupContext = new AsyncLocalStorage();
+	static pluginRequestContext = new 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 = [];
+	/**
+	* Resolve middlewares before assigning to adapter
+	* 
+	* @param middleware 
+	* @returns 
+	*/
+	static resolveMiddleware(middleware) {
+		if (!middleware || typeof middleware === "function" && !isClass(middleware)) return middleware;
+		const instance = isClass(middleware) ? new middleware() : middleware;
+		if (instance && typeof instance.handle === "function") return instance.handle.bind(instance);
+		return middleware;
+	}
+	static resolveMiddlewares(middlewares = []) {
+		return middlewares.map((middleware) => this.resolveMiddleware(middleware));
+	}
+	static routeSpecificity(route) {
+		const path = route.registrationPaths.slice().sort((left, right) => right.length - left.length)[0] ?? route.path;
+		const segments = this.normalizePath(path).split("/").filter(Boolean);
+		return [
+			segments.filter((segment) => !segment.startsWith(":")).length,
+			segments.length,
+			path.length
+		];
+	}
+	static orderedRoutes() {
+		return Array.from(this.routes).sort((left, right) => {
+			const leftScore = this.routeSpecificity(left);
+			const rightScore = this.routeSpecificity(right);
+			for (let index = 0; index < leftScore.length; index++) {
+				const difference = rightScore[index] - leftScore[index];
+				if (difference !== 0) return difference;
+			}
+			return 0;
+		});
+	}
+	static removeRouteMethod(route, method, path) {
+		route.methods = route.methods.filter((existingMethod) => existingMethod !== method);
+		this.routesByPathMethod.delete(`${method.toUpperCase()} ${path}`);
+		const methodKey = method.toUpperCase();
+		this.routesByMethod.set(methodKey, (this.routesByMethod.get(methodKey) ?? []).filter((existingRoute) => existingRoute !== route));
+		if (!route.methods.some((existingMethod) => existingMethod !== "options")) {
+			this.routes.delete(route);
+			if (route.routeName && this.routesByName.get(route.routeName) === route) this.routesByName.delete(route.routeName);
+		}
+	}
+	static removeRoute(route) {
+		this.routes.delete(route);
+		if (route.routeName && this.routesByName.get(route.routeName) === route) this.routesByName.delete(route.routeName);
+		for (const method of route.methods) {
+			const methodKey = method.toUpperCase();
+			this.routesByPathMethod.delete(`${methodKey} ${route.path}`);
+			this.routesByMethod.set(methodKey, (this.routesByMethod.get(methodKey) ?? []).filter((existingRoute) => existingRoute !== route));
+		}
+	}
+	/**
+	* 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();
+		this.routePatterns.clear();
+		return this;
+	}
+	static createBaseConfig() {
+		return {
+			inferParamName: false,
+			methodOverride: {
+				enabled: true,
+				bodyKeys: ["_method"],
+				headerKeys: ["x-http-method"]
+			},
+			container: {
+				enabled: false,
+				autoDiscover: false,
+				strict: 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() {
+		this.bindStateAccessors();
+		return this.pluginStore;
+	}
+	static getPluginPendingStore() {
+		this.bindStateAccessors();
+		return this.pluginPending;
+	}
+	static getPluginArgumentResolvers() {
+		this.bindStateAccessors();
+		return this.pluginArgumentResolvers;
+	}
+	static getPluginHttpCtxResolvers() {
+		this.bindStateAccessors();
+		return this.pluginHttpCtxResolvers;
+	}
+	static createDefaultState() {
+		return {
+			config: this.getDefaultConfig(),
+			groupContext: new AsyncLocalStorage(),
+			routes: /* @__PURE__ */ new Set([]),
+			routesByPathMethod: /* @__PURE__ */ new Map(),
+			routesByMethod: /* @__PURE__ */ new Map(),
+			routesByName: /* @__PURE__ */ new Map(),
+			prefix: "",
+			groupMiddlewares: [],
+			globalMiddlewares: [],
+			container: Container.create(),
+			pluginStore: /* @__PURE__ */ new Set(),
+			pluginPending: /* @__PURE__ */ new Set(),
+			pluginArgumentResolvers: /* @__PURE__ */ new Set(),
+			pluginHttpCtxResolvers: /* @__PURE__ */ new Set()
+		};
+	}
+	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",
+			"container",
+			"pluginStore",
+			"pluginPending",
+			"pluginArgumentResolvers",
+			"pluginHttpCtxResolvers"
+		]) 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) {
+		this.ensureState();
+		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: this.container,
+				bind: this.createPluginBind(),
+				resolveArguments: (resolver) => {
+					this.getPluginArgumentResolvers().add(resolver);
+				},
+				useHttpContext: (resolver) => {
+					this.getPluginHttpCtxResolvers().add(resolver);
+				},
+				bindings: this.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.current().bindings()
+		};
+	}
+	static createPluginBind() {
+		const bind = (token, value, options) => {
+			if (value && typeof value === "object" && "useFactory" in value) {
+				const factory = value.useFactory;
+				this.container.bind(token, {
+					...value,
+					useFactory: (ctx) => factory(this.createPluginRequestContext(ctx))
+				});
+				return;
+			}
+			if (typeof value === "function" && !isClass(value)) {
+				const factory = value;
+				this.container.bind(token, (ctx) => factory(this.createPluginRequestContext(ctx)), options);
+				return;
+			}
+			this.container.bind(token, value, options);
+		};
+		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 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);
+	}
+	/**
+	* Compile a host pattern such as `{account}.example.com` into a matcher and
+	* the ordered list of placeholder names it captures. Results are memoized.
+	*
+	* @param pattern
+	* @returns
+	*/
+	static compileDomain(pattern) {
+		const cached = this.domainMatcherCache.get(pattern);
+		if (cached) return cached;
+		const cleanPattern = pattern.split(":", 1)[0].trim();
+		const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, (match) => `\\${match}`);
+		const placeholder = /\{([^{}]+)\}/g;
+		const params = [];
+		let source = "^";
+		let lastIndex = 0;
+		let match;
+		while ((match = placeholder.exec(cleanPattern)) !== null) {
+			source += escape(cleanPattern.slice(lastIndex, match.index));
+			const raw = match[1].trim();
+			const optional = raw.endsWith("?");
+			const name = (optional ? raw.slice(0, -1) : raw).split(":", 1)[0].trim();
+			params.push(name);
+			source += optional ? "([^.]*)" : "([^.]+)";
+			lastIndex = match.index + match[0].length;
+		}
+		source += escape(cleanPattern.slice(lastIndex));
+		source += "$";
+		const compiled = {
+			regex: new RegExp(source, "i"),
+			params
+		};
+		this.domainMatcherCache.set(pattern, compiled);
+		return compiled;
+	}
+	/**
+	* Match a host against a domain pattern, returning the captured parameters or
+	* `null` when the host does not match.
+	*
+	* @param pattern
+	* @param host
+	* @returns
+	*/
+	static matchDomain(pattern, host) {
+		if (!pattern) return null;
+		const cleanHost = String(host ?? "").split(":", 1)[0].trim().toLowerCase();
+		const { regex, params } = this.compileDomain(pattern);
+		const match = regex.exec(cleanHost);
+		if (!match) return null;
+		const result = {};
+		params.forEach((name, index) => {
+			const value = match[index + 1];
+			if (typeof value !== "undefined") result[name] = decodeURIComponent(value);
+		});
+		return result;
+	}
+	/**
+	* Best-effort extraction of the request host across every supported adapter
+	* context shape (Express/Fastify plain headers, H3 `Headers`, Hono accessor,
+	* Koa context).
+	*
+	* @param ctx
+	* @returns
+	*/
+	static extractHost(ctx) {
+		const headers = ctx?.req?.headers ?? ctx?.headers;
+		let host;
+		if (headers) host = typeof headers.get === "function" ? headers.get("host") ?? headers.get(":authority") : headers.host ?? headers[":authority"];
+		if (!host && typeof ctx?.req?.header === "function") host = ctx.req.header("host");
+		if (!host && typeof ctx?.host === "string") host = ctx.host;
+		if (Array.isArray(host)) host = host[0];
+		return String(host ?? "").split(",", 1)[0].trim();
+	}
+	/**
+	* Resolve the domain parameters for a route given the active request context.
+	* Returns `null` when the route is not domain-constrained, `false` when it is
+	* but the host does not match, or the captured parameters on a match.
+	*
+	* @param route
+	* @param ctx
+	* @returns
+	*/
+	static matchRouteDomain(route, ctx) {
+		if (!route.domainPattern) return null;
+		return this.matchDomain(route.domainPattern, this.extractHost(ctx)) ?? false;
+	}
+	/**
+	* Register a global pattern applied to every route parameter sharing the
+	* given name (equivalent to Laravel's `Route::pattern`).
+	*
+	* @param name
+	* @param pattern
+	*/
+	static pattern(name, pattern) {
+		this.ensureState();
+		this.routePatterns.set(name, pattern);
+	}
+	/**
+	* Register multiple global parameter patterns at once.
+	*
+	* @param patterns
+	*/
+	static patterns(patterns) {
+		for (const [name, pattern] of Object.entries(patterns)) this.pattern(name, pattern);
+	}
+	/**
+	* Merge the global parameter patterns with the route's own constraints. Route
+	* level constraints take precedence over global patterns.
+	*
+	* @param route
+	* @returns
+	*/
+	static resolveConstraints(route) {
+		if (!this.routePatterns.size && !Object.keys(route.constraints).length) return route.constraints;
+		return {
+			...Object.fromEntries(this.routePatterns),
+			...route.constraints
+		};
+	}
+	/**
+	* Compile a constraint pattern into a fully-anchored regular expression.
+	*
+	* @param pattern
+	* @returns
+	*/
+	static toConstraintRegex(pattern) {
+		if (pattern instanceof RegExp) return new RegExp(`^(?:${pattern.source})$`, pattern.flags.replace("g", ""));
+		const cached = this.constraintRegexCache.get(pattern);
+		if (cached) return cached;
+		const regex = new RegExp(`^(?:${pattern})$`);
+		this.constraintRegexCache.set(pattern, regex);
+		return regex;
+	}
+	/**
+	* Determine whether the resolved parameters satisfy the route's constraints.
+	* Absent parameters (e.g. optional ones) are ignored.
+	*
+	* @param route
+	* @param params
+	* @returns
+	*/
+	static satisfiesConstraints(route, params) {
+		const constraints = this.resolveConstraints(route);
+		for (const name of Object.keys(constraints)) {
+			const value = params[name];
+			if (typeof value === "undefined" || value === null) continue;
+			const values = Array.isArray(value) ? value : [value];
+			const regex = this.toConstraintRegex(constraints[name]);
+			if (!values.every((entry) => regex.test(String(entry)))) return false;
+		}
+		return true;
+	}
+	/**
+	* Determine which of a route's parameters are allowed to span multiple path
+	* segments (i.e. their constraint matches an encoded forward slash). These are
+	* registered with the adapter's catch-all syntax.
+	*
+	* @param route
+	* @returns
+	*/
+	static wildcardParameters(route) {
+		const wildcards = /* @__PURE__ */ new Set();
+		const constraints = this.resolveConstraints(route);
+		const declared = new Set(route.parameters.map((parameter) => parameter.name));
+		for (const name of Object.keys(constraints)) {
+			if (!declared.has(name)) continue;
+			if (this.toConstraintRegex(constraints[name]).test("a/b")) wildcards.add(name);
+		}
+		return wildcards;
+	}
+	/**
+	* Render a single wildcard (slash-spanning) parameter for the underlying
+	* router's registration path. Overridden per adapter; the base form keeps the
+	* plain `:name` placeholder.
+	*
+	* @param name
+	* @returns
+	*/
+	static formatWildcardParam(name) {
+		return `:${name}`;
+	}
+	/**
+	* Rewrite a route's registration paths so any wildcard parameters use the
+	* adapter's catch-all syntax. Non-wildcard routes are returned unchanged.
+	*
+	* @param route
+	* @returns
+	*/
+	static resolveRegistrationPaths(route) {
+		const wildcards = this.wildcardParameters(route);
+		if (!wildcards.size) return route.registrationPaths;
+		return route.registrationPaths.map((path) => path.split("/").map((segment) => {
+			const name = segment.startsWith(":") ? segment.slice(1) : "";
+			return name && wildcards.has(name) ? this.formatWildcardParam(name) : segment;
+		}).join("/"));
+	}
+	/**
+	* Resolve the final parameters for a dispatched route, applying domain
+	* matching and constraint validation. Returns the merged parameters, or
+	* `false` when the route should not handle the request (host mismatch or a
+	* constraint failure) so the adapter can fall through.
+	*
+	* @param route
+	* @param ctx
+	* @param baseParams
+	* @returns
+	*/
+	static matchRoute(route, ctx, baseParams = {}) {
+		const params = { ...baseParams ?? {} };
+		if (route.domainPattern) {
+			const domainParams = this.matchDomain(route.domainPattern, this.extractHost(ctx));
+			if (!domainParams) return false;
+			Object.assign(params, domainParams);
+		}
+		this.normalizeWildcardParams(route, params);
+		if (!this.satisfiesConstraints(route, params)) return false;
+		return params;
+	}
+	/**
+	* Normalize wildcard (slash-spanning) parameters into a single string keyed by
+	* the declared parameter name, smoothing over the differing shapes adapters
+	* return (Express yields an array of segments, Fastify keys it under `*`).
+	*
+	* @param route
+	* @param params
+	*/
+	static normalizeWildcardParams(route, params) {
+		const wildcards = this.wildcardParameters(route);
+		if (!wildcards.size) return;
+		for (const name of wildcards) {
+			let value = params[name];
+			if (typeof value === "undefined" && typeof params["*"] !== "undefined") {
+				value = params["*"];
+				delete params["*"];
+			}
+			if (Array.isArray(value)) value = value.join("/");
+			if (typeof value !== "undefined") params[name] = value;
+		}
+	}
+	/**
+	* Get the route currently being dispatched, if any.
+	*
+	* @returns
+	*/
+	static current() {
+		const store = this.pluginRequestContext.getStore();
+		return store?.request?.route ?? store?.ctx?.clearRequest?.route;
+	}
+	/**
+	* Get the name of the route currently being dispatched.
+	*
+	* @returns
+	*/
+	static currentRouteName() {
+		return this.current()?.routeName ?? "";
+	}
+	/**
+	* Get the action (`Controller@method` or `Closure`) of the route currently
+	* being dispatched.
+	*
+	* @returns
+	*/
+	static currentRouteAction() {
+		return this.current()?.action ?? "";
+	}
+	/**
+	* 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;
+		const activeDomain = context?.domain;
+		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);
+		for (const method of methods) {
+			const existing = this.routesByPathMethod.get(`${method.toUpperCase()} ${fullPath}`);
+			if (existing) this.removeRouteMethod(existing, method, fullPath);
+		}
+		const route = new Route(methods.includes("options") ? methods : methods.concat("options"), fullPath, handler, this.resolveMiddlewares([
+			...this.globalMiddlewares,
+			...activeGroupMiddlewares,
+			...getControllerMiddlewares(handler),
+			...middlewares || []
+		]), {
+			registrationPaths,
+			parameters,
+			domain: activeDomain,
+			onName: (name, route, previousName) => {
+				if (previousName && this.routesByName.get(previousName) === route) this.routesByName.delete(previousName);
+				this.routesByName.set(name, route);
+			},
+			normalizeMiddleware: (middleware) => this.resolveMiddleware(middleware)
+		});
+		if (!methods.includes("options") && !this.routesByPathMethod.get(`OPTIONS ${fullPath}`)) this.options(path, this.createDefaultOptionsHandler());
+		this.routes.add(route);
+		for (const collector of context?.routeCollectors ?? []) collector.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 } = createRequire(import.meta.url)("@h3ravel/support");
+			paramName = str(basePath).singular().afterLast("/").camel().toString();
+		}
+		return new ResourceRoutes(basePath, controller, paramName, options, ({ method, path, handler, middlewares, name }) => {
+			return this.add(method, path, handler, middlewares).name(name);
+		}, (route) => this.removeRoute(route)).register();
+	}
+	/**
+	* 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 group(prefix, source, middlewares) {
+		return this.makeGroup(prefix, source, middlewares);
+	}
+	/**
+	* Build a route group, optionally constrained to a host pattern. Shared by
+	* `group` and the `domain` registrar.
+	*
+	* @param prefix
+	* @param source
+	* @param middlewares
+	* @param extra
+	*/
+	static makeGroup(prefix, source, middlewares, extra) {
+		this.ensureState();
+		return new RouteGroup({
+			prefix,
+			source,
+			middlewares,
+			domain: extra?.domain,
+			context: this.groupContext,
+			defaultPrefix: this.prefix,
+			defaultMiddlewares: this.groupMiddlewares,
+			normalizePath: (path) => this.normalizePath(path),
+			removeRoute: (route) => this.removeRoute(route)
+		});
+	}
+	/**
+	* Begin a route registration constrained to a host pattern such as
+	* `{account}.example.com`. Returns a registrar whose `.group()` registers the
+	* routes under that domain (matched parameters become route parameters).
+	*
+	* @param pattern
+	* @returns
+	*/
+	static domain(pattern) {
+		this.ensureState();
+		return new RouteRegistrar((prefix, source, middlewares, extra) => this.makeGroup(prefix, source, middlewares, extra), { domain: pattern });
+	}
+	/**
+	* 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 {
+			createRequire(import.meta.url).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) {
+		this.ensureState();
+		const requestContainer = this.container.createRequestScope(ctx);
+		return Container.run(requestContainer, () => 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$1(bindingMetadata, bindingMethod) ?? getStandardMetadata$1(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 = this.config.container?.strict ? await requestContainer.resolveOrFail(token, ctx, Boolean(this.config.container?.autoDiscover)) : await requestContainer.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;
+		if (!(ctx.clearResponse instanceof Response)) ctx.clearResponse = this.initializeInstance(Response, ctx.response ?? ctx.reply ?? ctx.res);
+		if (!instance) return;
+		instance.ctx = ctx;
+		instance.body = payload.body;
+		instance.query = payload.query;
+		instance.params = payload.params;
+		instance.clearRequest = clearRequest;
+	}
+};
+/**
+* Expose the active request's route through the `Route` facade (`Route.current()`,
+* `Route.currentRouteName()`, `Route.currentRouteAction()`) by delegating to the
+* shared router request context.
+*/
+Route.bindCurrentResolvers({
+	current: () => CoreRouter.current(),
+	currentRouteName: () => CoreRouter.currentRouteName(),
+	currentRouteAction: () => CoreRouter.currentRouteAction()
+});
+//#endregion
+//#region ../../node_modules/.pnpm/dayjs@1.11.20/node_modules/dayjs/plugin/customParseFormat.js
+var require_customParseFormat = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(e, t) {
+		"object" == typeof exports && "undefined" != typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_customParseFormat = t();
+	})(exports, (function() {
+		"use strict";
+		var e = {
+			LTS: "h:mm:ss A",
+			LT: "h:mm A",
+			L: "MM/DD/YYYY",
+			LL: "MMMM D, YYYY",
+			LLL: "MMMM D, YYYY h:mm A",
+			LLLL: "dddd, MMMM D, YYYY h:mm A"
+		}, t = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|Q|YYYY|YY?|ww?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d/, r = /\d\d/, i = /\d\d?/, o = /\d*[^-_:/,()\s\d]+/, s = {}, a = function(e) {
+			return (e = +e) + (e > 68 ? 1900 : 2e3);
+		};
+		var f = function(e) {
+			return function(t) {
+				this[e] = +t;
+			};
+		}, h = [/[+-]\d\d:?(\d\d)?|Z/, function(e) {
+			(this.zone || (this.zone = {})).offset = function(e) {
+				if (!e) return 0;
+				if ("Z" === e) return 0;
+				var t = e.match(/([+-]|\d\d)/g), n = 60 * t[1] + (+t[2] || 0);
+				return 0 === n ? 0 : "+" === t[0] ? -n : n;
+			}(e);
+		}], u = function(e) {
+			var t = s[e];
+			return t && (t.indexOf ? t : t.s.concat(t.f));
+		}, d = function(e, t) {
+			var n, r = s.meridiem;
+			if (r) {
+				for (var i = 1; i <= 24; i += 1) if (e.indexOf(r(i, 0, t)) > -1) {
+					n = i > 12;
+					break;
+				}
+			} else n = e === (t ? "pm" : "PM");
+			return n;
+		}, c = {
+			A: [o, function(e) {
+				this.afternoon = d(e, !1);
+			}],
+			a: [o, function(e) {
+				this.afternoon = d(e, !0);
+			}],
+			Q: [n, function(e) {
+				this.month = 3 * (e - 1) + 1;
+			}],
+			S: [n, function(e) {
+				this.milliseconds = 100 * +e;
+			}],
+			SS: [r, function(e) {
+				this.milliseconds = 10 * +e;
+			}],
+			SSS: [/\d{3}/, function(e) {
+				this.milliseconds = +e;
+			}],
+			s: [i, f("seconds")],
+			ss: [i, f("seconds")],
+			m: [i, f("minutes")],
+			mm: [i, f("minutes")],
+			H: [i, f("hours")],
+			h: [i, f("hours")],
+			HH: [i, f("hours")],
+			hh: [i, f("hours")],
+			D: [i, f("day")],
+			DD: [r, f("day")],
+			Do: [o, function(e) {
+				var t = s.ordinal, n = e.match(/\d+/);
+				if (this.day = n[0], t) for (var r = 1; r <= 31; r += 1) t(r).replace(/\[|\]/g, "") === e && (this.day = r);
+			}],
+			w: [i, f("week")],
+			ww: [r, f("week")],
+			M: [i, f("month")],
+			MM: [r, f("month")],
+			MMM: [o, function(e) {
+				var t = u("months"), n = (u("monthsShort") || t.map((function(e) {
+					return e.slice(0, 3);
+				}))).indexOf(e) + 1;
+				if (n < 1) throw new Error();
+				this.month = n % 12 || n;
+			}],
+			MMMM: [o, function(e) {
+				var t = u("months").indexOf(e) + 1;
+				if (t < 1) throw new Error();
+				this.month = t % 12 || t;
+			}],
+			Y: [/[+-]?\d+/, f("year")],
+			YY: [r, function(e) {
+				this.year = a(e);
+			}],
+			YYYY: [/\d{4}/, f("year")],
+			Z: h,
+			ZZ: h
+		};
+		function l(n) {
+			var r = n, i = s && s.formats;
+			for (var o = (n = r.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, (function(t, n, r) {
+				var o = r && r.toUpperCase();
+				return n || i[r] || e[r] || i[o].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, (function(e, t, n) {
+					return t || n.slice(1);
+				}));
+			}))).match(t), a = o.length, f = 0; f < a; f += 1) {
+				var h = o[f], u = c[h], d = u && u[0], l = u && u[1];
+				o[f] = l ? {
+					regex: d,
+					parser: l
+				} : h.replace(/^\[|\]$/g, "");
+			}
+			return function(e) {
+				for (var t = {}, n = 0, r = 0; n < a; n += 1) {
+					var i = o[n];
+					if ("string" == typeof i) r += i.length;
+					else {
+						var s = i.regex, f = i.parser, h = e.slice(r), u = s.exec(h)[0];
+						f.call(t, u), e = e.replace(u, "");
+					}
+				}
+				return function(e) {
+					var t = e.afternoon;
+					if (void 0 !== t) {
+						var n = e.hours;
+						t ? n < 12 && (e.hours += 12) : 12 === n && (e.hours = 0), delete e.afternoon;
+					}
+				}(t), t;
+			};
+		}
+		return function(e, t, n) {
+			n.p.customParseFormat = !0, e && e.parseTwoDigitYear && (a = e.parseTwoDigitYear);
+			var r = t.prototype, i = r.parse;
+			r.parse = function(e) {
+				var t = e.date, r = e.utc, o = e.args;
+				this.$u = r;
+				var a = o[1];
+				if ("string" == typeof a) {
+					var f = !0 === o[2], h = !0 === o[3], u = f || h, d = o[2];
+					h && (d = o[2]), s = this.$locale(), !f && d && (s = n.Ls[d]), this.$d = function(e, t, n, r) {
+						try {
+							if (["x", "X"].indexOf(t) > -1) return /* @__PURE__ */ new Date(("X" === t ? 1e3 : 1) * e);
+							var i = l(t)(e), o = i.year, s = i.month, a = i.day, f = i.hours, h = i.minutes, u = i.seconds, d = i.milliseconds, c = i.zone, m = i.week, M = /* @__PURE__ */ new Date(), Y = a || (o || s ? 1 : M.getDate()), p = o || M.getFullYear(), v = 0;
+							o && !s || (v = s > 0 ? s - 1 : M.getMonth());
+							var D, w = f || 0, g = h || 0, y = u || 0, L = d || 0;
+							return c ? new Date(Date.UTC(p, v, Y, w, g, y, L + 60 * c.offset * 1e3)) : n ? new Date(Date.UTC(p, v, Y, w, g, y, L)) : (D = new Date(p, v, Y, w, g, y, L), m && (D = r(D).week(m).toDate()), D);
+						} catch (e) {
+							return /* @__PURE__ */ new Date("");
+						}
+					}(t, a, r, n), this.init(), d && !0 !== d && (this.$L = this.locale(d).$L), u && t != this.format(a) && (this.$d = /* @__PURE__ */ new Date("")), s = {};
+				} else if (a instanceof Array) for (var c = a.length, m = 1; m <= c; m += 1) {
+					o[1] = a[m - 1];
+					var M = n.apply(this, o);
+					if (M.isValid()) {
+						this.$d = M.$d, this.$L = M.$L, this.init();
+						break;
+					}
+					m === c && (this.$d = /* @__PURE__ */ new Date(""));
+				}
+				else i.call(this, e);
+			};
+		};
+	}));
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/dayjs@1.11.20/node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(t, e) {
+		"object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+	})(exports, (function() {
+		"use strict";
+		var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = {
+			name: "en",
+			weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+			months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+			ordinal: function(t) {
+				var e = [
+					"th",
+					"st",
+					"nd",
+					"rd"
+				], n = t % 100;
+				return "[" + t + (e[(n - 20) % 10] || e[n] || e[0]) + "]";
+			}
+		}, m = function(t, e, n) {
+			var r = String(t);
+			return !r || r.length >= e ? t : "" + Array(e + 1 - r.length).join(n) + t;
+		}, v = {
+			s: m,
+			z: function(t) {
+				var e = -t.utcOffset(), n = Math.abs(e), r = Math.floor(n / 60), i = n % 60;
+				return (e <= 0 ? "+" : "-") + m(r, 2, "0") + ":" + m(i, 2, "0");
+			},
+			m: function t(e, n) {
+				if (e.date() < n.date()) return -t(n, e);
+				var r = 12 * (n.year() - e.year()) + (n.month() - e.month()), i = e.clone().add(r, c), s = n - i < 0, u = e.clone().add(r + (s ? -1 : 1), c);
+				return +(-(r + (n - i) / (s ? i - u : u - i)) || 0);
+			},
+			a: function(t) {
+				return t < 0 ? Math.ceil(t) || 0 : Math.floor(t);
+			},
+			p: function(t) {
+				return {
+					M: c,
+					y: h,
+					w: o,
+					d: a,
+					D: d,
+					h: u,
+					m: s,
+					s: i,
+					ms: r,
+					Q: f
+				}[t] || String(t || "").toLowerCase().replace(/s$/, "");
+			},
+			u: function(t) {
+				return void 0 === t;
+			}
+		}, g = "en", D = {};
+		D[g] = M;
+		var p = "$isDayjsObject", S = function(t) {
+			return t instanceof _ || !(!t || !t[p]);
+		}, w = function t(e, n, r) {
+			var i;
+			if (!e) return g;
+			if ("string" == typeof e) {
+				var s = e.toLowerCase();
+				D[s] && (i = s), n && (D[s] = n, i = s);
+				var u = e.split("-");
+				if (!i && u.length > 1) return t(u[0]);
+			} else {
+				var a = e.name;
+				D[a] = e, i = a;
+			}
+			return !r && i && (g = i), i || !r && g;
+		}, O = function(t, e) {
+			if (S(t)) return t.clone();
+			var n = "object" == typeof e ? e : {};
+			return n.date = t, n.args = arguments, new _(n);
+		}, b = v;
+		b.l = w, b.i = S, b.w = function(t, e) {
+			return O(t, {
+				locale: e.$L,
+				utc: e.$u,
+				x: e.$x,
+				$offset: e.$offset
+			});
+		};
+		var _ = function() {
+			function M(t) {
+				this.$L = w(t.locale, null, !0), this.parse(t), this.$x = this.$x || t.x || {}, this[p] = !0;
+			}
+			var m = M.prototype;
+			return m.parse = function(t) {
+				this.$d = function(t) {
+					var e = t.date, n = t.utc;
+					if (null === e) return /* @__PURE__ */ new Date(NaN);
+					if (b.u(e)) return /* @__PURE__ */ new Date();
+					if (e instanceof Date) return new Date(e);
+					if ("string" == typeof e && !/Z$/i.test(e)) {
+						var r = e.match($);
+						if (r) {
+							var i = r[2] - 1 || 0, s = (r[7] || "0").substring(0, 3);
+							return n ? new Date(Date.UTC(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s)) : new Date(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s);
+						}
+					}
+					return new Date(e);
+				}(t), this.init();
+			}, m.init = function() {
+				var t = this.$d;
+				this.$y = t.getFullYear(), this.$M = t.getMonth(), this.$D = t.getDate(), this.$W = t.getDay(), this.$H = t.getHours(), this.$m = t.getMinutes(), this.$s = t.getSeconds(), this.$ms = t.getMilliseconds();
+			}, m.$utils = function() {
+				return b;
+			}, m.isValid = function() {
+				return !(this.$d.toString() === l);
+			}, m.isSame = function(t, e) {
+				var n = O(t);
+				return this.startOf(e) <= n && n <= this.endOf(e);
+			}, m.isAfter = function(t, e) {
+				return O(t) < this.startOf(e);
+			}, m.isBefore = function(t, e) {
+				return this.endOf(e) < O(t);
+			}, m.$g = function(t, e, n) {
+				return b.u(t) ? this[e] : this.set(n, t);
+			}, m.unix = function() {
+				return Math.floor(this.valueOf() / 1e3);
+			}, m.valueOf = function() {
+				return this.$d.getTime();
+			}, m.startOf = function(t, e) {
+				var n = this, r = !!b.u(e) || e, f = b.p(t), l = function(t, e) {
+					var i = b.w(n.$u ? Date.UTC(n.$y, e, t) : new Date(n.$y, e, t), n);
+					return r ? i : i.endOf(a);
+				}, $ = function(t, e) {
+					return b.w(n.toDate()[t].apply(n.toDate("s"), (r ? [
+						0,
+						0,
+						0,
+						0
+					] : [
+						23,
+						59,
+						59,
+						999
+					]).slice(e)), n);
+				}, y = this.$W, M = this.$M, m = this.$D, v = "set" + (this.$u ? "UTC" : "");
+				switch (f) {
+					case h: return r ? l(1, 0) : l(31, 11);
+					case c: return r ? l(1, M) : l(0, M + 1);
+					case o:
+						var g = this.$locale().weekStart || 0, D = (y < g ? y + 7 : y) - g;
+						return l(r ? m - D : m + (6 - D), M);
+					case a:
+					case d: return $(v + "Hours", 0);
+					case u: return $(v + "Minutes", 1);
+					case s: return $(v + "Seconds", 2);
+					case i: return $(v + "Milliseconds", 3);
+					default: return this.clone();
+				}
+			}, m.endOf = function(t) {
+				return this.startOf(t, !1);
+			}, m.$set = function(t, e) {
+				var n, o = b.p(t), f = "set" + (this.$u ? "UTC" : ""), l = (n = {}, n[a] = f + "Date", n[d] = f + "Date", n[c] = f + "Month", n[h] = f + "FullYear", n[u] = f + "Hours", n[s] = f + "Minutes", n[i] = f + "Seconds", n[r] = f + "Milliseconds", n)[o], $ = o === a ? this.$D + (e - this.$W) : e;
+				if (o === c || o === h) {
+					var y = this.clone().set(d, 1);
+					y.$d[l]($), y.init(), this.$d = y.set(d, Math.min(this.$D, y.daysInMonth())).$d;
+				} else l && this.$d[l]($);
+				return this.init(), this;
+			}, m.set = function(t, e) {
+				return this.clone().$set(t, e);
+			}, m.get = function(t) {
+				return this[b.p(t)]();
+			}, m.add = function(r, f) {
+				var d, l = this;
+				r = Number(r);
+				var $ = b.p(f), y = function(t) {
+					var e = O(l);
+					return b.w(e.date(e.date() + Math.round(t * r)), l);
+				};
+				if ($ === c) return this.set(c, this.$M + r);
+				if ($ === h) return this.set(h, this.$y + r);
+				if ($ === a) return y(1);
+				if ($ === o) return y(7);
+				var M = (d = {}, d[s] = e, d[u] = n, d[i] = t, d)[$] || 1, m = this.$d.getTime() + r * M;
+				return b.w(m, this);
+			}, m.subtract = function(t, e) {
+				return this.add(-1 * t, e);
+			}, m.format = function(t) {
+				var e = this, n = this.$locale();
+				if (!this.isValid()) return n.invalidDate || l;
+				var r = t || "YYYY-MM-DDTHH:mm:ssZ", i = b.z(this), s = this.$H, u = this.$m, a = this.$M, o = n.weekdays, c = n.months, f = n.meridiem, h = function(t, n, i, s) {
+					return t && (t[n] || t(e, r)) || i[n].slice(0, s);
+				}, d = function(t) {
+					return b.s(s % 12 || 12, t, "0");
+				}, $ = f || function(t, e, n) {
+					var r = t < 12 ? "AM" : "PM";
+					return n ? r.toLowerCase() : r;
+				};
+				return r.replace(y, (function(t, r) {
+					return r || function(t) {
+						switch (t) {
+							case "YY": return String(e.$y).slice(-2);
+							case "YYYY": return b.s(e.$y, 4, "0");
+							case "M": return a + 1;
+							case "MM": return b.s(a + 1, 2, "0");
+							case "MMM": return h(n.monthsShort, a, c, 3);
+							case "MMMM": return h(c, a);
+							case "D": return e.$D;
+							case "DD": return b.s(e.$D, 2, "0");
+							case "d": return String(e.$W);
+							case "dd": return h(n.weekdaysMin, e.$W, o, 2);
+							case "ddd": return h(n.weekdaysShort, e.$W, o, 3);
+							case "dddd": return o[e.$W];
+							case "H": return String(s);
+							case "HH": return b.s(s, 2, "0");
+							case "h": return d(1);
+							case "hh": return d(2);
+							case "a": return $(s, u, !0);
+							case "A": return $(s, u, !1);
+							case "m": return String(u);
+							case "mm": return b.s(u, 2, "0");
+							case "s": return String(e.$s);
+							case "ss": return b.s(e.$s, 2, "0");
+							case "SSS": return b.s(e.$ms, 3, "0");
+							case "Z": return i;
+						}
+						return null;
+					}(t) || i.replace(":", "");
+				}));
+			}, m.utcOffset = function() {
+				return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+			}, m.diff = function(r, d, l) {
+				var $, y = this, M = b.p(d), m = O(r), v = (m.utcOffset() - this.utcOffset()) * e, g = this - m, D = function() {
+					return b.m(y, m);
+				};
+				switch (M) {
+					case h:
+						$ = D() / 12;
+						break;
+					case c:
+						$ = D();
+						break;
+					case f:
+						$ = D() / 3;
+						break;
+					case o:
+						$ = (g - v) / 6048e5;
+						break;
+					case a:
+						$ = (g - v) / 864e5;
+						break;
+					case u:
+						$ = g / n;
+						break;
+					case s:
+						$ = g / e;
+						break;
+					case i:
+						$ = g / t;
+						break;
+					default: $ = g;
+				}
+				return l ? $ : b.a($);
+			}, m.daysInMonth = function() {
+				return this.endOf(c).$D;
+			}, m.$locale = function() {
+				return D[this.$L];
+			}, m.locale = function(t, e) {
+				if (!t) return this.$L;
+				var n = this.clone(), r = w(t, e, !0);
+				return r && (n.$L = r), n;
+			}, m.clone = function() {
+				return b.w(this.$d, this);
+			}, m.toDate = function() {
+				return new Date(this.valueOf());
+			}, m.toJSON = function() {
+				return this.isValid() ? this.toISOString() : null;
+			}, m.toISOString = function() {
+				return this.$d.toISOString();
+			}, m.toString = function() {
+				return this.$d.toUTCString();
+			}, M;
+		}(), k = _.prototype;
+		return O.prototype = k, [
+			["$ms", r],
+			["$s", i],
+			["$m", s],
+			["$H", u],
+			["$W", a],
+			["$M", c],
+			["$y", h],
+			["$D", d]
+		].forEach((function(t) {
+			k[t[1]] = function(e) {
+				return this.$g(e, t[0], t[1]);
+			};
+		})), O.extend = function(t, e) {
+			return t.$i || (t(e, _, O), t.$i = !0), O;
+		}, O.locale = w, O.isDayjs = S, O.unix = function(t) {
+			return O(1e3 * t);
+		}, O.en = D[g], O.Ls = D, O.p = {}, O;
+	}));
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/kanun@1.2.0/node_modules/kanun/dist/index.js
+var import_customParseFormat = /* @__PURE__ */ __toESM(require_customParseFormat(), 1);
+var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
+new AsyncLocalStorage();
+var locales_default = {
+	en: {
+		accepted: "The :attribute must be accepted.",
+		accepted_if: "The :attribute must be accepted when :other is :value.",
+		after: "The :attribute must be a date after :date.",
+		after_or_equal: "The :attribute must be a date after or equal to :date.",
+		alpha: "The :attribute must only contain letters.",
+		alpha_dash: "The :attribute must only contain at least one letter or one number, and optionally dashes and underscores.",
+		alpha_num: "The :attribute must only contain letters and numbers.",
+		array: "The :attribute must be an array.",
+		array_unique: "The :attribute must be an array with unique values.",
+		before: "The :attribute must be a date before :date.",
+		before_or_equal: "The :attribute must be a date before or equal to :date.",
+		between: {
+			number: "The :attribute must be between :min and :max.",
+			string: "The :attribute must be between :min and :max characters.",
+			array: "The :attribute must have between :min and :max items.",
+			object: "The :attribute must have between :min and :max items."
+		},
+		boolean: "The :attribute field must be true or false.",
+		confirmed: "The :attribute confirmation does not match.",
+		date: "The :attribute is not a valid date.",
+		datetime: "The :attribute must be a valid date matching the format :format.",
+		date_equals: "The :attribute must be a date equal to :date.",
+		declined: "The :attribute must be declined.",
+		declined_if: "The :attribute must be declined when :other is :value.",
+		different: "The :attribute and :other must be different.",
+		distinct: "The :attribute field has a duplicate value.",
+		digits: "The :attribute must be :digits digits.",
+		digits_between: "The :attribute must be between :min and :max digits.",
+		email: "The :attribute must be a valid email address.",
+		ends_with: "The :attribute must end with one of the following: :values.",
+		filled: "The :attribute field must have a value.",
+		exists: "The selected :attribute is invalid.",
+		gt: {
+			number: "The :attribute must be greater than :value.",
+			string: "The :attribute must be greater than :value characters.",
+			array: "The :attribute must have more than :value items.",
+			object: "The :attribute must have more than :value items."
+		},
+		gte: {
+			number: "The :attribute must be greater than or equal :value.",
+			string: "The :attribute must be greater than or equal :value characters.",
+			array: "The :attribute must have :value items or more.",
+			object: "The :attribute must have :value items or more."
+		},
+		hex: "The :attribute must be a valid hexadecimal color.",
+		in: "The :attribute must be one of the following :values.",
+		includes: "The :attribute must include one of the following values: :values.",
+		integer: "The :attribute must be an integer.",
+		ip: "The :attribute must be a valid IP address.",
+		ipv4: "The :attribute must be a valid IPv4 address.",
+		ipv6: "The :attribute must be a valid IPv6 address.",
+		json: "The :attribute must be a valid JSON string.",
+		lt: {
+			number: "The :attribute must be less than :value.",
+			string: "The :attribute must be less than :value characters.",
+			array: "The :attribute must have less than :value items.",
+			object: "The :attribute must have less than :value items."
+		},
+		lte: {
+			number: "The :attribute must be less than or equal :value.",
+			string: "The :attribute must be less than or equal :value characters.",
+			array: "The :attribute must have :value items or less.",
+			object: "The :attribute must have :value items or less."
+		},
+		max: {
+			number: "The :attribute must not be greater than :max.",
+			string: "The :attribute must not be greater than :max characters.",
+			array: "The :attribute must not have more than :max items.",
+			object: "The :attribute must not have more than :max items."
+		},
+		min: {
+			number: "The :attribute must be at least :min.",
+			string: "The :attribute must be at least :min characters.",
+			array: "The :attribute must have at least :min items.",
+			object: "The :attribute must have at least :min items."
+		},
+		mac_address: "The :attribute must be a valid MAC address.",
+		not_in: "The selected :attribute is invalid.",
+		not_regex: "The :attribute format is invalid.",
+		not_includes: "The :attribute must not include any of the following values: :values.",
+		numeric: "The :attribute must be a number.",
+		object: "The :attribute must be an object.",
+		password: {
+			letter: "The :attribute must contain at least one letter.",
+			letters: "The :attribute must contain at least :amount letters.",
+			lower_case: "The :attribute must contain at least one lowercase letter.",
+			lower_cases: "The :attribute must contain at least :amount lowercase letters.",
+			number: "The :attribute must contain at least one number.",
+			numbers: "The :attribute must contain at least :amount numbers.",
+			symbol: "The :attribute must contain at least one symbol.",
+			symbols: "The :attribute must contain at least :amount symbols.",
+			upper_case: "The :attribute must contain at least one uppercase letter.",
+			upper_cases: "The :attribute must contain at least :amount uppercase letters."
+		},
+		present: "The :attribute field must be present.",
+		presentsame: "The :attribute field must be present.",
+		prohibited: "The :attribute field is prohibited.",
+		prohibited_unless: "The :attribute field is prohibited unless :other is in :values.",
+		prohibits: "The :attribute field prohibits :values from being present.",
+		regex: "The :attribute format is invalid.",
+		required: "The :attribute field is required.",
+		required_if: "The :attribute field is required when :other is :value.",
+		required_unless: "The :attribute field is required unless :other is in :values.",
+		required_with: "The :attribute field is required when :values is present.",
+		required_with_all: "The :attribute field is required when :values are present.",
+		required_without: "The :attribute field is required when :values is not present.",
+		required_without_all: "The :attribute field is required when none of :values are present.",
+		starts_with: "The :attribute must start with one of the following: :values.",
+		same: "The :attribute and :other must match.",
+		size: {
+			number: "The :attribute must be :size.",
+			string: "The :attribute must be :size characters.",
+			array: "The :attribute must contain :size items.",
+			object: "The :attribute must contain :size items."
+		},
+		string: "The :attribute must be a string.",
+		timezone: "The :attribute must be a valid timezone.",
+		unique: "The :attribute has already been taken.",
+		url: "The :attribute must have a valid URL format.",
+		multiple_of: "The :attribute must be a multiple of :value."
+	},
+	ar: {
+		accepted: "يجب قبول الحقل :attribute",
+		accepted_if: "الحقل :attribute مقبول في حال ما إذا كان :other يساوي :value.",
+		after: "يجب على الحقل :attribute أن يكون تاريخا لاحقا للتاريخ :date.",
+		after_or_equal: "الحقل :attribute يجب أن يكون تاريخاً لاحقاً أو مطابقاً للتاريخ :date.",
+		alpha: "يجب أن لا يحتوي الحقل :attribute سوى على حروف",
+		alpha_dash: "يجب أن يحتوي الحقل :attribute على حرف واحد أو رقم واحد على الأقل، بالإضافة إلى شرطات وشرطات سفلية بشكل اختياري",
+		alpha_num: "يجب أن يحتوي :attribute على حروف وأرقام فقط",
+		array: "يجب أن يكون الحقل :attribute ًمصفوفة",
+		before: "يجب على الحقل :attribute أن يكون تاريخا سابقا للتاريخ :date.",
+		before_or_equal: "الحقل :attribute يجب أن يكون تاريخا سابقا أو مطابقا للتاريخ :date",
+		between: {
+			number: "يجب أن تكون قيمة :attribute بين :min و :max.",
+			string: "يجب أن يكون عدد حروف النّص :attribute بين :min و :max",
+			array: "يجب أن يحتوي :attribute على عدد من العناصر بين :min و :max",
+			object: "يجب أن يحتوي :attribute على عدد من العناصر بين :min و :max"
+		},
+		boolean: "يجب أن تكون قيمة الحقل :attribute إما true أو false",
+		confirmed: "حقل التأكيد غير مُطابق للحقل :attribute",
+		date: "الحقل :attribute ليس تاريخًا صحيحًا",
+		datetime: "الحقل :attribute يجب أن يكون تاريخًا صالحًا يطابق الصيغة :format.",
+		date_equals: "لا يساوي الحقل :attribute مع :date.",
+		declined: "يجب رفض الحقل :attribute",
+		declined_if: "الحقل :attribute مرفوض في حال ما إذا كان :other يساوي :value.",
+		different: "يجب أن يكون الحقلان :attribute و :other مُختلفان",
+		digits: "يجب أن يحتوي الحقل :attribute على :digits رقمًا/أرقام",
+		digits_between: "يجب أن يحتوي الحقل :attribute بين :min و :max رقمًا/أرقام",
+		email: "يجب أن يكون :attribute عنوان بريد إلكتروني صحيح البُنية",
+		ends_with: "حقل :attribute يجب ان ينتهي بأحد القيم التالية :value.",
+		exists: "الحقل :attribute غير موجود",
+		gt: {
+			number: "حقل :attribute يجب ان يكون اكبر من :value.",
+			string: "حقل :attribute يجب ان يكون اكبر من :value حروفٍ/حرفًا.",
+			array: "حقل :attribute يجب ان يحتوي علي اكثر من :value عناصر/عنصر.",
+			object: "حقل :attribute يجب ان يحتوي علي اكثر من :value عناصر/عنصر."
+		},
+		gte: {
+			number: "حقل :attribute يجب ان يكون اكبر من او يساوي :value.",
+			string: "حقل :attribute يجب ان يكون اكبر من او يساوي :value حروفٍ/حرفًا.",
+			array: "حقل :attribute يجب ان يحتوي علي :value عناصر/عنصر او اكثر.",
+			object: "حقل :attribute يجب ان يحتوي علي :value عناصر/عنصر او اكثر."
+		},
+		hex: "الحقل :attribute يجب أن يكون لونًا سداسيًا صالحًا.",
+		in: "الحقل :attribute غير صالح",
+		includes: "الحقل :attribute يجب أن يحتوي على أحد القيم التالية: :values.",
+		integer: "يجب أن يكون الحقل :attribute عددًا صحيحًا",
+		json: "يجب أن يكون الحقل :attribute نصا من نوع JSON.",
+		lt: {
+			number: "حقل :attribute يجب ان يكون اقل من :value.",
+			string: "حقل :attribute يجب ان يكون اقل من :value حروفٍ/حرفًا.",
+			array: "حقل :attribute يجب ان يحتوي علي اقل من :value عناصر/عنصر.",
+			object: "حقل :attribute يجب ان يحتوي علي اقل من :value عناصر/عنصر."
+		},
+		lte: {
+			number: "حقل :attribute يجب ان يكون اقل من او يساوي :value.",
+			string: "حقل :attribute يجب ان يكون اقل من او يساوي :value حروفٍ/حرفًا.",
+			array: "حقل :attribute يجب ان يحتوي علي اكثر من :value عناصر/عنصر.",
+			object: "حقل :attribute يجب ان يحتوي علي اكثر من :value عناصر/عنصر."
+		},
+		max: {
+			number: "يجب أن تكون قيمة الحقل :attribute مساوية أو أصغر لـ :max.",
+			string: "يجب أن لا يتجاوز طول نص :attribute :max حروفٍ/حرفًا",
+			array: "يجب أن لا يحتوي الحقل :attribute على أكثر من :max عناصر/عنصر.",
+			object: "يجب أن لا يحتوي الحقل :attribute على أكثر من :max عناصر/عنصر."
+		},
+		min: {
+			number: "يجب أن تكون قيمة الحقل :attribute مساوية أو أكبر لـ :min.",
+			string: "يجب أن يكون طول نص :attribute على الأقل :min حروفٍ/حرفًا",
+			array: "يجب أن يحتوي الحقل :attribute على الأقل على :min عُنصرًا/عناصر",
+			object: "يجب أن يحتوي الحقل :attribute على الأقل على :min عُنصرًا/عناصر"
+		},
+		not_in: "الحقل :attribute غير صالح",
+		not_regex: "الحقل :attribute نوعه غير صالح",
+		not_includes: "الحقل :attribute يجب ألا يحتوي على أي من القيم التالية: :values.",
+		numeric: "يجب على الحقل :attribute أن يكون رقمًا",
+		object: "الحقل :attribute يجب ان يكون من نوع object.",
+		password: {
+			letter: "يجب ان يشمل حقل :attribute على حرف واحد على الاقل.",
+			letters: "يجب ان يشمل حقل :attribute على عدد :amount حروف على الاقل.",
+			lower_case: "يجب ان يشمل حقل :attribute على حرف واحد من صيغة صغيرة على الاقل.",
+			lower_cases: "يجب ان يشمل حقل :attribute على عدد :amount حروف صغيرة على الاقل.",
+			number: "يجب ان يشمل حقل :attribute على رقم واحد على الاقل.",
+			numbers: "يجب ان يشمل حقل :attribute على عدد :amount من الارقام على الاقل.",
+			symbol: "يجب ان يشمل حقل :attribute على رمز واحد على الاقل.",
+			symbols: "يجب ان يشمل حقل :attribute على عدد :amount رموز على الاقل.",
+			upper_case: "يجب ان يشمل حقل :attribute على حرف كبير واحد على الاقل.",
+			upper_cases: "يجب ان يشمل حقل :attribute على عدد :amount حروف كبيرة على الاقل."
+		},
+		present: "يجب تقديم الحقل :attribute",
+		regex: "صيغة الحقل :attribute .غير صحيحة",
+		required: "الحقل :attribute مطلوب.",
+		required_if: "الحقل :attribute مطلوب في حال ما إذا كان :other يساوي :value.",
+		required_unless: "الحقل :attribute مطلوب في حال ما لم يكن :other يساوي :values.",
+		required_with: "الحقل :attribute اجباري إذا توفّر :values.",
+		required_with_all: "الحقل :attribute اجباري إذا توفّر :values.",
+		required_without: "الحقل :attribute اجباري إذا لم يتوفّر :values.",
+		required_without_all: "الحقل :attribute اجباري إذا لم يتوفّر :values.",
+		starts_with: "الحقل :attribute يجب ان يبدأ بأحد القيم التالية: :values.",
+		same: "يجب أن يتطابق الحقل :attribute مع :other",
+		size: {
+			number: "يجب أن تكون قيمة الحقل :attribute مساوية لـ :size",
+			string: "يجب أن يحتوي النص :attribute على :size حروفٍ/حرفًا بالظبط",
+			array: "يجب أن يحتوي الحقل :attribute على :size عنصرٍ/عناصر بالظبط",
+			object: "يجب أن يحتوي الحقل :attribute على :size عنصرٍ/عناصر بالظبط"
+		},
+		string: "يجب أن يكون الحقل :attribute نصآ.",
+		unique: "الحقل :attribute مستخدم بالفعل.",
+		url: "صيغة الرابط :attribute غير صحيحة"
+	}
+};
+/**
+* Determine if a value is an object. Arrays and null are not considered objects.
+* 
+* @param value 
+* @returns 
+*/
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Deeply merge two objects. 
+* The source object will overwrite the target object when there is a conflict.
+* Arrays and non-object values will be overwritten, not merged.
+* 
+* @param target 
+* @param source 
+* @returns 
+*/
+function mergeDeep(target, source) {
+	const output = Object.assign({}, target);
+	if (!isObject(target) || !isObject(source)) return output;
+	for (const key in source) if (isObject(source[key])) if (!target[key]) Object.assign(output, { [key]: source[key] });
+	else output[key] = mergeDeep(target[key], source[key]);
+	else Object.assign(output, { [key]: source[key] });
+	return output;
+}
+(class {
+	/**
+	* Default lang to be used, when lang is not specified 
+	*/
+	static defaultLang = "en";
+	/**
+	* Determines the locale to be used when tu current one is not available
+	*/
+	static fallbackLang = "en";
+	/**
+	* The existing langs that are supported by the library
+	*/
+	static existingLangs = ["en"];
+	/**
+	* Store the translations passed by the user
+	*/
+	static translations = {};
+	/**
+	* Store translations contributed by plugins.
+	*/
+	static translationExtensions = {};
+	/**
+	* Stores the messages that are already loaded
+	*/
+	static messages = {};
+	/**
+	* Stores the default messages
+	*/
+	static defaultMessages = {};
+	/**
+	* Stores the fallback messages
+	*/
+	static fallbackMessages = locales_default.en;
+	/**
+	* Get messages for lang 
+	* 
+	* @param lang 
+	* @returns 
+	*/
+	static get(lang) {
+		lang ??= this.defaultLang;
+		this.load(lang);
+		return this.messages[lang];
+	}
+	/**
+	* Set the translation object passed by the user
+	* 
+	* @param translations 
+	*/
+	static setTranslationObject(translations) {
+		this.translations = translations;
+		this.existingLangs = Array.from(/* @__PURE__ */ new Set([...this.existingLangs, ...Object.keys(translations)]));
+		this.resetLoadedMessages();
+		this.setDefaultLang(this.defaultLang);
+	}
+	/**
+	* Merge additional translations into the global catalog.
+	*/
+	static extendTranslationObject(translations) {
+		this.translationExtensions = mergeDeep(this.translationExtensions, translations);
+		this.existingLangs = Array.from(/* @__PURE__ */ new Set([...this.existingLangs, ...Object.keys(translations)]));
+		this.resetLoadedMessages();
+		this.setDefaultLang(this.defaultLang);
+	}
+	/**
+	* Set the default lang that should be used. And assign the default messages
+	* 
+	* @param lang 
+	*/
+	static setDefaultLang(lang) {
+		this.defaultLang = lang;
+		this.load(lang);
+	}
+	/**
+	* Set the fallback lang to be used. And assign the fallback messages
+	* 
+	* @param lang 
+	*/
+	static setFallbackLang(lang) {
+		this.fallbackLang = lang;
+		this.fallbackMessages = locales_default.en;
+		if (Object.prototype.hasOwnProperty.call(locales_default, lang)) this.fallbackMessages = mergeDeep(this.fallbackMessages, locales_default[lang]);
+		if (Object.prototype.hasOwnProperty.call(this.translationExtensions, lang)) this.fallbackMessages = mergeDeep(this.fallbackMessages, this.translationExtensions[lang]);
+		if (Object.prototype.hasOwnProperty.call(this.translations, lang)) this.fallbackMessages = mergeDeep(this.fallbackMessages, this.translations[lang]);
+	}
+	/**
+	* Get the default language
+	* 
+	* @returns 
+	*/
+	static getDefaultLang() {
+		return this.defaultLang;
+	}
+	/**
+	* Load the messages based on the specified language
+	* 
+	* @param lang 
+	* @returns 
+	*/
+	static load(lang) {
+		if (this.messages[lang]) return;
+		if (Object.prototype.hasOwnProperty.call(locales_default, lang)) this.messages[lang] = mergeDeep(this.fallbackMessages, locales_default[lang]);
+		else this.messages[lang] = mergeDeep({}, this.fallbackMessages);
+		if (Object.prototype.hasOwnProperty.call(this.translationExtensions, lang)) this.messages[lang] = mergeDeep(this.messages[lang], this.translationExtensions[lang]);
+		if (Object.prototype.hasOwnProperty.call(this.translations, lang)) this.messages[lang] = mergeDeep(this.messages[lang], this.translations[lang]);
+	}
+	static resetLoadedMessages() {
+		this.messages = {};
+		this.fallbackMessages = locales_default.en;
+	}
+});
+import_dayjs_min.default.extend(import_customParseFormat.default);
+//#endregion
+//#region ../http/dist/redirect-g4KUj_g-.js
+const unwrapRequestSource = (source) => {
+	if (source.original) return unwrapRequestSource(source.original);
+	if (source.headers) return source;
+	if (source.req) return source.req;
+	if (source.request) return source.request;
+	return source;
+};
+const makeHeaders = (headers) => {
+	return new Headers(normalizeHeaders(headers));
+};
+const normalizeHeaders = (headers) => {
+	const normalized = {};
+	if (!headers) return normalized;
+	if (isHeaders(headers)) {
+		headers.forEach((value, key) => {
+			normalized[key.toLowerCase()] = value;
+		});
+		return normalized;
+	}
+	for (const [key, value] of Object.entries(headers)) {
+		const normalizedValue = normalizeHeaderValue(value);
+		if (typeof normalizedValue === "string") normalized[key.toLowerCase()] = normalizedValue;
+	}
+	return normalized;
+};
+const normalizeHeaderValue = (value) => {
+	if (Array.isArray(value)) return value.join(", ");
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return value ?? void 0;
+};
+const isHeaders = (value) => typeof Headers !== "undefined" && value instanceof Headers;
+const isRecord = (value) => {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+};
+let fallbackRequest;
+const requestResolvers = /* @__PURE__ */ new Set();
+const currentRequest = () => {
+	for (const resolver of requestResolvers) {
+		const request = resolver();
+		if (request) return request;
+	}
+	return fallbackRequest;
+};
+const requestHelper = ((key) => {
+	const request = currentRequest();
+	return key ? request?.input(key) : request;
+});
+const setFallbackRequest = (request) => {
+	fallbackRequest = request;
+	globalThis.request = requestHelper;
+};
+/**
+* Represents an HTTP request, providing a consistent interface for accessing request data.
+* 
+* @author 3m1n3nc3
+*/
+var Request$1 = class Request$1 extends Request {
+	headers;
+	ip;
+	source;
+	currentUser;
+	currentAuth;
+	currentAuthUser;
+	currentAuthToken;
+	get user() {
+		return this.getSourceRequest()?.user ?? this.currentUser;
+	}
+	set user(user) {
+		this.currentUser = user;
+	}
+	get auth() {
+		return this.getSourceRequest()?.auth ?? this.currentAuth;
+	}
+	set auth(auth) {
+		this.currentAuth = auth;
+	}
+	get authUser() {
+		return this.getSourceRequest()?.authUser ?? this.currentAuthUser;
+	}
+	set authUser(user) {
+		this.currentAuthUser = user;
+	}
+	get authToken() {
+		return this.getSourceRequest()?.authToken ?? this.currentAuthToken;
+	}
+	set authToken(token) {
+		this.currentAuthToken = token;
+	}
+	constructor(options = {}) {
+		super(options);
+		const source = options.source ?? options.original;
+		const sourceRequest = isRecord(source) ? source : void 0;
+		this.headers = normalizeHeaders(options.headers);
+		if (this.method) this.method = options.method;
+		if (this.url) this.url = options.url;
+		if (this.path) this.path = options.path;
+		this.ip = options.ip ?? sourceRequest?.ip ?? null;
+		this.user = options.user ?? sourceRequest?.user;
+		this.auth = options.auth ?? sourceRequest?.auth;
+		this.authUser = options.authUser ?? sourceRequest?.authUser;
+		this.authToken = options.authToken ?? sourceRequest?.authToken;
+		this.source = source;
+		setFallbackRequest(this);
+	}
+	static from(source) {
+		if (!source) return;
+		if (source instanceof Request$1) return source;
+		const request = unwrapRequestSource(source);
+		const unified = source;
+		return new Request$1({
+			body: unified.body,
+			query: unified.query,
+			params: unified.params,
+			route: unified.route,
+			ctx: unified.ctx,
+			headers: request.headers,
+			method: request.method,
+			url: request.originalUrl ?? request.url,
+			path: request.path,
+			ip: request.ip ?? null,
+			user: request.user,
+			auth: request.auth,
+			authUser: request.authUser,
+			authToken: request.authToken,
+			source: request,
+			original: unified.original
+		});
+	}
+	header(name) {
+		return this.headers[name.toLowerCase()];
+	}
+	bearerToken() {
+		const authorization = this.header("authorization");
+		if (!authorization?.startsWith("Bearer ")) return null;
+		return authorization.substring(7);
+	}
+	setUser(user) {
+		this.user = user;
+		if (isRecord(this.source)) this.source.user = user;
+		return this;
+	}
+	setAuthentication(auth, user, token) {
+		this.auth = auth;
+		this.authUser = user;
+		this.authToken = token;
+		this.setUser(user);
+		if (isRecord(this.source)) {
+			this.source.auth = auth;
+			this.source.authUser = user;
+			this.source.authToken = token;
+		}
+		return this;
+	}
+	syncFromSource() {
+		if (!isRecord(this.source)) return this;
+		const source = this.source;
+		this.user = source.user ?? this.user;
+		this.auth = source.auth ?? this.auth;
+		this.authUser = source.authUser ?? this.authUser;
+		this.authToken = source.authToken ?? this.authToken;
+		return this;
+	}
+	getSourceRequest() {
+		return isRecord(this.source) ? this.source : void 0;
+	}
+	clearAuthentication() {
+		this.auth = void 0;
+		this.authUser = void 0;
+		this.authToken = void 0;
+		this.user = void 0;
+		if (isRecord(this.source)) {
+			this.source.auth = void 0;
+			this.source.authUser = void 0;
+			this.source.authToken = void 0;
+			this.source.user = void 0;
+		}
+		return this;
+	}
+};
+let fallbackResponse;
+const responseResolvers = /* @__PURE__ */ new Set();
+const responseHelper = () => {
+	for (const resolver of responseResolvers) {
+		const response = resolver();
+		if (response) return response;
+	}
+	return fallbackResponse;
+};
+const setFallbackResponse = (response) => {
+	fallbackResponse = response;
+	globalThis.response = responseHelper;
+};
+/**
+* Represents an HTTP response, providing a consistent interface for accessing response data.
+* 
+* @author 3m1n3nc3
+*/
+var Response$1 = class Response$1 extends Response {
+	body;
+	source;
+	constructor(options = {}) {
+		super({
+			body: options.body,
+			headers: makeHeaders(options.headers),
+			statusCode: options.statusCode ?? 200
+		});
+		this.body = options.body ?? {};
+		this.source = options.source;
+		setFallbackResponse(this);
+	}
+	static from(source) {
+		if (!source) return;
+		if (source instanceof Response$1) return source;
+		return new Response$1({
+			statusCode: typeof source.status === "number" ? source.status : source.statusCode,
+			headers: source.headers,
+			source
+		});
+	}
+	status(code) {
+		this.statusCode = code;
+		if (isRecord(this.source)) if (typeof this.source.status === "function") this.source.status(code);
+		else this.source.statusCode = code;
+		return this;
+	}
+	header(name, value) {
+		this.headers.set(name.toLowerCase(), value);
+		if (isRecord(this.source) && typeof this.source.setHeader === "function") this.source.setHeader(name, value);
+		return this;
+	}
+	getHeaders() {
+		return normalizeHeaders(this.headers);
+	}
+	json(body) {
+		this.body = body;
+		if (isRecord(this.source) && typeof this.source.json === "function") return this.source.json(body);
+		return body;
+	}
+	send(body) {
+		this.body = body;
+		if (isRecord(this.source) && typeof this.source.send === "function") return this.source.send(body);
+		return body;
+	}
+};
+var FlashBag = class {
+	bag = {};
+	sweepKeys = /* @__PURE__ */ new Set();
+	constructor(items) {
+		this.bag = { ...items || {} };
+		this.sweepKeys = new Set(Object.keys(this.bag));
+	}
+	put(key, value) {
+		this.bag[key] = value;
+		this.sweepKeys.delete(key);
+		return this;
+	}
+	set(key, value) {
+		return this.put(key, value);
+	}
+	get(key, defaultValue) {
+		return key in this.bag ? this.bag[key] : defaultValue;
+	}
+	has(key) {
+		if (Array.isArray(key)) return key.every((item) => this.has(item));
+		if (key) return key in this.bag;
+		return this.any();
+	}
+	any() {
+		return Object.keys(this.bag).length > 0;
+	}
+	isEmpty() {
+		return !this.any();
+	}
+	isNotEmpty() {
+		return this.any();
+	}
+	keys() {
+		return Object.keys(this.bag);
+	}
+	all() {
+		return { ...this.bag };
+	}
+	clear(key) {
+		if (Array.isArray(key)) {
+			for (const item of key) {
+				delete this.bag[item];
+				this.sweepKeys.delete(item);
+			}
+			return this;
+		}
+		if (key) {
+			delete this.bag[key];
+			this.sweepKeys.delete(key);
+			return this;
+		}
+		this.bag = {};
+		this.sweepKeys.clear();
+		return this;
+	}
+	forget(key) {
+		return this.clear(key);
+	}
+	markForSweep(keys = this.keys()) {
+		this.sweepKeys = new Set(keys);
+		return this;
+	}
+	sweep() {
+		for (const key of this.sweepKeys) delete this.bag[key];
+		this.sweepKeys = new Set(Object.keys(this.bag));
+		return this;
+	}
+	toJSON() {
+		return this.all();
+	}
+};
+const asMessageRecord = (value) => {
+	if (!isRecord(value)) return;
+	return value;
+};
+const callRecordMethod = (source, method) => {
+	if (typeof source[method] !== "function") return;
+	const value = source[method]();
+	return asMessageRecord(value);
+};
+const resolveMessageRecord = (source) => {
+	if (!isRecord(source)) return;
+	if (typeof source.getMessageBag === "function") {
+		const bag = source.getMessageBag();
+		if (bag && bag !== source) {
+			const messages = resolveMessageRecord(bag);
+			if (messages) return messages;
+		}
+	}
+	if (typeof source.errors === "function") {
+		const errors = source.errors();
+		const messages = resolveMessageRecord(errors) || asMessageRecord(errors);
+		if (messages) return messages;
+	}
+	return callRecordMethod(source, "getMessages") || callRecordMethod(source, "messagesRaw") || callRecordMethod(source, "toArray") || resolveMessageRecord(source.errors) || asMessageRecord(source.errors);
+};
+const getValidationIssueField = (issue) => {
+	if (typeof issue.field === "string") return issue.field;
+	if (typeof issue.attribute === "string") return issue.attribute;
+	if (typeof issue.key === "string") return issue.key;
+	if (typeof issue.path === "string") return issue.path;
+	if (Array.isArray(issue.path)) return issue.path.join(".") || "_";
+	return "_";
+};
+const toMessages = (value) => {
+	if (Array.isArray(value)) return value.flatMap((item) => toMessages(item));
+	if (value instanceof Error) return [value.message];
+	if (isRecord(value) && typeof value.message === "string") return [value.message];
+	if (value === null || typeof value === "undefined") return [];
+	return [String(value)];
+};
+var ErrorBag = class ErrorBag extends FlashBag {
+	constructor(errors) {
+		super();
+		if (errors) {
+			this.merge(errors);
+			this.markForSweep();
+		}
+	}
+	add(field, message) {
+		const key = field || "_";
+		const messages = toMessages(message);
+		if (!messages.length) return this;
+		this.put(key, [...this.bag[key] || [], ...messages]);
+		return this;
+	}
+	addIf(condition, field, message) {
+		if (condition) this.add(field, message);
+		return this;
+	}
+	merge(errors) {
+		const incoming = resolveMessageRecord(errors) || (isRecord(errors) ? errors : void 0);
+		if (!incoming) return this.validation(errors);
+		for (const [field, messages] of Object.entries(incoming)) this.add(field, messages);
+		return this;
+	}
+	validation(error) {
+		if (!error) return this;
+		if (error instanceof ErrorBag) return this.merge(error);
+		const messages = resolveMessageRecord(error);
+		if (messages) return this.merge(messages);
+		if (Array.isArray(error)) {
+			for (const item of error) if (isRecord(item) && "message" in item) this.add(getValidationIssueField(item), item.message);
+			else this.add("_", item);
+			return this;
+		}
+		if (isRecord(error)) {
+			if (typeof error.errors === "function") return this.validation(error.errors());
+			if (error.errors) return this.validation(error.errors);
+			if (Array.isArray(error.issues)) return this.validation(error.issues);
+			if ("message" in error) return this.add(getValidationIssueField(error), error.message);
+			return this.merge(error);
+		}
+		if (error instanceof Error) return this.add("_", error.message);
+		return this.add("_", error);
+	}
+	keys() {
+		return Object.keys(this.bag);
+	}
+	get(field = "_") {
+		return [...this.bag[field] || []];
+	}
+	first(field) {
+		if (field) return this.bag[field]?.[0] || "";
+		return this.all()[0] || "";
+	}
+	has(field) {
+		if (Array.isArray(field)) return field.every((key) => this.has(key));
+		if (field) return (this.bag[field]?.length || 0) > 0;
+		return this.any();
+	}
+	hasAny(fields) {
+		return (Array.isArray(fields) ? fields : [fields]).some((key) => this.has(key));
+	}
+	missing(fields) {
+		return (Array.isArray(fields) ? fields : [fields]).every((key) => !this.has(key));
+	}
+	any() {
+		return Object.values(this.bag).some((messages) => messages.length > 0);
+	}
+	isEmpty() {
+		return !this.any();
+	}
+	isNotEmpty() {
+		return this.any();
+	}
+	count() {
+		return Object.values(this.bag).reduce((total, messages) => total + messages.length, 0);
+	}
+	all() {
+		return Object.values(this.bag).flat();
+	}
+	unique() {
+		return [...new Set(this.all())];
+	}
+	clear(field) {
+		super.clear(field);
+		return this;
+	}
+	forget(field) {
+		return this.clear(field);
+	}
+	messagesRaw() {
+		return this.toJSON();
+	}
+	getMessages() {
+		return this.messagesRaw();
+	}
+	getMessageBag() {
+		return this;
+	}
+	toArray() {
+		return this.toJSON();
+	}
+	toJSON() {
+		return Object.entries(this.bag).reduce((errors, [field, messages]) => {
+			errors[field] = [...messages];
+			return errors;
+		}, {});
+	}
+};
+let fallbackSession;
+const sessionResolvers = /* @__PURE__ */ new Set();
+const currentSession = () => {
+	for (const resolver of sessionResolvers) {
+		const session = resolver();
+		if (session) return session;
+	}
+	return fallbackSession;
+};
+const sessionHelperTarget = (key) => {
+	const session = currentSession();
+	return key ? session?.get(key) : session;
+};
+const sessionHelper = new Proxy(sessionHelperTarget, { get(target, property, receiver) {
+	if (Reflect.has(target, property)) return Reflect.get(target, property, receiver);
+	const session = currentSession();
+	const value = session?.[property];
+	return typeof value === "function" ? value.bind(session) : value;
+} });
+const setFallbackSession = (session) => {
+	fallbackSession = session;
+	globalThis.session = sessionHelper;
+};
+var Session = class Session {
+	errors;
+	flashBag;
+	id;
+	data;
+	persistent;
+	saveQueue = Promise.resolve();
+	constructor(initial, persistent) {
+		const current = initial instanceof Session ? initial : void 0;
+		const state = current ? current.snapshot() : initial && ("data" in initial || "errors" in initial || "flash" in initial) ? initial : { data: initial };
+		this.id = persistent?.id ?? current?.id;
+		this.persistent = persistent ?? current?.persistent;
+		this.saveQueue = current?.saveQueue ?? this.saveQueue;
+		this.data = current ? current.data : { ...state.data || {} };
+		this.errors = current ? current.errors : state.errors instanceof ErrorBag ? state.errors : new ErrorBag(state.errors);
+		this.flashBag = current ? current.flashBag : state.flash instanceof FlashBag ? state.flash : new FlashBag(state.flash);
+		setFallbackSession(this);
+	}
+	snapshot() {
+		return {
+			data: this.all(),
+			errors: this.errors.toJSON(),
+			flash: this.flashBag.toJSON()
+		};
+	}
+	queuePersist() {
+		this.save();
+	}
+	async save() {
+		const payload = this.snapshot();
+		const previous = this.saveQueue.catch(() => void 0);
+		this.saveQueue = previous.then(async () => {
+			await this.persistent?.save(payload);
+		});
+		await this.saveQueue;
+		return this;
+	}
+	async destroy() {
+		this.data = {};
+		this.errors.clear();
+		this.flashBag.clear();
+		await this.persistent?.destroy?.();
+		return this;
+	}
+	/**
+	* Get an item from the session bag
+	*
+	* @param key
+	* @param defaultValue
+	* @returns
+	*/
+	get(key, defaultValue) {
+		return key in this.data ? this.data[key] : defaultValue;
+	}
+	/**
+	* Add an item to the session bag
+	*
+	* @param key
+	* @param defaultValue
+	* @returns
+	*/
+	put(key, value) {
+		this.data[key] = value;
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Add an item to the session bag
+	*
+	* @param key
+	* @param defaultValue
+	* @returns
+	*/
+	set(key, value) {
+		return this.put(key, value);
+	}
+	/**
+	* Check if an item exist in the session bag
+	*
+	* @param key
+	* @returns
+	*/
+	has(key) {
+		return key in this.data;
+	}
+	/**
+	* Remove an item from the session bag
+	*
+	* @param key
+	* @returns
+	*/
+	forget(key) {
+		delete this.data[key];
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Clear the session bag
+	*
+	* @returns
+	*/
+	clear() {
+		this.data = {};
+		this.errors.clear();
+		this.flashBag.clear();
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Get all items in the session bag
+	*
+	* @returns
+	*/
+	all() {
+		return { ...this.data };
+	}
+	/**
+	* Add a flash item for the next request
+	*
+	* @param key
+	* @param value
+	* @returns
+	*/
+	flash(key, value) {
+		this.flashBag.put(key, value);
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Get a flash item
+	*
+	* @param key
+	* @param defaultValue
+	* @returns
+	*/
+	getFlash(key, defaultValue) {
+		return this.flashBag.get(key, defaultValue);
+	}
+	/**
+	* Sweep flashed data that was loaded for this request
+	*
+	* @returns
+	*/
+	async sweepFlash() {
+		this.errors.sweep();
+		this.flashBag.sweep();
+		await this.save();
+		return this;
+	}
+	/**
+	* Add an error to the session error bag
+	*
+	* @param field
+	* @param message
+	* @returns
+	*/
+	addError(field, message) {
+		this.errors.add(field, message);
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Add multiple errors to the session error bag
+	*
+	* @param errors
+	* @returns
+	*/
+	addErrors(errors) {
+		this.errors.merge(errors);
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Add a validation error to the session error bag
+	*
+	* @param error
+	* @returns
+	*/
+	addValidationErrors(error) {
+		this.errors.validation(error);
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Check if the session error bag has any errors
+	*
+	* @param field
+	* @returns
+	*/
+	hasErrors(field) {
+		return this.errors.has(field);
+	}
+	/**
+	* Clear all errors in the session error bag
+	*
+	* @param field
+	* @returns
+	*/
+	clearErrors(field) {
+		this.errors.clear(field);
+		this.queuePersist();
+		return this;
+	}
+	/**
+	* Parse session for views
+	*
+	* @returns
+	*/
+	forView() {
+		return {
+			...this.all(),
+			errors: this.errors,
+			flash: this.flashBag
+		};
+	}
+	/**
+	* Return session as json
+	*
+	* @returns
+	*/
+	toJSON() {
+		return {
+			...this.all(),
+			errors: this.errors.toJSON(),
+			flash: this.flashBag.toJSON()
+		};
+	}
+};
+const byteLength = (value) => Buffer.byteLength(value, "utf8");
+const serializeValue = (value) => {
+	if (value === null || typeof value === "undefined") return "N;";
+	if (typeof value === "boolean") return `b:${value ? 1 : 0};`;
+	if (typeof value === "number") return Number.isInteger(value) ? `i:${value};` : `d:${value};`;
+	if (typeof value === "string") return `s:${byteLength(value)}:"${value}";`;
+	if (Array.isArray(value)) return serializeEntries(value.map((item, index) => [index, item]));
+	if (typeof value === "object") return serializeEntries(Object.entries(value));
+	return serializeValue(String(value));
+};
+const serializeEntries = (entries) => {
+	return `a:${entries.length}:{${entries.map(([key, value]) => serializeValue(key) + serializeValue(value)).join("")}}`;
+};
+//#endregion
+export { Request$1 as Request, Response$1 as Response, Session };