routup 4.1.0 → 5.0.0-beta.1

package/dist/src-CpLmo5Po.mjs

@@ -0,0 +1,1602 @@
+import { HTTPError, isHTTPError } from "@ebec/http";
+import { Buffer } from "node:buffer";
+import { subtle } from "uncrypto";
+import { distinctArray, hasOwnProperty, merge } from "smob";
+import { compile } from "proxy-addr";
+import { get, getType } from "mime-explorer";
+import { FastURL } from "srvx";
+import { pathToRegexp } from "path-to-regexp";
+import Negotiator from "negotiator";
+//#region src/constants.ts
+let MethodName = /* @__PURE__ */ function(MethodName) {
+	MethodName["GET"] = "GET";
+	MethodName["POST"] = "POST";
+	MethodName["PUT"] = "PUT";
+	MethodName["PATCH"] = "PATCH";
+	MethodName["DELETE"] = "DELETE";
+	MethodName["OPTIONS"] = "OPTIONS";
+	MethodName["HEAD"] = "HEAD";
+	return MethodName;
+}({});
+let HeaderName = /* @__PURE__ */ function(HeaderName) {
+	HeaderName["ACCEPT"] = "accept";
+	HeaderName["ACCEPT_CHARSET"] = "accept-charset";
+	HeaderName["ACCEPT_ENCODING"] = "accept-encoding";
+	HeaderName["ACCEPT_LANGUAGE"] = "accept-language";
+	HeaderName["ACCEPT_RANGES"] = "accept-ranges";
+	HeaderName["ALLOW"] = "allow";
+	HeaderName["CACHE_CONTROL"] = "cache-control";
+	HeaderName["CONTENT_DISPOSITION"] = "content-disposition";
+	HeaderName["CONTENT_ENCODING"] = "content-encoding";
+	HeaderName["CONTENT_LENGTH"] = "content-length";
+	HeaderName["CONTENT_RANGE"] = "content-range";
+	HeaderName["CONTENT_TYPE"] = "content-type";
+	HeaderName["CONNECTION"] = "connection";
+	HeaderName["COOKIE"] = "cookie";
+	HeaderName["ETag"] = "etag";
+	HeaderName["HOST"] = "host";
+	HeaderName["IF_MODIFIED_SINCE"] = "if-modified-since";
+	HeaderName["IF_NONE_MATCH"] = "if-none-match";
+	HeaderName["LAST_MODIFIED"] = "last-modified";
+	HeaderName["LOCATION"] = "location";
+	HeaderName["RANGE"] = "range";
+	HeaderName["RATE_LIMIT_LIMIT"] = "ratelimit-limit";
+	HeaderName["RATE_LIMIT_REMAINING"] = "ratelimit-remaining";
+	HeaderName["RATE_LIMIT_RESET"] = "ratelimit-reset";
+	HeaderName["RETRY_AFTER"] = "retry-after";
+	HeaderName["SET_COOKIE"] = "set-cookie";
+	HeaderName["TRANSFER_ENCODING"] = "transfer-encoding";
+	HeaderName["X_ACCEL_BUFFERING"] = "x-accel-buffering";
+	HeaderName["X_FORWARDED_HOST"] = "x-forwarded-host";
+	HeaderName["X_FORWARDED_FOR"] = "x-forwarded-for";
+	HeaderName["X_FORWARDED_PROTO"] = "x-forwarded-proto";
+	return HeaderName;
+}({});
+//#endregion
+//#region src/utils/header.ts
+function sanitizeHeaderValue(value) {
+	return value.replace(/[\r\n]/g, "");
+}
+//#endregion
+//#region src/utils/object.ts
+function isObject(item) {
+	return !!item && typeof item === "object" && !Array.isArray(item);
+}
+//#endregion
+//#region src/utils/etag/module.ts
+/**
+* Determine if object is a Stats object.
+*
+* @param {object} obj
+* @return {boolean}
+* @api private
+*/
+function isStatsObject(obj) {
+	return isObject(obj) && "ctime" in obj && Object.prototype.toString.call(obj.ctime) === "[object Date]" && "mtime" in obj && Object.prototype.toString.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
+}
+async function sha1(str) {
+	const enc = new TextEncoder();
+	const hash = await subtle.digest("SHA-1", enc.encode(str));
+	return btoa(String.fromCharCode(...new Uint8Array(hash)));
+}
+/**
+* Generate an ETag.
+*/
+async function generateETag(input) {
+	if (isStatsObject(input)) {
+		const mtime = input.mtime.getTime().toString(16);
+		return `"${input.size.toString(16)}-${mtime}"`;
+	}
+	if (input.length === 0) return "\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"";
+	const entity = Buffer.isBuffer(input) ? input.toString("utf-8") : input;
+	const hash = await sha1(entity);
+	return `"${entity.length.toString(16)}-${hash.substring(0, 27)}"`;
+}
+/**
+* Create a simple ETag.
+*/
+async function createEtag(input, options) {
+	options = options || {};
+	const weak = typeof options.weak === "boolean" ? options.weak : isStatsObject(input);
+	const tag = await generateETag(input);
+	return weak ? `W/${tag}` : tag;
+}
+//#endregion
+//#region src/utils/etag/utils.ts
+function buildEtagFn(input) {
+	if (typeof input === "function") return input;
+	input = input ?? true;
+	if (input === false) return () => Promise.resolve(void 0);
+	let options = { weak: true };
+	if (isObject(input)) options = merge(input, options);
+	return async (body, encoding, size) => {
+		const buff = Buffer.isBuffer(body) ? body : Buffer.from(body, encoding);
+		if (typeof options.threshold !== "undefined") {
+			size = size ?? Buffer.byteLength(buff);
+			if (size <= options.threshold) return;
+		}
+		return createEtag(buff, options);
+	};
+}
+//#endregion
+//#region src/utils/trust-proxy/module.ts
+function buildTrustProxyFn(input) {
+	if (typeof input === "function") return input;
+	if (input === true) return () => true;
+	if (typeof input === "number") return (_address, hop) => hop < input;
+	if (typeof input === "string") input = input.split(",").map((value) => value.trim());
+	return compile(input || []);
+}
+//#endregion
+//#region src/utils/is-instance.ts
+function isInstance(input, sym) {
+	if (!isObject(input)) return false;
+	return input["@instanceof"] === sym;
+}
+//#endregion
+//#region src/utils/mime.ts
+function getMimeType(type) {
+	if (type.includes("/")) return type;
+	return getType(type);
+}
+function getCharsetForMimeType(type) {
+	if (/^text\/|^application\/(javascript|json)/.test(type)) return "utf-8";
+	const meta = get(type);
+	if (meta && meta.charset) return meta.charset.toLowerCase();
+}
+//#endregion
+//#region src/utils/method.ts
+function toMethodName(input, alt) {
+	if (input) return input.toUpperCase();
+	return alt;
+}
+//#endregion
+//#region src/utils/path.ts
+/**
+* Based on https://github.com/unjs/pathe v1.1.1 (055f50a6f1131f4e5c56cf259dd8816168fba329)
+*/
+function normalizeWindowsPath(input = "") {
+	if (!input || !input.includes("\\")) return input;
+	return input.replace(/\\/g, "/");
+}
+const EXTNAME_RE = /.(\.[^./]+)$/;
+function extname(input) {
+	const match = EXTNAME_RE.exec(normalizeWindowsPath(input));
+	return match && match[1] || "";
+}
+function basename(input, extension) {
+	const lastSegment = normalizeWindowsPath(input).split("/").pop();
+	if (!lastSegment) return input;
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+}
+//#endregion
+//#region src/utils/url.ts
+const TRAILING_SLASH_RE = /\/$|\/\?/;
+function hasTrailingSlash(input = "", queryParams = false) {
+	if (!queryParams) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", queryParams = false) {
+	if (!queryParams) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+	if (!hasTrailingSlash(input, true)) return input || "/";
+	const [s0, ...s] = input.split("?");
+	return (s0.slice(0, -1) || "/") + (s.length ? `?${s.join("?")}` : "");
+}
+function hasLeadingSlash(input = "") {
+	return input.startsWith("/");
+}
+function withLeadingSlash(input = "") {
+	return hasLeadingSlash(input) ? input : `/${input}`;
+}
+function cleanDoubleSlashes(input = "") {
+	if (input.includes("://")) return input.split("://").map((str) => cleanDoubleSlashes(str)).join("://");
+	return input.replace(/\/+/g, "/");
+}
+//#endregion
+//#region src/error/is.ts
+function isError(input) {
+	if (!isHTTPError(input)) return false;
+	return input.name === "RoutupError";
+}
+//#endregion
+//#region src/error/module.ts
+var RoutupError = class extends HTTPError {
+	constructor(input = {}) {
+		super(input);
+		this.name = "RoutupError";
+	}
+};
+//#endregion
+//#region src/error/create.ts
+function isNativeError(input) {
+	return isObject(input) && typeof input.message === "string" && typeof input.name === "string";
+}
+/**
+* Create an internal error object by
+* - an existing RoutupError (returned as-is)
+* - an HTTPError (wrapped into a RoutupError preserving status)
+* - an Error (wrapped preserving message and cause)
+* - an options object (statusCode, statusMessage, etc.)
+* - a message string
+*
+* @param input
+*/
+function createError(input) {
+	if (isError(input)) return input;
+	if (typeof input === "string") return new RoutupError(input);
+	if (isHTTPError(input)) return new RoutupError({
+		message: input.message,
+		code: input.code,
+		statusCode: input.statusCode,
+		statusMessage: input.statusMessage,
+		redirectURL: input.redirectURL,
+		cause: input
+	});
+	if (isNativeError(input)) return new RoutupError({
+		message: input.message,
+		cause: input
+	});
+	if (!isObject(input)) return new RoutupError();
+	const options = { ...input };
+	if (options.cause === void 0) options.cause = input;
+	return new RoutupError(options);
+}
+//#endregion
+//#region src/event/module.ts
+var RoutupEvent = class {
+	request;
+	params;
+	path;
+	method;
+	mountPath;
+	error;
+	routerPath;
+	/**
+	* Collected allowed methods (for OPTIONS).
+	*/
+	methodsAllowed;
+	store;
+	_dispatched;
+	_response;
+	/**
+	* Cached parsed URL (avoids double-parsing).
+	*/
+	_url;
+	_searchParams;
+	/**
+	* Continuation function for middleware onion model.
+	*/
+	_next;
+	/**
+	* Whether _next has already been called (guard against double-invocation).
+	*/
+	_nextCalled;
+	/**
+	* The cached result of the next handler.
+	*/
+	_nextResult;
+	constructor(request) {
+		this.request = request;
+		this._url = new FastURL(request.url);
+		this.method = request.method;
+		this.path = this._url.pathname;
+		this.mountPath = "/";
+		this.params = {};
+		this.routerPath = [];
+		this.methodsAllowed = [];
+		this.store = Object.create(null);
+		this._dispatched = false;
+		this._nextCalled = false;
+	}
+	get headers() {
+		return this.request.headers;
+	}
+	get searchParams() {
+		if (!this._searchParams) this._searchParams = new URLSearchParams(this._url.search);
+		return this._searchParams;
+	}
+	get response() {
+		if (!this._response) this._response = {
+			status: 200,
+			headers: new Headers()
+		};
+		return this._response;
+	}
+	get dispatched() {
+		return this._dispatched;
+	}
+	set dispatched(value) {
+		this._dispatched = value;
+	}
+	async next() {
+		if (this._nextCalled) return this._nextResult;
+		this._nextCalled = true;
+		if (this._next) this._nextResult = this._next();
+		return this._nextResult;
+	}
+};
+//#endregion
+//#region src/handler/constants.ts
+let HandlerType = /* @__PURE__ */ function(HandlerType) {
+	HandlerType["CORE"] = "core";
+	HandlerType["ERROR"] = "error";
+	return HandlerType;
+}({});
+const HandlerSymbol = /* @__PURE__ */ Symbol.for("Handler");
+//#endregion
+//#region src/hook/constants.ts
+let HookName = /* @__PURE__ */ function(HookName) {
+	HookName["REQUEST"] = "request";
+	HookName["RESPONSE"] = "response";
+	HookName["ERROR"] = "error";
+	HookName["CHILD_MATCH"] = "childMatch";
+	HookName["CHILD_DISPATCH_BEFORE"] = "childDispatchBefore";
+	HookName["CHILD_DISPATCH_AFTER"] = "childDispatchAfter";
+	return HookName;
+}({});
+//#endregion
+//#region src/hook/module.ts
+var HookManager = class {
+	items;
+	constructor() {
+		this.items = {};
+	}
+	addListener(name, fn) {
+		this.items[name] = this.items[name] || [];
+		this.items[name].push(fn);
+		return () => {
+			this.removeListener(name, fn);
+		};
+	}
+	removeListener(name, fn) {
+		if (!this.items[name]) return;
+		if (typeof fn === "undefined") {
+			delete this.items[name];
+			return;
+		}
+		if (typeof fn === "function") {
+			const index = this.items[name].indexOf(fn);
+			if (index !== -1) this.items[name].splice(index, 1);
+		}
+		if (this.items[name].length === 0) delete this.items[name];
+	}
+	async trigger(name, event) {
+		if (!this.items[name] || this.items[name].length === 0) return;
+		try {
+			for (let i = 0; i < this.items[name].length; i++) {
+				const listener = this.items[name][i];
+				await this.triggerListener(name, event, listener);
+				if (event.dispatched) {
+					if (event.error) event.error = void 0;
+					return;
+				}
+			}
+		} catch (e) {
+			event.error = e;
+			if (!this.isErrorListenerHook(name)) {
+				await this.trigger(HookName.ERROR, event);
+				if (event.dispatched) {
+					if (event.error) event.error = void 0;
+				}
+			}
+		}
+	}
+	triggerListener(name, event, listener) {
+		if (this.isErrorListenerHook(name)) {
+			if (event.error) return listener(event);
+			return;
+		}
+		return listener(event);
+	}
+	isErrorListenerHook(input) {
+		return input === HookName.ERROR;
+	}
+};
+//#endregion
+//#region src/path/matcher.ts
+function decodeParam(val) {
+	/* istanbul ignore next */
+	if (typeof val !== "string" || val.length === 0) return val;
+	try {
+		return decodeURIComponent(val);
+	} catch {
+		return val;
+	}
+}
+var PathMatcher = class {
+	path;
+	regexp;
+	regexpKeys = [];
+	regexpOptions;
+	constructor(path, options) {
+		this.path = path;
+		this.regexpOptions = options || {};
+		const regexp = pathToRegexp(path, options);
+		this.regexp = regexp.regexp;
+		this.regexpKeys = regexp.keys;
+	}
+	test(path) {
+		return this.regexp.test(path);
+	}
+	exec(path) {
+		if (this.path === "/" && this.regexpOptions.end === false) return {
+			path: "/",
+			params: Object.create(null)
+		};
+		const match = this.regexp.exec(path);
+		if (!match) return;
+		const params = Object.create(null);
+		for (let i = 1; i < match.length; i++) {
+			const key = this.regexpKeys[i - 1];
+			if (!key) continue;
+			const prop = key.name;
+			const val = decodeParam(match[i]);
+			if (typeof val !== "undefined") params[prop] = val;
+		}
+		return {
+			path: match[0],
+			params
+		};
+	}
+};
+//#endregion
+//#region src/path/utils.ts
+function isPath(input) {
+	return typeof input === "string";
+}
+//#endregion
+//#region src/response/helpers/cache.ts
+function setResponseCacheHeaders(event, options) {
+	options = options || {};
+	const cacheControls = ["public"].concat(options.cacheControls || []);
+	if (options.maxAge !== void 0) cacheControls.push(`max-age=${+options.maxAge}`, `s-maxage=${+options.maxAge}`);
+	if (options.modifiedTime) {
+		const modifiedTime = typeof options.modifiedTime === "string" ? new Date(options.modifiedTime) : options.modifiedTime;
+		event.response.headers.set("last-modified", modifiedTime.toUTCString());
+	}
+	event.response.headers.set("cache-control", cacheControls.join(", "));
+}
+//#endregion
+//#region src/response/helpers/event-stream/utils.ts
+function stripNewlines(value) {
+	return value.replace(/[\r\n]/g, "");
+}
+function serializeEventStreamMessage(message) {
+	let result = "";
+	if (message.id) result += `id: ${stripNewlines(message.id)}\n`;
+	if (message.event) result += `event: ${stripNewlines(message.event)}\n`;
+	if (typeof message.retry === "number" && Number.isInteger(message.retry)) result += `retry: ${message.retry}\n`;
+	const lines = message.data.replace(/\r/g, "").split("\n");
+	for (const line of lines) result += `data: ${line}\n`;
+	result += "\n";
+	return result;
+}
+//#endregion
+//#region src/response/helpers/event-stream/module.ts
+function createEventStream(event, options) {
+	if (options?.maxMessageSize !== void 0) {
+		if (!Number.isInteger(options.maxMessageSize) || options.maxMessageSize < 0) throw new RoutupError("maxMessageSize must be a non-negative integer.");
+	}
+	let controller;
+	let closed = false;
+	const encoder = new TextEncoder();
+	const stream = new ReadableStream({
+		start(ctrl) {
+			controller = ctrl;
+		},
+		cancel() {
+			closed = true;
+		}
+	});
+	const headers = new Headers(event.response.headers);
+	headers.set(HeaderName.CONTENT_TYPE, "text/event-stream");
+	headers.set(HeaderName.CACHE_CONTROL, "private, no-cache, no-store, no-transform, must-revalidate, max-age=0");
+	headers.set(HeaderName.X_ACCEL_BUFFERING, "no");
+	headers.set(HeaderName.CONNECTION, "keep-alive");
+	const handle = {
+		write(message) {
+			if (closed) return;
+			if (typeof message === "string") {
+				handle.write({ data: message });
+				return;
+			}
+			const serialized = serializeEventStreamMessage(message);
+			if (options?.maxMessageSize !== void 0) {
+				if (encoder.encode(serialized).byteLength > options.maxMessageSize) return;
+			}
+			controller.enqueue(encoder.encode(serialized));
+		},
+		end() {
+			if (closed) return;
+			closed = true;
+			controller.close();
+		},
+		response: new Response(stream, {
+			status: event.response.status,
+			statusText: event.response.statusText,
+			headers
+		})
+	};
+	return handle;
+}
+//#endregion
+//#region src/response/helpers/gone.ts
+function isResponseGone(event) {
+	return event.dispatched;
+}
+function setResponseGone(event) {
+	event.dispatched = true;
+}
+//#endregion
+//#region src/response/helpers/header.ts
+function appendResponseHeader(event, name, value) {
+	const { headers } = event.response;
+	if (Array.isArray(value)) for (const v of value) headers.append(name, sanitizeHeaderValue(v));
+	else headers.append(name, sanitizeHeaderValue(value));
+}
+function appendResponseHeaderDirective(event, name, value) {
+	const { headers } = event.response;
+	const existing = headers.get(name);
+	if (!existing) {
+		if (Array.isArray(value)) headers.set(name, sanitizeHeaderValue(value.join("; ")));
+		else headers.set(name, sanitizeHeaderValue(value));
+		return;
+	}
+	const directives = existing.split("; ");
+	if (Array.isArray(value)) directives.push(...value);
+	else directives.push(value);
+	const unique = [...new Set(directives)];
+	headers.set(name, sanitizeHeaderValue(unique.join("; ")));
+}
+//#endregion
+//#region src/response/helpers/utils.ts
+function setResponseContentTypeByFileName(event, fileName) {
+	const ext = extname(fileName);
+	if (ext) {
+		let type = getMimeType(ext.substring(1));
+		if (type) {
+			const charset = getCharsetForMimeType(type);
+			if (charset) type += `; charset=${charset}`;
+			event.response.headers.set(HeaderName.CONTENT_TYPE, type);
+		}
+	}
+}
+//#endregion
+//#region src/response/helpers/header-attachment.ts
+function sanitizeFilename(filename) {
+	return filename.replace(/[\r\n]/g, "");
+}
+function toAsciiFilename(filename) {
+	return filename.replace(/[^\x20-\x7E]/g, "").replace(/"/g, "\\\"");
+}
+function encodeRfc5987(filename) {
+	return encodeURIComponent(filename).replace(/['()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`).replace(/\*/g, "%2A");
+}
+function setResponseHeaderAttachment(event, filename) {
+	if (typeof filename === "string") setResponseContentTypeByFileName(event, filename);
+	let disposition = "attachment";
+	if (filename) {
+		const sanitized = sanitizeFilename(filename);
+		const ascii = toAsciiFilename(sanitized);
+		disposition += `; filename="${ascii}"`;
+		disposition += `; filename*=UTF-8''${encodeRfc5987(sanitized)}`;
+	}
+	event.response.headers.set(HeaderName.CONTENT_DISPOSITION, disposition);
+}
+//#endregion
+//#region src/response/helpers/header-content-type.ts
+function setResponseHeaderContentType(event, input, ifNotExists) {
+	if (ifNotExists) {
+		if (event.response.headers.get(HeaderName.CONTENT_TYPE)) return;
+	}
+	const contentType = getMimeType(input);
+	if (contentType) event.response.headers.set(HeaderName.CONTENT_TYPE, contentType);
+}
+//#endregion
+//#region src/router-options/module.ts
+const defaults = {
+	trustProxy: () => false,
+	subdomainOffset: 2,
+	etag: buildEtagFn(),
+	proxyIpMax: 0
+};
+const instances = {};
+function setRouterOptions(id, input) {
+	instances[id] = input;
+}
+function findRouterOption(key, path) {
+	if (!path || path.length === 0) return defaults[key];
+	if (path.length > 0) for (let i = path.length; i >= 0; i--) {
+		const segment = path[i];
+		if (segment !== void 0 && hasOwnProperty(instances, segment) && typeof instances[segment][key] !== "undefined") return instances[segment][key];
+	}
+	return defaults[key];
+}
+//#endregion
+//#region src/response/to-response.ts
+function stripWeakPrefix(etag) {
+	return etag.startsWith("W/") ? etag.slice(2) : etag;
+}
+async function applyEtag(body, event, headers) {
+	const etagFn = findRouterOption("etag", event.routerPath);
+	if (!etagFn) return void 0;
+	const etag = await etagFn(body);
+	if (!etag) return void 0;
+	headers.set("etag", etag);
+	const ifNoneMatch = event.headers.get("if-none-match");
+	if (ifNoneMatch && (ifNoneMatch === "*" || ifNoneMatch.split(",").some((t) => stripWeakPrefix(t.trim()) === stripWeakPrefix(etag)))) return new Response(null, {
+		status: 304,
+		headers
+	});
+}
+async function toResponse(value, event) {
+	if (value === void 0) return;
+	if (value === null) return new Response(null, {
+		status: event.response.status,
+		statusText: event.response.statusText,
+		headers: event.response.headers
+	});
+	if (value instanceof Response) return value;
+	const { status, headers, statusText } = event.response;
+	if (typeof value === "string") {
+		if (!headers.has("content-type")) headers.set("content-type", "text/plain; charset=utf-8");
+		const cached = await applyEtag(value, event, headers);
+		if (cached) return cached;
+		return new Response(value, {
+			status,
+			statusText,
+			headers
+		});
+	}
+	if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
+		if (!headers.has("content-type")) headers.set("content-type", "application/octet-stream");
+		return new Response(value, {
+			status,
+			statusText,
+			headers
+		});
+	}
+	if (value instanceof ReadableStream) return new Response(value, {
+		status,
+		statusText,
+		headers
+	});
+	if (value instanceof Blob) {
+		if (!headers.has("content-type")) headers.set("content-type", value.type || "application/octet-stream");
+		return new Response(value, {
+			status,
+			statusText,
+			headers
+		});
+	}
+	if (!headers.has("content-type")) headers.set("content-type", "application/json; charset=utf-8");
+	const json = JSON.stringify(value);
+	const cached = await applyEtag(json, event, headers);
+	if (cached) return cached;
+	return new Response(json, {
+		status,
+		statusText,
+		headers
+	});
+}
+//#endregion
+//#region src/response/helpers/send-accepted.ts
+async function sendAccepted(event, data) {
+	event.response.status = 202;
+	event.response.statusText = "Accepted";
+	event.dispatched = true;
+	return await toResponse(data ?? "", event);
+}
+//#endregion
+//#region src/response/helpers/send-created.ts
+async function sendCreated(event, data) {
+	event.response.status = 201;
+	event.response.statusText = "Created";
+	event.dispatched = true;
+	return await toResponse(data ?? "", event);
+}
+//#endregion
+//#region src/response/helpers/send-file.ts
+async function sendFile(event, options) {
+	const stats = await options.stats();
+	const name = options.name || stats.name;
+	const { headers } = event.response;
+	if (name) {
+		const fileName = basename(name);
+		if (options.attachment) {
+			if (!headers.get(HeaderName.CONTENT_DISPOSITION)) setResponseHeaderAttachment(event, fileName);
+		} else setResponseContentTypeByFileName(event, fileName);
+	}
+	const contentOptions = {};
+	let statusCode = event.response.status;
+	if (stats.size) {
+		const rangeHeader = event.headers.get(HeaderName.RANGE);
+		if (rangeHeader) {
+			const [x, y] = rangeHeader.replace("bytes=", "").split("-");
+			const parsedStart = Number.parseInt(x, 10);
+			const parsedEnd = Number.parseInt(y, 10);
+			contentOptions.start = Number.isFinite(parsedStart) && parsedStart >= 0 ? parsedStart : 0;
+			contentOptions.end = Number.isFinite(parsedEnd) && parsedEnd >= 0 ? Math.min(parsedEnd, stats.size - 1) : stats.size - 1;
+			if (contentOptions.start >= stats.size || contentOptions.start > contentOptions.end) {
+				event.dispatched = true;
+				const rangeHeaders = new Headers(headers);
+				rangeHeaders.set(HeaderName.CONTENT_RANGE, `bytes */${stats.size}`);
+				return new Response(null, {
+					status: 416,
+					statusText: event.response.statusText,
+					headers: rangeHeaders
+				});
+			}
+			headers.set(HeaderName.CONTENT_RANGE, `bytes ${contentOptions.start}-${contentOptions.end}/${stats.size}`);
+			headers.set(HeaderName.CONTENT_LENGTH, `${contentOptions.end - contentOptions.start + 1}`);
+			statusCode = 206;
+		} else headers.set(HeaderName.CONTENT_LENGTH, `${stats.size}`);
+		headers.set(HeaderName.ACCEPT_RANGES, "bytes");
+		if (stats.mtime) {
+			const mtime = new Date(stats.mtime);
+			headers.set(HeaderName.LAST_MODIFIED, mtime.toUTCString());
+			headers.set(HeaderName.ETag, `W/"${stats.size}-${mtime.getTime()}"`);
+		}
+	}
+	const content = await options.content(contentOptions);
+	event.dispatched = true;
+	return new Response(content, {
+		status: statusCode,
+		statusText: event.response.statusText,
+		headers
+	});
+}
+//#endregion
+//#region src/request/helpers/header.ts
+function getRequestHeader(event, name) {
+	return event.headers.get(name);
+}
+//#endregion
+//#region src/request/helpers/negotiator.ts
+const NEGOTIATOR_KEY = /* @__PURE__ */ Symbol.for("routup:negotiator");
+function headersToPlainObject(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+}
+function useRequestNegotiator(event) {
+	let value = event.store[NEGOTIATOR_KEY];
+	if (value) return value;
+	value = new Negotiator({ headers: headersToPlainObject(event.headers) });
+	event.store[NEGOTIATOR_KEY] = value;
+	return value;
+}
+//#endregion
+//#region src/request/helpers/header-accept.ts
+function getRequestAcceptableContentTypes(event) {
+	return useRequestNegotiator(event).mediaTypes();
+}
+function getRequestAcceptableContentType(event, input) {
+	input = input || [];
+	const items = Array.isArray(input) ? input : [input];
+	if (items.length === 0) return getRequestAcceptableContentTypes(event).shift();
+	if (!getRequestHeader(event, HeaderName.ACCEPT)) return items[0];
+	let polluted = false;
+	const mimeTypes = [];
+	for (const item of items) {
+		const mimeType = getMimeType(item);
+		if (mimeType) mimeTypes.push(mimeType);
+		else polluted = true;
+	}
+	const matches = useRequestNegotiator(event).mediaTypes(mimeTypes);
+	if (matches.length > 0) {
+		if (polluted) return items[0];
+		return items[mimeTypes.indexOf(matches[0])];
+	}
+}
+//#endregion
+//#region src/response/helpers/send-format.ts
+function sendFormat(event, input) {
+	const { default: formatDefault, ...formats } = input;
+	const contentTypes = Object.keys(formats);
+	if (contentTypes.length === 0) return formatDefault();
+	const contentType = getRequestAcceptableContentType(event, contentTypes);
+	if (contentType && formats[contentType]) return formats[contentType]();
+	return formatDefault();
+}
+//#endregion
+//#region src/response/helpers/send-redirect.ts
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function isAllowedRedirectUrl(location) {
+	if (location.startsWith("//")) return false;
+	if (location.startsWith("/") || location.startsWith(".")) return true;
+	try {
+		const url = new URL(location);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return true;
+	}
+}
+function sendRedirect(event, location, statusCode = 302) {
+	if (!isAllowedRedirectUrl(location)) throw new RoutupError({
+		statusCode: 400,
+		statusMessage: "Invalid redirect URL scheme."
+	});
+	const sanitizedLocation = sanitizeHeaderValue(location);
+	const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${escapeHtml(location)}"></head></html>`;
+	const headers = new Headers(event.response.headers);
+	headers.set("location", sanitizedLocation);
+	headers.set("content-type", "text/html; charset=utf-8");
+	headers.delete("content-length");
+	const response = new Response(html, {
+		status: statusCode,
+		statusText: event.response.statusText,
+		headers
+	});
+	event.dispatched = true;
+	return response;
+}
+//#endregion
+//#region src/response/helpers/send-stream.ts
+function sendStream(event, stream) {
+	event.dispatched = true;
+	const { status, statusText, headers } = event.response;
+	return new Response(stream, {
+		status,
+		statusText,
+		headers
+	});
+}
+//#endregion
+//#region src/handler/module.ts
+var Handler = class {
+	"@instanceof" = HandlerSymbol;
+	config;
+	hookManager;
+	pathMatcher;
+	_method;
+	constructor(handler) {
+		this.config = handler;
+		this.hookManager = new HookManager();
+		this.mountHooks();
+		this.setPath(handler.path);
+	}
+	get type() {
+		return this.config.type;
+	}
+	get path() {
+		return this.config.path;
+	}
+	get method() {
+		if (this._method || !this.config.method) return this._method;
+		this._method = toMethodName(this.config.method);
+		return this._method;
+	}
+	async dispatch(event) {
+		if (this.pathMatcher) {
+			const pathMatch = this.pathMatcher.exec(event.path);
+			if (pathMatch) event.params = {
+				...event.params,
+				...pathMatch.params
+			};
+		}
+		await this.hookManager.trigger(HookName.CHILD_DISPATCH_BEFORE, event);
+		if (event.dispatched) return;
+		let response;
+		try {
+			let result;
+			if (this.config.type === HandlerType.ERROR) {
+				if (event.error) result = await this.config.fn(event.error, event);
+			} else result = await this.config.fn(event);
+			response = await toResponse(result, event);
+			if (response) event.dispatched = true;
+		} catch (e) {
+			event.error = isError(e) ? e : createError(e);
+			await this.hookManager.trigger(HookName.ERROR, event);
+			if (event.dispatched) event.error = void 0;
+			else throw event.error;
+		}
+		await this.hookManager.trigger(HookName.CHILD_DISPATCH_AFTER, event);
+		return response;
+	}
+	matchPath(path) {
+		if (!this.pathMatcher) return true;
+		return this.pathMatcher.test(path);
+	}
+	setPath(path) {
+		if (typeof path === "string") path = withLeadingSlash(path);
+		this.config.path = path;
+		if (typeof path === "undefined") {
+			this.pathMatcher = void 0;
+			return;
+		}
+		this.pathMatcher = new PathMatcher(path, { end: !!this.config.method });
+	}
+	matchMethod(method) {
+		return !this.method || method === this.method || method === MethodName.HEAD && this.method === MethodName.GET;
+	}
+	setMethod(input) {
+		const method = toMethodName(input);
+		this.config.method = method;
+		this._method = method;
+	}
+	mountHooks() {
+		if (this.config.onBefore) this.hookManager.addListener(HookName.CHILD_DISPATCH_BEFORE, this.config.onBefore);
+		if (this.config.onAfter) this.hookManager.addListener(HookName.CHILD_DISPATCH_AFTER, this.config.onAfter);
+		if (this.config.onError) this.hookManager.addListener(HookName.ERROR, this.config.onError);
+	}
+};
+//#endregion
+//#region src/handler/core/define.ts
+function defineCoreHandler(input) {
+	if (typeof input === "function") return new Handler({
+		type: HandlerType.CORE,
+		fn: input
+	});
+	return new Handler({
+		type: HandlerType.CORE,
+		...input
+	});
+}
+//#endregion
+//#region src/handler/error/define.ts
+function defineErrorHandler(input) {
+	if (typeof input === "function") return new Handler({
+		type: HandlerType.ERROR,
+		fn: input
+	});
+	return new Handler({
+		type: HandlerType.ERROR,
+		...input
+	});
+}
+//#endregion
+//#region src/handler/adapters/node/define.ts
+const kHandled = /* @__PURE__ */ Symbol("handled");
+function callHandler(handler, req, res) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const onClose = () => settle(kHandled);
+		const onFinish = () => settle(kHandled);
+		const onError = (error) => fail(error);
+		function cleanup() {
+			res.removeListener("close", onClose);
+			res.removeListener("finish", onFinish);
+			res.removeListener("error", onError);
+		}
+		function settle(value) {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		}
+		function fail(error) {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		}
+		res.once("close", onClose);
+		res.once("finish", onFinish);
+		res.once("error", onError);
+		try {
+			Promise.resolve(handler(req, res)).then(() => settle(kHandled)).catch(fail);
+		} catch (error) {
+			fail(error);
+		}
+	});
+}
+function callMiddleware(handler, req, res) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const onClose = () => settle(kHandled);
+		const onFinish = () => settle(kHandled);
+		const onError = (error) => fail(error);
+		function cleanup() {
+			res.removeListener("close", onClose);
+			res.removeListener("finish", onFinish);
+			res.removeListener("error", onError);
+		}
+		function settle(value) {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		}
+		function fail(error) {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		}
+		res.once("close", onClose);
+		res.once("finish", onFinish);
+		res.once("error", onError);
+		try {
+			Promise.resolve(handler(req, res, (error) => {
+				if (error) fail(error);
+				else settle(res.writableEnded || res.destroyed ? kHandled : void 0);
+			})).catch(fail);
+		} catch (error) {
+			fail(error);
+		}
+	});
+}
+function createNodeBridge(handler, isMiddleware) {
+	if (typeof handler !== "function") throw new RoutupError("fromNodeHandler/fromNodeMiddleware expects a function.");
+	return defineCoreHandler({ fn: (async (event) => {
+		const node = event.request.runtime?.node;
+		if (!node?.req || !node?.res) throw new RoutupError("fromNodeHandler/fromNodeMiddleware requires a Node.js runtime.");
+		const req = node.req;
+		const res = node.res;
+		if ((isMiddleware ? await callMiddleware(handler, req, res) : await callHandler(handler, req, res)) === kHandled) event.dispatched = true;
+	}) });
+}
+/**
+* Wraps a Node.js `(req, res)` handler for use in the routup pipeline.
+*
+* @example
+* ```typescript
+* import { fromNodeHandler } from 'routup/node';
+*
+* router.use(fromNodeHandler((req, res) => {
+*     res.end('Hello');
+* }));
+* ```
+*/
+function fromNodeHandler(handler) {
+	return createNodeBridge(handler, false);
+}
+/**
+* Wraps a Node.js `(req, res, next)` middleware for use in the routup pipeline.
+*
+* @example
+* ```typescript
+* import cors from 'cors';
+* import { fromNodeMiddleware } from 'routup/node';
+*
+* router.use(fromNodeMiddleware(cors()));
+* ```
+*/
+function fromNodeMiddleware(handler) {
+	return createNodeBridge(handler, true);
+}
+//#endregion
+//#region src/handler/adapters/web/is.ts
+function isWebHandlerProvider(input) {
+	return isObject(input) && typeof input.fetch === "function";
+}
+function isWebHandler(input) {
+	return typeof input === "function";
+}
+//#endregion
+//#region src/handler/adapters/web/define.ts
+function fromWebHandler(input) {
+	if (isWebHandlerProvider(input)) return fromWebHandler(input.fetch.bind(input));
+	if (typeof input !== "function") throw new RoutupError("fromWebHandler expects a function or an object with a fetch method.");
+	return defineCoreHandler({ fn: (event) => input(event.request) });
+}
+//#endregion
+//#region src/handler/is.ts
+function isHandlerOptions(input) {
+	return isObject(input) && typeof input.fn === "function" && typeof input.type === "string";
+}
+function isHandler(input) {
+	return isInstance(input, HandlerSymbol);
+}
+//#endregion
+//#region src/request/helpers/body.ts
+const BODY_KEY = /* @__PURE__ */ Symbol.for("routup:body");
+/**
+* Read and parse the request body.
+*
+* - `application/x-www-form-urlencoded` → plain object (duplicate keys become arrays)
+* - `application/json` or other → attempts JSON parse, returns undefined on failure
+*
+* The result is cached on the event store — calling `readBody()` multiple
+* times returns the same parsed result.
+*
+* For binary or streaming access, use `event.request.arrayBuffer()`,
+* `event.request.blob()`, or `event.request.body` directly.
+*
+* @experimental
+*/
+async function readBody(event) {
+	if (BODY_KEY in event.store) return event.store[BODY_KEY];
+	const text = await event.request.text();
+	let result;
+	if ((event.headers.get("content-type") || "").includes("application/x-www-form-urlencoded")) result = parseURLEncodedBody(text);
+	else try {
+		result = JSON.parse(text);
+	} catch {
+		result = void 0;
+	}
+	event.store[BODY_KEY] = result;
+	return result;
+}
+function parseURLEncodedBody(body) {
+	const form = new URLSearchParams(body);
+	const parsed = Object.create(null);
+	for (const [key, value] of form.entries()) {
+		const existing = parsed[key];
+		if (existing !== void 0) if (Array.isArray(existing)) existing.push(value);
+		else parsed[key] = [existing, value];
+		else parsed[key] = value;
+	}
+	return parsed;
+}
+//#endregion
+//#region src/request/helpers/cache.ts
+function isRequestCacheable(event, modifiedTime) {
+	const modifiedSince = event.headers.get(HeaderName.IF_MODIFIED_SINCE);
+	if (!modifiedSince) return false;
+	modifiedTime = typeof modifiedTime === "string" ? new Date(modifiedTime) : modifiedTime;
+	const sinceDate = new Date(modifiedSince);
+	if (Number.isNaN(sinceDate.getTime()) || Number.isNaN(modifiedTime.getTime())) return false;
+	return sinceDate >= modifiedTime;
+}
+//#endregion
+//#region src/request/helpers/header-accept-charset.ts
+function getRequestAcceptableCharsets(event) {
+	return useRequestNegotiator(event).charsets();
+}
+function getRequestAcceptableCharset(event, input) {
+	input = input || [];
+	const items = Array.isArray(input) ? input : [input];
+	if (items.length === 0) return getRequestAcceptableCharsets(event).shift();
+	return useRequestNegotiator(event).charsets(items).shift() || void 0;
+}
+//#endregion
+//#region src/request/helpers/header-accept-encoding.ts
+function getRequestAcceptableEncodings(event) {
+	return useRequestNegotiator(event).encodings();
+}
+function getRequestAcceptableEncoding(event, input) {
+	input = input || [];
+	const items = Array.isArray(input) ? input : [input];
+	if (items.length === 0) return getRequestAcceptableEncodings(event).shift();
+	return useRequestNegotiator(event).encodings(items).shift() || void 0;
+}
+//#endregion
+//#region src/request/helpers/header-accept-language.ts
+function getRequestAcceptableLanguages(event) {
+	return useRequestNegotiator(event).languages();
+}
+function getRequestAcceptableLanguage(event, input) {
+	input = input || [];
+	const items = Array.isArray(input) ? input : [input];
+	if (items.length === 0) return getRequestAcceptableLanguages(event).shift();
+	return useRequestNegotiator(event).languages(items).shift() || void 0;
+}
+//#endregion
+//#region src/request/helpers/header-content-type.ts
+function matchRequestContentType(event, contentType) {
+	const header = getRequestHeader(event, HeaderName.CONTENT_TYPE);
+	if (!header) return true;
+	return header.split(";")[0].trim() === getMimeType(contentType);
+}
+//#endregion
+//#region src/request/helpers/hostname.ts
+function getRequestHostName(event, options = {}) {
+	let trustProxy;
+	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
+	else trustProxy = findRouterOption("trustProxy", event.routerPath);
+	let hostname = event.headers.get(HeaderName.X_FORWARDED_HOST);
+	if (!hostname || !event.request.ip || !trustProxy(event.request.ip, 0)) hostname = event.headers.get(HeaderName.HOST);
+	else if (hostname && hostname.includes(",")) hostname = hostname.substring(0, hostname.indexOf(",")).trimEnd();
+	if (!hostname) return;
+	const offset = hostname[0] === "[" ? hostname.indexOf("]") + 1 : 0;
+	const index = hostname.indexOf(":", offset);
+	const result = index !== -1 ? hostname.substring(0, index) : hostname;
+	if (/[\x00-\x1F\x7F\s/@\\]/.test(result)) return;
+	return result;
+}
+//#endregion
+//#region src/request/helpers/ip.ts
+function getRequestIP(event, options = {}) {
+	if (options.trustProxy) {
+		const forwarded = event.headers.get(HeaderName.X_FORWARDED_FOR);
+		if (forwarded) {
+			const first = forwarded.split(",")[0];
+			if (first) return first.trim();
+		}
+	}
+	const request = event.request;
+	if (request.ip) return request.ip;
+}
+//#endregion
+//#region src/request/helpers/protocol.ts
+function getRequestProtocol(event, options = {}) {
+	let trustProxy;
+	if (typeof options.trustProxy !== "undefined") trustProxy = buildTrustProxyFn(options.trustProxy);
+	else trustProxy = findRouterOption("trustProxy", event.routerPath);
+	let protocol;
+	try {
+		if (new URL(event.request.url).protocol === "https:") protocol = "https";
+		else protocol = "http";
+	} catch {
+		protocol = options.default || "http";
+	}
+	if (!event.request.ip || !trustProxy(event.request.ip, 0)) return protocol;
+	const header = event.headers.get(HeaderName.X_FORWARDED_PROTO);
+	if (!header) return protocol;
+	const index = header.indexOf(",");
+	const forwarded = index !== -1 ? header.substring(0, index).trim().toLowerCase() : header.trim().toLowerCase();
+	if (forwarded === "http" || forwarded === "https") return forwarded;
+	return protocol;
+}
+//#endregion
+//#region src/plugin/is.ts
+function isPlugin(input) {
+	if (!isObject(input)) return false;
+	if (typeof input.name !== "undefined" && typeof input.name !== "string") return false;
+	return typeof input.install === "function" && input.install.length === 1;
+}
+//#endregion
+//#region src/router-options/normalize.ts
+function normalizeRouterOptions(input) {
+	if (typeof input.etag !== "undefined") input.etag = buildEtagFn(input.etag);
+	if (typeof input.trustProxy !== "undefined") input.trustProxy = buildTrustProxyFn(input.trustProxy);
+	return input;
+}
+//#endregion
+//#region src/router/constants.ts
+const RouterSymbol = /* @__PURE__ */ Symbol.for("Router");
+let RouterPipelineStep = /* @__PURE__ */ function(RouterPipelineStep) {
+	RouterPipelineStep[RouterPipelineStep["START"] = 0] = "START";
+	RouterPipelineStep[RouterPipelineStep["LOOKUP"] = 1] = "LOOKUP";
+	RouterPipelineStep[RouterPipelineStep["CHILD_BEFORE"] = 2] = "CHILD_BEFORE";
+	RouterPipelineStep[RouterPipelineStep["CHILD_DISPATCH"] = 3] = "CHILD_DISPATCH";
+	RouterPipelineStep[RouterPipelineStep["CHILD_AFTER"] = 4] = "CHILD_AFTER";
+	RouterPipelineStep[RouterPipelineStep["FINISH"] = 5] = "FINISH";
+	return RouterPipelineStep;
+}({});
+//#endregion
+//#region src/router/utils.ts
+let nextId = 0;
+function generateRouterID() {
+	return ++nextId;
+}
+function isRouterInstance(input) {
+	return isInstance(input, RouterSymbol);
+}
+/**
+* Check if the request accepts JSON responses.
+* Matches application/json and +json suffixes (e.g. application/vnd.api+json).
+* Returns true if no Accept header is present (API-first default).
+*/
+function acceptsJson(request) {
+	const accept = request.headers.get("accept");
+	if (!accept) return true;
+	return accept.includes("application/json") || accept.includes("+json") || accept.includes("*/*");
+}
+//#endregion
+//#region src/router/module.ts
+var Router = class Router {
+	"@instanceof" = RouterSymbol;
+	/**
+	* An identifier for the router instance.
+	*/
+	id;
+	/**
+	* A label for the router instance.
+	*/
+	name;
+	/**
+	* Array of mounted layers, routes & routers.
+	*
+	* @protected
+	*/
+	stack = [];
+	/**
+	* Path matcher for the current mount path.
+	*
+	* @protected
+	*/
+	pathMatcher;
+	/**
+	* A hook manager.
+	*
+	* @protected
+	*/
+	hookManager;
+	constructor(options = {}) {
+		this.id = generateRouterID();
+		this.name = options.name;
+		this.hookManager = new HookManager();
+		this.setPath(options.path);
+		setRouterOptions(this.id, normalizeRouterOptions(options));
+	}
+	matchPath(path) {
+		if (this.pathMatcher) return this.pathMatcher.test(path);
+		return true;
+	}
+	setPath(value) {
+		if (value === "/" || typeof value === "undefined") {
+			this.pathMatcher = void 0;
+			return;
+		}
+		this.pathMatcher = new PathMatcher(withLeadingSlash(withoutTrailingSlash(`${value}`)), { end: false });
+	}
+	/**
+	* Public entry point — creates a RoutupEvent from the request,
+	* runs the pipeline, and returns a Response (with 404/500 fallbacks).
+	*/
+	async fetch(request) {
+		const event = new RoutupEvent(request);
+		let response;
+		try {
+			response = await this.dispatch(event);
+		} catch (e) {
+			event.error = createError(e);
+		}
+		if (response) return response;
+		if (event.error) {
+			const status = event.error.statusCode || 500;
+			const message = event.error.statusMessage || "Internal Server Error";
+			return this.buildFallbackResponse(request, event, status, message);
+		}
+		return this.buildFallbackResponse(request, event, 404, "Not Found");
+	}
+	buildFallbackResponse(request, event, status, message) {
+		const headers = new Headers(event.response.headers);
+		if (acceptsJson(request)) {
+			headers.set("content-type", "application/json; charset=utf-8");
+			return new Response(JSON.stringify({
+				status,
+				message
+			}), {
+				status,
+				statusText: message,
+				headers
+			});
+		}
+		headers.set("content-type", "text/plain; charset=utf-8");
+		return new Response(message, {
+			status,
+			statusText: message,
+			headers
+		});
+	}
+	async executePipelineStep(context) {
+		switch (context.step) {
+			case RouterPipelineStep.START: return this.executePipelineStepStart(context);
+			case RouterPipelineStep.LOOKUP: return this.executePipelineStepLookup(context);
+			case RouterPipelineStep.CHILD_BEFORE: return this.executePipelineStepChildBefore(context);
+			case RouterPipelineStep.CHILD_DISPATCH: return this.executePipelineStepChildDispatch(context);
+			case RouterPipelineStep.CHILD_AFTER: return this.executePipelineStepChildAfter(context);
+			case RouterPipelineStep.FINISH:
+			default: return this.executePipelineStepFinish(context);
+		}
+	}
+	async executePipelineStepStart(context) {
+		await this.hookManager.trigger(HookName.REQUEST, context.event);
+		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
+		else context.step = RouterPipelineStep.LOOKUP;
+		return this.executePipelineStep(context);
+	}
+	async executePipelineStepLookup(context) {
+		while (!context.event.dispatched && context.stackIndex < this.stack.length) {
+			const item = this.stack[context.stackIndex];
+			if (isHandler(item)) {
+				if (context.event.error && item.type === HandlerType.CORE || !context.event.error && item.type === HandlerType.ERROR) {
+					context.stackIndex++;
+					continue;
+				}
+				if (item.matchPath(context.event.path)) {
+					if (item.method) context.event.methodsAllowed.push(item.method);
+					if (item.matchMethod(context.event.method)) {
+						await this.hookManager.trigger(HookName.CHILD_MATCH, context.event);
+						if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
+						else context.step = RouterPipelineStep.CHILD_BEFORE;
+						return this.executePipelineStep(context);
+					}
+				}
+				context.stackIndex++;
+				continue;
+			}
+			if (item.matchPath(context.event.path)) {
+				await this.hookManager.trigger(HookName.CHILD_MATCH, context.event);
+				if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
+				else context.step = RouterPipelineStep.CHILD_BEFORE;
+				return this.executePipelineStep(context);
+			}
+			context.stackIndex++;
+		}
+		context.step = RouterPipelineStep.FINISH;
+		return this.executePipelineStep(context);
+	}
+	async executePipelineStepChildBefore(context) {
+		await this.hookManager.trigger(HookName.CHILD_DISPATCH_BEFORE, context.event);
+		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
+		else context.step = RouterPipelineStep.CHILD_DISPATCH;
+		return this.executePipelineStep(context);
+	}
+	async executePipelineStepChildAfter(context) {
+		await this.hookManager.trigger(HookName.CHILD_DISPATCH_AFTER, context.event);
+		if (context.event.dispatched) context.step = RouterPipelineStep.FINISH;
+		else context.step = RouterPipelineStep.LOOKUP;
+		return this.executePipelineStep(context);
+	}
+	async executePipelineStepChildDispatch(context) {
+		if (context.event.dispatched || typeof this.stack[context.stackIndex] === "undefined") {
+			context.step = RouterPipelineStep.FINISH;
+			return this.executePipelineStep(context);
+		}
+		const item = this.stack[context.stackIndex];
+		const { event } = context;
+		const savedNext = event._next;
+		const savedNextCalled = event._nextCalled;
+		try {
+			event._nextCalled = false;
+			event._next = async () => {
+				const nextContext = {
+					step: RouterPipelineStep.LOOKUP,
+					event,
+					stackIndex: context.stackIndex + 1,
+					response: void 0
+				};
+				event.routerPath.push(this.id);
+				try {
+					await this.executePipelineStep(nextContext);
+				} finally {
+					event.routerPath.pop();
+				}
+				return nextContext.response;
+			};
+			const response = await item.dispatch(event);
+			if (response) {
+				context.response = response;
+				event.dispatched = true;
+			}
+		} catch (e) {
+			event.error = createError(e);
+			await this.hookManager.trigger(HookName.ERROR, event);
+		} finally {
+			event._next = savedNext;
+			event._nextCalled = savedNextCalled;
+		}
+		context.stackIndex++;
+		context.step = RouterPipelineStep.CHILD_AFTER;
+		return this.executePipelineStep(context);
+	}
+	async executePipelineStepFinish(context) {
+		if (context.event.error || context.event.dispatched) return this.hookManager.trigger(HookName.RESPONSE, context.event);
+		if (!context.event.dispatched && context.event.routerPath.length === 1 && context.event.method && context.event.method === MethodName.OPTIONS) {
+			if (context.event.methodsAllowed.includes(MethodName.GET)) context.event.methodsAllowed.push(MethodName.HEAD);
+			distinctArray(context.event.methodsAllowed);
+			const options = context.event.methodsAllowed.map((key) => key.toUpperCase()).join(",");
+			const optionsHeaders = new Headers(context.event.response.headers);
+			optionsHeaders.set(HeaderName.ALLOW, options);
+			context.response = new Response(options, {
+				status: context.event.response.status || 200,
+				statusText: context.event.response.statusText,
+				headers: optionsHeaders
+			});
+			context.event.dispatched = true;
+		}
+		return this.hookManager.trigger(HookName.RESPONSE, context.event);
+	}
+	async dispatch(event) {
+		if (this.pathMatcher) {
+			const output = this.pathMatcher.exec(event.path);
+			if (typeof output !== "undefined") {
+				event.mountPath = cleanDoubleSlashes(`${event.mountPath}/${output.path}`);
+				if (event.path === output.path) event.path = "/";
+				else event.path = withLeadingSlash(event.path.substring(output.path.length));
+				event.params = {
+					...event.params,
+					...output.params
+				};
+			}
+		}
+		const context = {
+			step: RouterPipelineStep.START,
+			event,
+			stackIndex: 0
+		};
+		event.routerPath.push(this.id);
+		try {
+			await this.executePipelineStep(context);
+		} finally {
+			event.routerPath.pop();
+		}
+		return context.response;
+	}
+	delete(...input) {
+		this.useForMethod(MethodName.DELETE, ...input);
+		return this;
+	}
+	get(...input) {
+		this.useForMethod(MethodName.GET, ...input);
+		return this;
+	}
+	post(...input) {
+		this.useForMethod(MethodName.POST, ...input);
+		return this;
+	}
+	put(...input) {
+		this.useForMethod(MethodName.PUT, ...input);
+		return this;
+	}
+	patch(...input) {
+		this.useForMethod(MethodName.PATCH, ...input);
+		return this;
+	}
+	head(...input) {
+		this.useForMethod(MethodName.HEAD, ...input);
+		return this;
+	}
+	options(...input) {
+		this.useForMethod(MethodName.OPTIONS, ...input);
+		return this;
+	}
+	useForMethod(method, ...input) {
+		let path;
+		for (const element of input) {
+			if (isPath(element)) {
+				path = element;
+				continue;
+			}
+			if (isHandlerOptions(element)) {
+				if (path) element.path = path;
+				element.method = method;
+				this.use(element);
+				continue;
+			}
+			if (isHandler(element)) {
+				if (path) element.setPath(path);
+				element.setMethod(method);
+				this.use(element);
+			}
+		}
+	}
+	use(...input) {
+		let path;
+		for (const item of input) {
+			if (isPath(item)) {
+				path = withLeadingSlash(item);
+				continue;
+			}
+			if (isRouterInstance(item)) {
+				if (path) item.setPath(path);
+				this.stack.push(item);
+				continue;
+			}
+			if (isHandlerOptions(item)) {
+				item.path = path || item.path;
+				this.stack.push(new Handler(item));
+				continue;
+			}
+			if (isHandler(item)) {
+				item.setPath(path || item.path);
+				this.stack.push(item);
+				continue;
+			}
+			if (isPlugin(item)) if (path) this.install(item, { path });
+			else this.install(item);
+		}
+		return this;
+	}
+	install(plugin, context = {}) {
+		const router = new Router({ name: context.name || plugin.name });
+		plugin.install(router);
+		if (context.path) this.use(context.path, router);
+		else this.use(router);
+		return this;
+	}
+	on(name, fn) {
+		return this.hookManager.addListener(name, fn);
+	}
+	off(name, fn) {
+		if (typeof fn === "undefined") {
+			this.hookManager.removeListener(name);
+			return this;
+		}
+		this.hookManager.removeListener(name, fn);
+		return this;
+	}
+};
+//#endregion
+export { isError as $, useRequestNegotiator as A, appendResponseHeaderDirective as B, defineCoreHandler as C, sendFormat as D, sendRedirect as E, toResponse as F, setResponseCacheHeaders as G, setResponseGone as H, setResponseHeaderContentType as I, HandlerSymbol as J, isPath as K, setResponseHeaderAttachment as L, sendFile as M, sendCreated as N, getRequestAcceptableContentType as O, sendAccepted as P, RoutupError as Q, setResponseContentTypeByFileName as R, defineErrorHandler as S, sendStream as T, createEventStream as U, isResponseGone as V, serializeEventStreamMessage as W, RoutupEvent as X, HandlerType as Y, createError as Z, fromWebHandler as _, getRequestHostName as a, fromNodeHandler as b, getRequestAcceptableLanguages as c, getRequestAcceptableCharset as d, HeaderName as et, getRequestAcceptableCharsets as f, isHandlerOptions as g, isHandler as h, getRequestIP as i, getRequestHeader as j, getRequestAcceptableContentTypes as k, getRequestAcceptableEncoding as l, readBody as m, isPlugin as n, matchRequestContentType as o, isRequestCacheable as p, PathMatcher as q, getRequestProtocol as r, getRequestAcceptableLanguage as s, Router as t, MethodName as tt, getRequestAcceptableEncodings as u, isWebHandler as v, Handler as w, fromNodeMiddleware as x, isWebHandlerProvider as y, appendResponseHeader as z };
+
+//# sourceMappingURL=src-CpLmo5Po.mjs.map