routup 4.1.0 → 5.0.0-beta.1

package/dist/src-D_4IPMmD.cjs

@@ -0,0 +1,1960 @@
+//#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 __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 ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _ebec_http = require("@ebec/http");
+let node_buffer = require("node:buffer");
+let uncrypto = require("uncrypto");
+let smob = require("smob");
+let proxy_addr = require("proxy-addr");
+let mime_explorer = require("mime-explorer");
+let srvx = require("srvx");
+let path_to_regexp = require("path-to-regexp");
+let negotiator = require("negotiator");
+negotiator = __toESM(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 uncrypto.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 = node_buffer.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 = (0, smob.merge)(input, options);
+	return async (body, encoding, size) => {
+		const buff = node_buffer.Buffer.isBuffer(body) ? body : node_buffer.Buffer.from(body, encoding);
+		if (typeof options.threshold !== "undefined") {
+			size = size ?? node_buffer.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 (0, proxy_addr.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 (0, mime_explorer.getType)(type);
+}
+function getCharsetForMimeType(type) {
+	if (/^text\/|^application\/(javascript|json)/.test(type)) return "utf-8";
+	const meta = (0, mime_explorer.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 (!(0, _ebec_http.isHTTPError)(input)) return false;
+	return input.name === "RoutupError";
+}
+//#endregion
+//#region src/error/module.ts
+var RoutupError = class extends _ebec_http.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 ((0, _ebec_http.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 srvx.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 = (0, path_to_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 && (0, smob.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.default({ 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);
+			(0, smob.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
+Object.defineProperty(exports, "Handler", {
+	enumerable: true,
+	get: function() {
+		return Handler;
+	}
+});
+Object.defineProperty(exports, "HandlerSymbol", {
+	enumerable: true,
+	get: function() {
+		return HandlerSymbol;
+	}
+});
+Object.defineProperty(exports, "HandlerType", {
+	enumerable: true,
+	get: function() {
+		return HandlerType;
+	}
+});
+Object.defineProperty(exports, "HeaderName", {
+	enumerable: true,
+	get: function() {
+		return HeaderName;
+	}
+});
+Object.defineProperty(exports, "MethodName", {
+	enumerable: true,
+	get: function() {
+		return MethodName;
+	}
+});
+Object.defineProperty(exports, "PathMatcher", {
+	enumerable: true,
+	get: function() {
+		return PathMatcher;
+	}
+});
+Object.defineProperty(exports, "Router", {
+	enumerable: true,
+	get: function() {
+		return Router;
+	}
+});
+Object.defineProperty(exports, "RoutupError", {
+	enumerable: true,
+	get: function() {
+		return RoutupError;
+	}
+});
+Object.defineProperty(exports, "RoutupEvent", {
+	enumerable: true,
+	get: function() {
+		return RoutupEvent;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "appendResponseHeader", {
+	enumerable: true,
+	get: function() {
+		return appendResponseHeader;
+	}
+});
+Object.defineProperty(exports, "appendResponseHeaderDirective", {
+	enumerable: true,
+	get: function() {
+		return appendResponseHeaderDirective;
+	}
+});
+Object.defineProperty(exports, "createError", {
+	enumerable: true,
+	get: function() {
+		return createError;
+	}
+});
+Object.defineProperty(exports, "createEventStream", {
+	enumerable: true,
+	get: function() {
+		return createEventStream;
+	}
+});
+Object.defineProperty(exports, "defineCoreHandler", {
+	enumerable: true,
+	get: function() {
+		return defineCoreHandler;
+	}
+});
+Object.defineProperty(exports, "defineErrorHandler", {
+	enumerable: true,
+	get: function() {
+		return defineErrorHandler;
+	}
+});
+Object.defineProperty(exports, "fromNodeHandler", {
+	enumerable: true,
+	get: function() {
+		return fromNodeHandler;
+	}
+});
+Object.defineProperty(exports, "fromNodeMiddleware", {
+	enumerable: true,
+	get: function() {
+		return fromNodeMiddleware;
+	}
+});
+Object.defineProperty(exports, "fromWebHandler", {
+	enumerable: true,
+	get: function() {
+		return fromWebHandler;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableCharset", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableCharset;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableCharsets", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableCharsets;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableContentType", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableContentType;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableContentTypes", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableContentTypes;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableEncoding", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableEncoding;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableEncodings", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableEncodings;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableLanguage", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableLanguage;
+	}
+});
+Object.defineProperty(exports, "getRequestAcceptableLanguages", {
+	enumerable: true,
+	get: function() {
+		return getRequestAcceptableLanguages;
+	}
+});
+Object.defineProperty(exports, "getRequestHeader", {
+	enumerable: true,
+	get: function() {
+		return getRequestHeader;
+	}
+});
+Object.defineProperty(exports, "getRequestHostName", {
+	enumerable: true,
+	get: function() {
+		return getRequestHostName;
+	}
+});
+Object.defineProperty(exports, "getRequestIP", {
+	enumerable: true,
+	get: function() {
+		return getRequestIP;
+	}
+});
+Object.defineProperty(exports, "getRequestProtocol", {
+	enumerable: true,
+	get: function() {
+		return getRequestProtocol;
+	}
+});
+Object.defineProperty(exports, "isError", {
+	enumerable: true,
+	get: function() {
+		return isError;
+	}
+});
+Object.defineProperty(exports, "isHandler", {
+	enumerable: true,
+	get: function() {
+		return isHandler;
+	}
+});
+Object.defineProperty(exports, "isHandlerOptions", {
+	enumerable: true,
+	get: function() {
+		return isHandlerOptions;
+	}
+});
+Object.defineProperty(exports, "isPath", {
+	enumerable: true,
+	get: function() {
+		return isPath;
+	}
+});
+Object.defineProperty(exports, "isPlugin", {
+	enumerable: true,
+	get: function() {
+		return isPlugin;
+	}
+});
+Object.defineProperty(exports, "isRequestCacheable", {
+	enumerable: true,
+	get: function() {
+		return isRequestCacheable;
+	}
+});
+Object.defineProperty(exports, "isResponseGone", {
+	enumerable: true,
+	get: function() {
+		return isResponseGone;
+	}
+});
+Object.defineProperty(exports, "isWebHandler", {
+	enumerable: true,
+	get: function() {
+		return isWebHandler;
+	}
+});
+Object.defineProperty(exports, "isWebHandlerProvider", {
+	enumerable: true,
+	get: function() {
+		return isWebHandlerProvider;
+	}
+});
+Object.defineProperty(exports, "matchRequestContentType", {
+	enumerable: true,
+	get: function() {
+		return matchRequestContentType;
+	}
+});
+Object.defineProperty(exports, "readBody", {
+	enumerable: true,
+	get: function() {
+		return readBody;
+	}
+});
+Object.defineProperty(exports, "sendAccepted", {
+	enumerable: true,
+	get: function() {
+		return sendAccepted;
+	}
+});
+Object.defineProperty(exports, "sendCreated", {
+	enumerable: true,
+	get: function() {
+		return sendCreated;
+	}
+});
+Object.defineProperty(exports, "sendFile", {
+	enumerable: true,
+	get: function() {
+		return sendFile;
+	}
+});
+Object.defineProperty(exports, "sendFormat", {
+	enumerable: true,
+	get: function() {
+		return sendFormat;
+	}
+});
+Object.defineProperty(exports, "sendRedirect", {
+	enumerable: true,
+	get: function() {
+		return sendRedirect;
+	}
+});
+Object.defineProperty(exports, "sendStream", {
+	enumerable: true,
+	get: function() {
+		return sendStream;
+	}
+});
+Object.defineProperty(exports, "serializeEventStreamMessage", {
+	enumerable: true,
+	get: function() {
+		return serializeEventStreamMessage;
+	}
+});
+Object.defineProperty(exports, "setResponseCacheHeaders", {
+	enumerable: true,
+	get: function() {
+		return setResponseCacheHeaders;
+	}
+});
+Object.defineProperty(exports, "setResponseContentTypeByFileName", {
+	enumerable: true,
+	get: function() {
+		return setResponseContentTypeByFileName;
+	}
+});
+Object.defineProperty(exports, "setResponseGone", {
+	enumerable: true,
+	get: function() {
+		return setResponseGone;
+	}
+});
+Object.defineProperty(exports, "setResponseHeaderAttachment", {
+	enumerable: true,
+	get: function() {
+		return setResponseHeaderAttachment;
+	}
+});
+Object.defineProperty(exports, "setResponseHeaderContentType", {
+	enumerable: true,
+	get: function() {
+		return setResponseHeaderContentType;
+	}
+});
+Object.defineProperty(exports, "toResponse", {
+	enumerable: true,
+	get: function() {
+		return toResponse;
+	}
+});
+Object.defineProperty(exports, "useRequestNegotiator", {
+	enumerable: true,
+	get: function() {
+		return useRequestNegotiator;
+	}
+});
+
+//# sourceMappingURL=src-D_4IPMmD.cjs.map