h3 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/h3.mjs

@@ -49,7 +49,7 @@ var H3Event = class {
 	*/
 	_res;
 	constructor(req, context, app) {
-		this.context = context || new EmptyObject();
+		this.context = context || req.context || new EmptyObject();
 		this.req = req;
 		this.app = app;
 		const _url = req._url;
@@ -297,9 +297,9 @@ function isJSONSerializable(value, _type) {
 const kNotFound = /* @__PURE__ */ Symbol.for("h3.notFound");
 const kHandled = /* @__PURE__ */ Symbol.for("h3.handled");
 function toResponse(val, event, config = {}) {
-	if (val && val instanceof Promise) return val.catch((error) => error).then((resolvedVal) => toResponse(resolvedVal, event, config));
+	if (typeof val?.then === "function") return (val.catch?.((error) => error) || Promise.resolve(val)).then((resolvedVal) => toResponse(resolvedVal, event, config));
 	const response = prepareResponse(val, event, config);
-	if (response instanceof Promise) return toResponse(response, event, config);
+	if (typeof response?.then === "function") return toResponse(response, event, config);
 	const { onResponse: onResponse$1 } = config;
 	return onResponse$1 ? Promise.resolve(onResponse$1(response, event)).then(() => response) : response;
 }
@@ -440,190 +440,77 @@ function callMiddleware(event, middleware, handler, index = 0) {
 		return nextResult;
 	};
 	const ret = fn(event, next);
-	return ret === void 0 || ret === kNotFound ? next() : ret instanceof Promise ? ret.then((resolved) => resolved === void 0 || resolved === kNotFound ? next() : resolved) : ret;
+	return ret === void 0 || ret === kNotFound ? next() : typeof ret?.then === "function" ? ret.then((resolved) => resolved === void 0 || resolved === kNotFound ? next() : resolved) : ret;
 }
 
 //#endregion
-//#region src/h3.ts
-const H3Core = /* @__PURE__ */ (() => {
-	const HTTPMethods = [
-		"GET",
-		"POST",
-		"PUT",
-		"DELETE",
-		"PATCH",
-		"HEAD",
-		"OPTIONS",
-		"CONNECT",
-		"TRACE"
-	];
-	class H3Core$1 {
-		_middleware;
-		_routes = [];
-		config;
-		constructor(config = {}) {
-			this._middleware = [];
-			this.config = config;
-			this.fetch = this.fetch.bind(this);
-			this._fetch = this._fetch.bind(this);
-			this.handler = this.handler.bind(this);
-			config.plugins?.forEach((plugin) => plugin(this));
-		}
-		fetch(request, options) {
-			try {
-				return Promise.resolve(this._fetch(request, options));
-			} catch (error) {
-				return Promise.reject(error);
-			}
-		}
-		_fetch(_req, _init, context) {
-			const request = toRequest(_req, _init);
-			const event = new H3Event(request, context, this);
-			let handlerRes;
-			try {
-				if (this.config.onRequest) {
-					const hookRes = this.config.onRequest(event);
-					handlerRes = hookRes instanceof Promise ? hookRes.then(() => this.handler(event)) : this.handler(event);
-				} else handlerRes = this.handler(event);
-			} catch (error) {
-				handlerRes = Promise.reject(error);
+//#region src/utils/internal/query.ts
+const plusRegex = /\+/g;
+function parseQuery(input) {
+	const params = new EmptyObject();
+	if (!input || input === "?") return params;
+	const inputLength = input.length;
+	let key = "";
+	let value = "";
+	let startingIndex = -1;
+	let equalityIndex = -1;
+	let shouldDecodeKey = false;
+	let shouldDecodeValue = false;
+	let keyHasPlus = false;
+	let valueHasPlus = false;
+	let hasBothKeyValuePair = false;
+	let c = 0;
+	for (let i = 0; i < inputLength + 1; i++) {
+		c = i === inputLength ? 38 : input.charCodeAt(i);
+		switch (c) {
+			case 38: {
+				hasBothKeyValuePair = equalityIndex > startingIndex;
+				if (!hasBothKeyValuePair) equalityIndex = i;
+				key = input.slice(startingIndex + 1, equalityIndex);
+				if (hasBothKeyValuePair || key.length > 0) {
+					if (keyHasPlus) key = key.replace(plusRegex, " ");
+					if (shouldDecodeKey) try {
+						key = decodeURIComponent(key);
+					} catch {}
+					if (hasBothKeyValuePair) {
+						value = input.slice(equalityIndex + 1, i);
+						if (valueHasPlus) value = value.replace(plusRegex, " ");
+						if (shouldDecodeValue) try {
+							value = decodeURIComponent(value);
+						} catch {}
+					}
+					const currentValue = params[key];
+					if (currentValue === void 0) params[key] = value;
+					else if (Array.isArray(currentValue)) currentValue.push(value);
+					else params[key] = [currentValue, value];
+				}
+				value = "";
+				startingIndex = i;
+				equalityIndex = i;
+				shouldDecodeKey = false;
+				shouldDecodeValue = false;
+				keyHasPlus = false;
+				valueHasPlus = false;
+				break;
 			}
-			return toResponse(handlerRes, event, this.config);
-		}
-		/**
-		* Immediately register an H3 plugin.
-		*/
-		register(plugin) {
-			plugin(this);
-			return this;
-		}
-		_findRoute(_event) {}
-		_addRoute(_route) {
-			this._routes.push(_route);
-		}
-		handler(event) {
-			const route = this._findRoute(event);
-			if (route) {
-				event.context.params = route.params;
-				event.context.matchedRoute = route.data;
+			case 61: {
+				if (equalityIndex <= startingIndex) equalityIndex = i;
+				else shouldDecodeValue = true;
+				break;
 			}
-			const middleware = route?.data.middleware ? [...this._middleware, ...route.data.middleware] : this._middleware;
-			return callMiddleware(event, middleware, () => {
-				return route ? route.data.handler(event) : kNotFound;
-			});
-		}
-		mount(base, input) {
-			if ("handler" in input) {
-				if (input._middleware.length > 0) this._middleware.push((event, next) => {
-					return event.url.pathname.startsWith(base) ? callMiddleware(event, input._middleware, next) : next();
-				});
-				for (const r of input._routes) this._addRoute({
-					...r,
-					route: base + r.route
-				});
-			} else {
-				const fetchHandler = "fetch" in input ? input.fetch : input;
-				this.all(`${base}/**`, (event) => {
-					const url = new URL(event.url);
-					url.pathname = url.pathname.slice(base.length) || "/";
-					return fetchHandler(new Request(url, event.req));
-				});
+			case 43: {
+				if (equalityIndex > startingIndex) valueHasPlus = true;
+				else keyHasPlus = true;
+				break;
 			}
-			return this;
-		}
-		all(route, handler, opts) {
-			return this.on("", route, handler, opts);
-		}
-		on(method, route, handler, opts) {
-			const _method = (method || "").toUpperCase();
-			route = new URL(route, "http://_").pathname;
-			this._addRoute({
-				method: _method,
-				route,
-				handler,
-				middleware: opts?.middleware,
-				meta: {
-					...handler.meta,
-					...opts?.meta
-				}
-			});
-			return this;
-		}
-		use(arg1, arg2, arg3) {
-			let route;
-			let fn;
-			let opts;
-			if (typeof arg1 === "string") {
-				route = arg1;
-				fn = arg2;
-				opts = arg3;
-			} else {
-				fn = arg1;
-				opts = arg2;
+			case 37: {
+				if (equalityIndex > startingIndex) shouldDecodeValue = true;
+				else shouldDecodeKey = true;
+				break;
 			}
-			this._middleware.push(normalizeMiddleware(fn, route ? {
-				...opts,
-				route
-			} : opts));
-			return this;
 		}
 	}
-	for (const method of HTTPMethods) H3Core$1.prototype[method.toLowerCase()] = function(route, handler, opts) {
-		return this.on(method, route, handler, opts);
-	};
-	return H3Core$1;
-})();
-var H3 = class extends H3Core {
-	/**
-	* @internal
-	*/
-	_rou3;
-	constructor(config = {}) {
-		super(config);
-		this._rou3 = createRouter();
-	}
-	_findRoute(_event) {
-		return findRoute(this._rou3, _event.req.method, _event.url.pathname);
-	}
-	_addRoute(_route) {
-		addRoute(this._rou3, _route.method, _route.route, _route);
-		super._addRoute(_route);
-	}
-};
-function toRequest(_request, _init) {
-	if (typeof _request === "string") {
-		let url = _request;
-		if (url[0] === "/") {
-			const headers = _init?.headers ? new Headers(_init.headers) : void 0;
-			const host = headers?.get("host") || "localhost";
-			const proto = headers?.get("x-forwarded-proto") === "https" ? "https" : "http";
-			url = `${proto}://${host}${url}`;
-		}
-		return new Request(url, _init);
-	} else if (_init || _request instanceof URL) return new Request(_request, _init);
-	return _request;
-}
-
-//#endregion
-//#region src/utils/event.ts
-/**
-* Checks if the input is an H3Event object.
-* @param input - The input to check.
-* @returns True if the input is an H3Event object, false otherwise.
-* @see H3Event
-*/
-function isEvent(input) {
-	return input instanceof H3Event || input?.constructor?.__is_event__;
-}
-function mockEvent(_request, options) {
-	let request;
-	if (typeof _request === "string") {
-		let url = _request;
-		if (url[0] === "/") url = `http://localhost${url}`;
-		request = new Request(url, options);
-	} else if (options || _request instanceof URL) request = new Request(_request, options);
-	else request = _request;
-	return new H3Event(request);
+	return params;
 }
 
 //#endregion
@@ -689,226 +576,65 @@ function createValidationError(validateError) {
 }
 
 //#endregion
-//#region src/handler.ts
-function defineHandler(arg1) {
-	if (typeof arg1 === "function") return handlerWithFetch(arg1);
-	const { middleware, handler, meta } = arg1;
-	const _handler = handlerWithFetch(middleware?.length ? (event) => callMiddleware(event, middleware, handler) : handler);
-	_handler.meta = meta;
-	return _handler;
+//#region src/utils/event.ts
+/**
+* Checks if the input is an H3Event object.
+* @param input - The input to check.
+* @returns True if the input is an H3Event object, false otherwise.
+* @see H3Event
+*/
+function isEvent(input) {
+	return input instanceof H3Event || input?.constructor?.__is_event__;
 }
 /**
-* @experimental defineValidatedHandler is an experimental feature and API may change.
+* Checks if the input is an object with `{ req: Request }` signature.
+* @param input - The input to check.
+* @returns True if the input is is `{ req: Request }`
 */
-function defineValidatedHandler(def) {
-	if (!def.validate) return defineHandler(def);
-	return defineHandler({
-		...def,
-		handler: (event) => {
-			event.req = validatedRequest(event.req, def.validate);
-			event.url = validatedURL(event.url, def.validate);
-			return def.handler(event);
-		}
-	});
+function isHTTPEvent(input) {
+	return input?.req instanceof Request;
 }
-function handlerWithFetch(handler) {
-	return Object.assign(handler, { fetch: (_req, _init) => {
-		const req = toRequest(_req, _init);
-		const event = new H3Event(req);
-		try {
-			return Promise.resolve(toResponse(handler(event), event));
-		} catch (error) {
-			return Promise.resolve(toResponse(error, event));
-		}
-	} });
-}
-function dynamicEventHandler(initial) {
-	let current = initial;
-	return Object.assign(defineHandler((event) => current?.(event)), { set: (handler) => {
-		current = handler;
-	} });
-}
-function defineLazyEventHandler(load) {
-	let _promise;
-	let _resolved;
-	const resolveHandler = () => {
-		if (_resolved) return Promise.resolve(_resolved);
-		if (!_promise) _promise = Promise.resolve(load()).then((r) => {
-			const handler = r.default || r;
-			if (typeof handler !== "function") throw new TypeError("Invalid lazy handler result. It should be a function:", handler);
-			_resolved = { handler: r.default || r };
-			return _resolved;
-		});
-		return _promise;
-	};
-	return defineHandler((event) => {
-		if (_resolved) return _resolved.handler(event);
-		return resolveHandler().then((r) => r.handler(event));
-	});
-}
-
-//#endregion
-//#region src/adapters.ts
 /**
-* @deprecated Since h3 v2 you can directly use `app.fetch(request, init?, context?)`
+* Gets the context of the event, if it does not exists, initializes a new context on `req.context`.
 */
-function toWebHandler(app) {
-	return (request, context) => {
-		return Promise.resolve(app._fetch(request, void 0, context));
-	};
+function getEventContext(event) {
+	if (event.context) return event.context;
+	event.req.context ??= {};
+	return event.req.context;
 }
-function fromWebHandler(handler) {
-	return (event) => handler(event.req, event.context);
-}
-function fromNodeHandler(handler) {
-	if (typeof handler !== "function") throw new TypeError(`Invalid handler. It should be a function: ${handler}`);
-	return (event) => {
-		if (!event.runtime?.node?.res) throw new Error("[h3] Executing Node.js middleware is not supported in this server!");
-		return callNodeHandler(handler, event.runtime?.node.req, event.runtime?.node.res);
-	};
-}
-function defineNodeHandler(handler) {
-	return handler;
-}
-function defineNodeMiddleware(handler) {
-	return handler;
-}
-/**
-* Convert H3 app instance to a NodeHandler with (IncomingMessage, ServerResponse) => void signature.
-*/
-function toNodeHandler$1(app) {
-	return toNodeHandler(app.fetch);
-}
-function callNodeHandler(handler, req, res) {
-	const isMiddleware = handler.length > 2;
-	return new Promise((resolve, reject) => {
-		res.once("close", () => resolve(kHandled));
-		res.once("finish", () => resolve(kHandled));
-		res.once("pipe", (stream) => resolve(stream));
-		res.once("error", (error) => reject(error));
-		try {
-			if (isMiddleware) Promise.resolve(handler(req, res, (error) => error ? reject(new HTTPError({
-				cause: error,
-				unhandled: true
-			})) : resolve(void 0))).catch((error) => reject(new HTTPError({
-				cause: error,
-				unhandled: true
-			})));
-			else return Promise.resolve(handler(req, res)).then(() => resolve(kHandled)).catch((error) => reject(new HTTPError({
-				cause: error,
-				unhandled: true
-			})));
-		} catch (error) {
-			reject(new HTTPError({
-				cause: error,
-				unhandled: true
-			}));
-		}
-	});
+function mockEvent(_request, options) {
+	let request;
+	if (typeof _request === "string") {
+		let url = _request;
+		if (url[0] === "/") url = `http://localhost${url}`;
+		request = new Request(url, options);
+	} else if (options || _request instanceof URL) request = new Request(_request, options);
+	else request = _request;
+	return new H3Event(request);
 }
 
 //#endregion
-//#region src/utils/route.ts
+//#region src/utils/request.ts
 /**
-* Define a route as a plugin that can be registered with app.register()
+* Convert input into a web [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request).
 *
-* @example
-* ```js
-* import { z } from "zod";
+* If input is a relative URL, it will be normalized into a full path based on headers.
 *
-* const userRoute = defineRoute({
-*    method: 'POST',
-*    validate: {
-*      query: z.object({ id: z.string().uuid() }),
-*      body: z.object({ name: z.string() }),
-*    },
-*    handler: (event) => {
-*      return { success: true };
-*    }
-* });
-*
-* app.register(userRoute);
-* ```
+* If input is already a Request and no options are provided, it will be returned as-is.
 */
-function defineRoute(def) {
-	const handler = defineValidatedHandler(def);
-	return (h3) => {
-		h3.on(def.method, def.route, handler);
-	};
-}
-
-//#endregion
-//#region src/utils/internal/query.ts
-const plusRegex = /\+/g;
-function parseQuery(input) {
-	const params = new EmptyObject();
-	if (!input || input === "?") return params;
-	const inputLength = input.length;
-	let key = "";
-	let value = "";
-	let startingIndex = -1;
-	let equalityIndex = -1;
-	let shouldDecodeKey = false;
-	let shouldDecodeValue = false;
-	let keyHasPlus = false;
-	let valueHasPlus = false;
-	let hasBothKeyValuePair = false;
-	let c = 0;
-	for (let i = 0; i < inputLength + 1; i++) {
-		c = i === inputLength ? 38 : input.charCodeAt(i);
-		switch (c) {
-			case 38: {
-				hasBothKeyValuePair = equalityIndex > startingIndex;
-				if (!hasBothKeyValuePair) equalityIndex = i;
-				key = input.slice(startingIndex + 1, equalityIndex);
-				if (hasBothKeyValuePair || key.length > 0) {
-					if (keyHasPlus) key = key.replace(plusRegex, " ");
-					if (shouldDecodeKey) try {
-						key = decodeURIComponent(key);
-					} catch {}
-					if (hasBothKeyValuePair) {
-						value = input.slice(equalityIndex + 1, i);
-						if (valueHasPlus) value = value.replace(plusRegex, " ");
-						if (shouldDecodeValue) try {
-							value = decodeURIComponent(value);
-						} catch {}
-					}
-					const currentValue = params[key];
-					if (currentValue === void 0) params[key] = value;
-					else if (Array.isArray(currentValue)) currentValue.push(value);
-					else params[key] = [currentValue, value];
-				}
-				value = "";
-				startingIndex = i;
-				equalityIndex = i;
-				shouldDecodeKey = false;
-				shouldDecodeValue = false;
-				keyHasPlus = false;
-				valueHasPlus = false;
-				break;
-			}
-			case 61: {
-				if (equalityIndex <= startingIndex) equalityIndex = i;
-				else shouldDecodeValue = true;
-				break;
-			}
-			case 43: {
-				if (equalityIndex > startingIndex) valueHasPlus = true;
-				else keyHasPlus = true;
-				break;
-			}
-			case 37: {
-				if (equalityIndex > startingIndex) shouldDecodeValue = true;
-				else shouldDecodeKey = true;
-				break;
-			}
+function toRequest(input, options) {
+	if (typeof input === "string") {
+		let url = input;
+		if (url[0] === "/") {
+			const headers = options?.headers ? new Headers(options.headers) : void 0;
+			const host = headers?.get("host") || "localhost";
+			const proto = headers?.get("x-forwarded-proto") === "https" ? "https" : "http";
+			url = `${proto}://${host}${url}`;
 		}
-	}
-	return params;
+		return new Request(url, options);
+	} else if (options || input instanceof URL) return new Request(input, options);
+	return input;
 }
-
-//#endregion
-//#region src/utils/request.ts
 /**
 * Get parsed query string object from the request URL.
 *
@@ -918,7 +644,8 @@ function parseQuery(input) {
 * });
 */
 function getQuery(event) {
-	return parseQuery(event.url.search.slice(1));
+	const url = event.url || new URL(event.req.url);
+	return parseQuery(url.search.slice(1));
 }
 /**
 * Get the query param from the request URL validated with validate function.
@@ -958,7 +685,8 @@ function getValidatedQuery(event, validate) {
 * });
 */
 function getRouterParams(event, opts = {}) {
-	let params = event.context.params || {};
+	const context = getEventContext(event);
+	let params = context.params || {};
 	if (opts.decode) {
 		params = { ...params };
 		for (const key in params) params[key] = decodeURIComponent(params[key]);
@@ -1009,126 +737,423 @@ function getRouterParam(event, name, opts = {}) {
 	return params[name];
 }
 /**
-*
-* Checks if the incoming request method is of the expected type.
-*
-* If `allowHead` is `true`, it will allow `HEAD` requests to pass if the expected method is `GET`.
-*
-* @example
-* app.get("/", (event) => {
-*   if (isMethod(event, "GET")) {
-*     // Handle GET request
-*   } else if (isMethod(event, ["POST", "PUT"])) {
-*     // Handle POST or PUT request
-*   }
-* });
+*
+* Checks if the incoming request method is of the expected type.
+*
+* If `allowHead` is `true`, it will allow `HEAD` requests to pass if the expected method is `GET`.
+*
+* @example
+* app.get("/", (event) => {
+*   if (isMethod(event, "GET")) {
+*     // Handle GET request
+*   } else if (isMethod(event, ["POST", "PUT"])) {
+*     // Handle POST or PUT request
+*   }
+* });
+*/
+function isMethod(event, expected, allowHead) {
+	if (allowHead && event.req.method === "HEAD") return true;
+	if (typeof expected === "string") {
+		if (event.req.method === expected) return true;
+	} else if (expected.includes(event.req.method)) return true;
+	return false;
+}
+/**
+* Asserts that the incoming request method is of the expected type using `isMethod`.
+*
+* If the method is not allowed, it will throw a 405 error with the message "HTTP method is not allowed".
+*
+* If `allowHead` is `true`, it will allow `HEAD` requests to pass if the expected method is `GET`.
+*
+* @example
+* app.get("/", (event) => {
+*   assertMethod(event, "GET");
+*   // Handle GET request, otherwise throw 405 error
+* });
+*/
+function assertMethod(event, expected, allowHead) {
+	if (!isMethod(event, expected, allowHead)) throw new HTTPError({ status: 405 });
+}
+/**
+* Get the request hostname.
+*
+* If `xForwardedHost` is `true`, it will use the `x-forwarded-host` header if it exists.
+*
+* If no host header is found, it will default to "localhost".
+*
+* @example
+* app.get("/", (event) => {
+*   const host = getRequestHost(event); // "example.com"
+* });
+*/
+function getRequestHost(event, opts = {}) {
+	if (opts.xForwardedHost) {
+		const _header = event.req.headers.get("x-forwarded-host");
+		const xForwardedHost = (_header || "").split(",").shift()?.trim();
+		if (xForwardedHost) return xForwardedHost;
+	}
+	return event.req.headers.get("host") || "";
+}
+/**
+* Get the request protocol.
+*
+* If `x-forwarded-proto` header is set to "https", it will return "https". You can disable this behavior by setting `xForwardedProto` to `false`.
+*
+* If protocol cannot be determined, it will default to "http".
+*
+* @example
+* app.get("/", (event) => {
+*   const protocol = getRequestProtocol(event); // "https"
+* });
+*/
+function getRequestProtocol(event, opts = {}) {
+	if (opts.xForwardedProto !== false) {
+		const forwardedProto = event.req.headers.get("x-forwarded-proto");
+		if (forwardedProto === "https") return "https";
+		if (forwardedProto === "http") return "http";
+	}
+	const url = event.url || new URL(event.req.url);
+	return url.protocol.slice(0, -1);
+}
+/**
+* Generated the full incoming request URL.
+*
+* If `xForwardedHost` is `true`, it will use the `x-forwarded-host` header if it exists.
+*
+* If `xForwardedProto` is `false`, it will not use the `x-forwarded-proto` header.
+*
+* @example
+* app.get("/", (event) => {
+*   const url = getRequestURL(event); // "https://example.com/path"
+* });
+*/
+function getRequestURL(event, opts = {}) {
+	const url = new URL(event.url || event.req.url);
+	url.protocol = getRequestProtocol(event, opts);
+	if (opts.xForwardedHost) {
+		const host = getRequestHost(event, opts);
+		if (host) {
+			url.host = host;
+			if (!host.includes(":")) url.port = "";
+		}
+	}
+	return url;
+}
+/**
+* Try to get the client IP address from the incoming request.
+*
+* If `xForwardedFor` is `true`, it will use the `x-forwarded-for` header if it exists.
+*
+* If IP cannot be determined, it will default to `undefined`.
+*
+* @example
+* app.get("/", (event) => {
+*   const ip = getRequestIP(event); // "192.0.2.0"
+* });
+*/
+function getRequestIP(event, opts = {}) {
+	if (opts.xForwardedFor) {
+		const _header = event.req.headers.get("x-forwarded-for");
+		const xForwardedFor = (_header || "")?.split(",").shift()?.trim();
+		if (xForwardedFor) return xForwardedFor;
+	}
+	return event.req.context?.clientAddress || event.req.ip || void 0;
+}
+
+//#endregion
+//#region src/h3.ts
+const H3Core = /* @__PURE__ */ (() => {
+	const HTTPMethods = [
+		"GET",
+		"POST",
+		"PUT",
+		"DELETE",
+		"PATCH",
+		"HEAD",
+		"OPTIONS",
+		"CONNECT",
+		"TRACE"
+	];
+	class H3Core$1 {
+		_middleware;
+		_routes = [];
+		config;
+		constructor(config = {}) {
+			this._middleware = [];
+			this.config = config;
+			this.fetch = this.fetch.bind(this);
+			this.request = this.request.bind(this);
+			this.handler = this.handler.bind(this);
+			config.plugins?.forEach((plugin) => plugin(this));
+		}
+		fetch(request) {
+			return this._request(request);
+		}
+		request(_req, _init, context) {
+			return this._request(toRequest(_req, _init), context);
+		}
+		_request(request, context) {
+			const event = new H3Event(request, context, this);
+			let handlerRes;
+			try {
+				if (this.config.onRequest) {
+					const hookRes = this.config.onRequest(event);
+					handlerRes = typeof hookRes?.then === "function" ? hookRes.then(() => this.handler(event)) : this.handler(event);
+				} else handlerRes = this.handler(event);
+			} catch (error) {
+				handlerRes = Promise.reject(error);
+			}
+			return toResponse(handlerRes, event, this.config);
+		}
+		/**
+		* Immediately register an H3 plugin.
+		*/
+		register(plugin) {
+			plugin(this);
+			return this;
+		}
+		_findRoute(_event) {}
+		_addRoute(_route) {
+			this._routes.push(_route);
+		}
+		handler(event) {
+			const route = this._findRoute(event);
+			if (route) {
+				event.context.params = route.params;
+				event.context.matchedRoute = route.data;
+			}
+			const middleware = route?.data.middleware ? [...this._middleware, ...route.data.middleware] : this._middleware;
+			return callMiddleware(event, middleware, () => {
+				return route ? route.data.handler(event) : kNotFound;
+			});
+		}
+		mount(base, input) {
+			if ("handler" in input) {
+				if (input._middleware.length > 0) this._middleware.push((event, next) => {
+					return event.url.pathname.startsWith(base) ? callMiddleware(event, input._middleware, next) : next();
+				});
+				for (const r of input._routes) this._addRoute({
+					...r,
+					route: base + r.route
+				});
+			} else {
+				const fetchHandler = "fetch" in input ? input.fetch : input;
+				this.all(`${base}/**`, (event) => {
+					const url = new URL(event.url);
+					url.pathname = url.pathname.slice(base.length) || "/";
+					return fetchHandler(new Request(url, event.req));
+				});
+			}
+			return this;
+		}
+		all(route, handler, opts) {
+			return this.on("", route, handler, opts);
+		}
+		on(method, route, handler, opts) {
+			const _method = (method || "").toUpperCase();
+			route = new URL(route, "http://_").pathname;
+			this._addRoute({
+				method: _method,
+				route,
+				handler,
+				middleware: opts?.middleware,
+				meta: {
+					...handler.meta,
+					...opts?.meta
+				}
+			});
+			return this;
+		}
+		use(arg1, arg2, arg3) {
+			let route;
+			let fn;
+			let opts;
+			if (typeof arg1 === "string") {
+				route = arg1;
+				fn = arg2;
+				opts = arg3;
+			} else {
+				fn = arg1;
+				opts = arg2;
+			}
+			this._middleware.push(normalizeMiddleware(fn, route ? {
+				...opts,
+				route
+			} : opts));
+			return this;
+		}
+	}
+	for (const method of HTTPMethods) H3Core$1.prototype[method.toLowerCase()] = function(route, handler, opts) {
+		return this.on(method, route, handler, opts);
+	};
+	return H3Core$1;
+})();
+var H3 = class extends H3Core {
+	/**
+	* @internal
+	*/
+	_rou3;
+	constructor(config = {}) {
+		super(config);
+		this._rou3 = createRouter();
+	}
+	_findRoute(_event) {
+		return findRoute(this._rou3, _event.req.method, _event.url.pathname);
+	}
+	_addRoute(_route) {
+		addRoute(this._rou3, _route.method, _route.route, _route);
+		super._addRoute(_route);
+	}
+};
+
+//#endregion
+//#region src/handler.ts
+function defineHandler(arg1) {
+	if (typeof arg1 === "function") return handlerWithFetch(arg1);
+	const { middleware, handler, meta } = arg1;
+	const _handler = handlerWithFetch(middleware?.length ? (event) => callMiddleware(event, middleware, handler) : handler);
+	_handler.meta = meta;
+	return _handler;
+}
+/**
+* @experimental defineValidatedHandler is an experimental feature and API may change.
 */
-function isMethod(event, expected, allowHead) {
-	if (allowHead && event.req.method === "HEAD") return true;
-	if (typeof expected === "string") {
-		if (event.req.method === expected) return true;
-	} else if (expected.includes(event.req.method)) return true;
-	return false;
+function defineValidatedHandler(def) {
+	if (!def.validate) return defineHandler(def);
+	return defineHandler({
+		...def,
+		handler: (event) => {
+			event.req = validatedRequest(event.req, def.validate);
+			event.url = validatedURL(event.url, def.validate);
+			return def.handler(event);
+		}
+	});
 }
-/**
-* Asserts that the incoming request method is of the expected type using `isMethod`.
-*
-* If the method is not allowed, it will throw a 405 error with the message "HTTP method is not allowed".
-*
-* If `allowHead` is `true`, it will allow `HEAD` requests to pass if the expected method is `GET`.
-*
-* @example
-* app.get("/", (event) => {
-*   assertMethod(event, "GET");
-*   // Handle GET request, otherwise throw 405 error
-* });
-*/
-function assertMethod(event, expected, allowHead) {
-	if (!isMethod(event, expected, allowHead)) throw new HTTPError({ status: 405 });
+function handlerWithFetch(handler) {
+	return Object.assign(handler, { fetch: (req) => {
+		if (typeof req === "string") req = new URL(req, "http://_");
+		if (req instanceof URL) req = new Request(req);
+		const event = new H3Event(req);
+		try {
+			return Promise.resolve(toResponse(handler(event), event));
+		} catch (error) {
+			return Promise.resolve(toResponse(error, event));
+		}
+	} });
 }
-/**
-* Get the request hostname.
-*
-* If `xForwardedHost` is `true`, it will use the `x-forwarded-host` header if it exists.
-*
-* If no host header is found, it will default to "localhost".
-*
-* @example
-* app.get("/", (event) => {
-*   const host = getRequestHost(event); // "example.com"
-* });
-*/
-function getRequestHost(event, opts = {}) {
-	if (opts.xForwardedHost) {
-		const _header = event.req.headers.get("x-forwarded-host");
-		const xForwardedHost = (_header || "").split(",").shift()?.trim();
-		if (xForwardedHost) return xForwardedHost;
-	}
-	return event.req.headers.get("host") || "";
+function dynamicEventHandler(initial) {
+	let current = initial;
+	return Object.assign(defineHandler((event) => current?.(event)), { set: (handler) => {
+		current = handler;
+	} });
+}
+function defineLazyEventHandler(load) {
+	let _promise;
+	let _resolved;
+	const resolveHandler = () => {
+		if (_resolved) return Promise.resolve(_resolved);
+		if (!_promise) _promise = Promise.resolve(load()).then((r) => {
+			const handler = r.default || r;
+			if (typeof handler !== "function") throw new TypeError("Invalid lazy handler result. It should be a function:", handler);
+			_resolved = { handler: r.default || r };
+			return _resolved;
+		});
+		return _promise;
+	};
+	return defineHandler((event) => {
+		if (_resolved) return _resolved.handler(event);
+		return resolveHandler().then((r) => r.handler(event));
+	});
 }
+
+//#endregion
+//#region src/adapters.ts
 /**
-* Get the request protocol.
-*
-* If `x-forwarded-proto` header is set to "https", it will return "https". You can disable this behavior by setting `xForwardedProto` to `false`.
-*
-* If protocol cannot be determined, it will default to "http".
-*
-* @example
-* app.get("/", (event) => {
-*   const protocol = getRequestProtocol(event); // "https"
-* });
+* @deprecated Since h3 v2 you can directly use `app.fetch(request, init?, context?)`
 */
-function getRequestProtocol(event, opts = {}) {
-	if (opts.xForwardedProto !== false) {
-		const forwardedProto = event.req.headers.get("x-forwarded-proto");
-		if (forwardedProto === "https") return "https";
-		if (forwardedProto === "http") return "http";
-	}
-	return event.url.protocol.slice(0, -1);
+function toWebHandler(app) {
+	return (request, context) => {
+		return Promise.resolve(app.request(request, void 0, context || request.context));
+	};
+}
+function fromWebHandler(handler) {
+	return (event) => handler(event.req, event.context);
+}
+function fromNodeHandler(handler) {
+	if (typeof handler !== "function") throw new TypeError(`Invalid handler. It should be a function: ${handler}`);
+	return (event) => {
+		if (!event.runtime?.node?.res) throw new Error("[h3] Executing Node.js middleware is not supported in this server!");
+		return callNodeHandler(handler, event.runtime?.node.req, event.runtime?.node.res);
+	};
+}
+function defineNodeHandler(handler) {
+	return handler;
+}
+function defineNodeMiddleware(handler) {
+	return handler;
 }
 /**
-* Generated the full incoming request URL.
-*
-* If `xForwardedHost` is `true`, it will use the `x-forwarded-host` header if it exists.
-*
-* If `xForwardedProto` is `false`, it will not use the `x-forwarded-proto` header.
-*
-* @example
-* app.get("/", (event) => {
-*   const url = getRequestURL(event); // "https://example.com/path"
-* });
+* Convert H3 app instance to a NodeHandler with (IncomingMessage, ServerResponse) => void signature.
 */
-function getRequestURL(event, opts = {}) {
-	const url = new URL(event.url);
-	url.protocol = getRequestProtocol(event, opts);
-	if (opts.xForwardedHost) {
-		const host = getRequestHost(event, opts);
-		if (host) {
-			url.host = host;
-			if (!host.includes(":")) url.port = "";
+function toNodeHandler$1(app) {
+	return toNodeHandler(app.fetch);
+}
+function callNodeHandler(handler, req, res) {
+	const isMiddleware = handler.length > 2;
+	return new Promise((resolve, reject) => {
+		res.once("close", () => resolve(kHandled));
+		res.once("finish", () => resolve(kHandled));
+		res.once("pipe", (stream) => resolve(stream));
+		res.once("error", (error) => reject(error));
+		try {
+			if (isMiddleware) Promise.resolve(handler(req, res, (error) => error ? reject(new HTTPError({
+				cause: error,
+				unhandled: true
+			})) : resolve(void 0))).catch((error) => reject(new HTTPError({
+				cause: error,
+				unhandled: true
+			})));
+			else return Promise.resolve(handler(req, res)).then(() => resolve(kHandled)).catch((error) => reject(new HTTPError({
+				cause: error,
+				unhandled: true
+			})));
+		} catch (error) {
+			reject(new HTTPError({
+				cause: error,
+				unhandled: true
+			}));
 		}
-	}
-	return url;
+	});
 }
+
+//#endregion
+//#region src/utils/route.ts
 /**
-* Try to get the client IP address from the incoming request.
-*
-* If `xForwardedFor` is `true`, it will use the `x-forwarded-for` header if it exists.
-*
-* If IP cannot be determined, it will default to `undefined`.
+* Define a route as a plugin that can be registered with app.register()
 *
 * @example
-* app.get("/", (event) => {
-*   const ip = getRequestIP(event); // "192.0.2.0"
+* ```js
+* import { z } from "zod";
+*
+* const userRoute = defineRoute({
+*    method: 'POST',
+*    validate: {
+*      query: z.object({ id: z.string().uuid() }),
+*      body: z.object({ name: z.string() }),
+*    },
+*    handler: (event) => {
+*      return { success: true };
+*    }
 * });
+*
+* app.register(userRoute);
+* ```
 */
-function getRequestIP(event, opts = {}) {
-	if (opts.xForwardedFor) {
-		const _header = event.req.headers.get("x-forwarded-for");
-		const xForwardedFor = (_header || "")?.split(",").shift()?.trim();
-		if (xForwardedFor) return xForwardedFor;
-	}
-	return event.context.clientAddress || event.req.ip || void 0;
+function defineRoute(def) {
+	const handler = defineValidatedHandler(def);
+	return (h3) => {
+		h3.on(def.method, def.route, handler);
+	};
 }
 
 //#endregion
@@ -1282,7 +1307,7 @@ function noContent(event, code) {
 	if (!code && currentStatus && currentStatus !== 200) code = event.res.status;
 	event.res.status = sanitizeStatusCode(code, 204);
 	if (event.res.status === 204) event.res.headers.delete("content-length");
-	return "";
+	return new FastResponse(null, event.res);
 }
 /**
 * Send a redirect response to the client.
@@ -1494,7 +1519,7 @@ async function proxy(event, target, opts = {}) {
 	};
 	let response;
 	try {
-		response = target[0] === "/" ? await event.app._fetch(createSubRequest(event, target, fetchOptions)) : await fetch(target, fetchOptions);
+		response = target[0] === "/" ? await event.app.fetch(createSubRequest(event, target, fetchOptions)) : await fetch(target, fetchOptions);
 	} catch (error) {
 		throw new HTTPError({
 			status: 502,
@@ -1528,7 +1553,17 @@ async function proxy(event, target, opts = {}) {
 */
 function getProxyRequestHeaders(event, opts) {
 	const headers = new EmptyObject();
-	for (const [name, value] of event.req.headers.entries()) if (opts?.forwardHeaders?.includes(name) || opts?.filterHeaders && !opts.filterHeaders.includes(name) || !ignoredHeaders.has(name) || name === "host" && opts?.host) headers[name] = value;
+	for (const [name, value] of event.req.headers.entries()) {
+		if (opts?.filterHeaders?.includes(name)) continue;
+		if (opts?.forwardHeaders?.includes(name)) {
+			headers[name] = value;
+			continue;
+		}
+		if (!ignoredHeaders.has(name) || name === "host" && opts?.host) {
+			headers[name] = value;
+			continue;
+		}
+	}
 	return headers;
 }
 /**
@@ -1536,7 +1571,7 @@ function getProxyRequestHeaders(event, opts) {
 */
 async function fetchWithEvent(event, url, init) {
 	if (url[0] !== "/") return fetch(url, init);
-	return event.app._fetch(createSubRequest(event, url, {
+	return event.app.fetch(createSubRequest(event, url, {
 		...init,
 		headers: mergeHeaders(getProxyRequestHeaders(event, { host: true }), init?.headers)
 	}));
@@ -1614,7 +1649,7 @@ async function readBody(event) {
 *   const body = await readValidatedBody(event, objectSchema);
 * });
 *
-* @param event The H3Event passed by the handler.
+* @param event The HTTPEvent passed by the handler.
 * @param validate The function to use for body validation. It will be called passing the read request body. If the result is not false, the parsed body will be returned.
 * @throws If the validation function returns `false` or throws, a validation error will be thrown.
 * @return {*} The `Object`, `Array`, `String`, `Number`, `Boolean`, or `null` value corresponding to the request JSON body.
@@ -1627,9 +1662,11 @@ async function readValidatedBody(event, validate) {
 
 //#endregion
 //#region src/utils/cookie.ts
+const CHUNKED_COOKIE = "__chunked__";
+const CHUNKS_MAX_LENGTH = 4e3;
 /**
 * Parse the request to get HTTP Cookie header string and returning an object of all cookie name-value pairs.
-* @param event {H3Event} H3 event or req passed by h3 handler
+* @param event {HTTPEvent} H3 event or req passed by h3 handler
 * @returns Object of cookie name-value pairs
 * ```ts
 * const cookies = parseCookies(event)
@@ -1640,7 +1677,7 @@ function parseCookies(event) {
 }
 /**
 * Get a cookie value by name.
-* @param event {H3Event} H3 event or req passed by h3 handler
+* @param event {HTTPEvent} H3 event or req passed by h3 handler
 * @param name Name of the cookie to get
 * @returns {*} Value of the cookie (String or undefined)
 * ```ts
@@ -1695,6 +1732,59 @@ function deleteCookie(event, name, serializeOptions) {
 	});
 }
 /**
+* Get a chunked cookie value by name. Will join chunks together.
+* @param event {HTTPEvent} { req: Request }
+* @param name Name of the cookie to get
+* @returns {*} Value of the cookie (String or undefined)
+* ```ts
+* const authorization = getCookie(request, 'Session')
+* ```
+*/
+function getChunkedCookie(event, name) {
+	const mainCookie = getCookie(event, name);
+	if (!mainCookie || !mainCookie.startsWith(CHUNKED_COOKIE)) return mainCookie;
+	const chunksCount = getChunkedCookieCount(mainCookie);
+	if (chunksCount === 0) return void 0;
+	const chunks = [];
+	for (let i = 1; i <= chunksCount; i++) {
+		const chunk = getCookie(event, chunkCookieName(name, i));
+		if (!chunk) return void 0;
+		chunks.push(chunk);
+	}
+	return chunks.join("");
+}
+/**
+* Set a cookie value by name. Chunked cookies will be created as needed.
+* @param event {H3Event} H3 event or res passed by h3 handler
+* @param name Name of the cookie to set
+* @param value Value of the cookie to set
+* @param options {CookieSerializeOptions} Options for serializing the cookie
+* ```ts
+* setCookie(res, 'Session', '<session data>')
+* ```
+*/
+function setChunkedCookie(event, name, value, options) {
+	const chunkMaxLength = options?.chunkMaxLength || CHUNKS_MAX_LENGTH;
+	const chunkCount = Math.ceil(value.length / chunkMaxLength);
+	const previousCookie = getCookie(event, name);
+	if (previousCookie?.startsWith(CHUNKED_COOKIE)) {
+		const previousChunkCount = getChunkedCookieCount(previousCookie);
+		if (previousChunkCount > chunkCount) for (let i = chunkCount; i <= previousChunkCount; i++) deleteCookie(event, chunkCookieName(name, i), options);
+	}
+	if (chunkCount <= 1) {
+		setCookie(event, name, value, options);
+		return;
+	}
+	const mainCookieValue = `${CHUNKED_COOKIE}${chunkCount}`;
+	setCookie(event, name, mainCookieValue, options);
+	for (let i = 1; i <= chunkCount; i++) {
+		const start = (i - 1) * chunkMaxLength;
+		const end = start + chunkMaxLength;
+		const chunkValue = value.slice(start, end);
+		setCookie(event, chunkCookieName(name, i), chunkValue, options);
+	}
+}
+/**
 * Cookies are unique by "cookie-name, domain-value, and path-value".
 *
 * @see https://httpwg.org/specs/rfc6265.html#rfc.section.4.1.2
@@ -1706,6 +1796,13 @@ function _getDistinctCookieKey(name, options) {
 		options.path || "/"
 	].join(";");
 }
+function getChunkedCookieCount(cookie) {
+	if (!cookie?.startsWith(CHUNKED_COOKIE)) return Number.NaN;
+	return Number.parseInt(cookie.slice(CHUNKED_COOKIE.length));
+}
+function chunkCookieName(name, chunkNumber) {
+	return `${name}.${chunkNumber}`;
+}
 
 //#endregion
 //#region src/utils/internal/event-stream.ts
@@ -1748,6 +1845,18 @@ var EventStream = class {
 		}
 		await this._sendEvent(message);
 	}
+	async pushComment(comment) {
+		if (this._writerIsClosed) return;
+		if (this._paused && !this._unsentData) {
+			this._unsentData = formatEventStreamComment(comment);
+			return;
+		}
+		if (this._paused) {
+			this._unsentData += formatEventStreamComment(comment);
+			return;
+		}
+		await this._writer.write(this._encoder.encode(formatEventStreamComment(comment))).catch();
+	}
 	async _sendEvent(message) {
 		if (this._writerIsClosed) return;
 		if (this._paused && !this._unsentData) {
@@ -1814,6 +1923,9 @@ var EventStream = class {
 		return this._transformStream.readable;
 	}
 };
+function formatEventStreamComment(comment) {
+	return `: ${comment}\n\n`;
+}
 function formatEventStreamMessage(message) {
 	let result = "";
 	if (message.id) result += `id: ${message.id}\n`;
@@ -2294,10 +2406,12 @@ async function useSession(event, config) {
 	await getSession(event, config);
 	const sessionManager = {
 		get id() {
-			return event.context.sessions?.[sessionName]?.id;
+			const context = getEventContext(event);
+			return context?.sessions?.[sessionName]?.id;
 		},
 		get data() {
-			return event.context.sessions?.[sessionName]?.data || {};
+			const context = getEventContext(event);
+			return context.sessions?.[sessionName]?.data || {};
 		},
 		update: async (update) => {
 			await updateSession(event, config, update);
@@ -2315,29 +2429,30 @@ async function useSession(event, config) {
 */
 async function getSession(event, config) {
 	const sessionName = config.name || DEFAULT_SESSION_NAME;
-	if (!event.context.sessions) event.context.sessions = new EmptyObject();
-	const existingSession = event.context.sessions[sessionName];
+	const context = getEventContext(event);
+	if (!context.sessions) context.sessions = new EmptyObject();
+	const existingSession = context.sessions[sessionName];
 	if (existingSession) return existingSession[kGetSession] || existingSession;
 	const session = {
 		id: "",
 		createdAt: 0,
 		data: new EmptyObject()
 	};
-	event.context.sessions[sessionName] = session;
+	context.sessions[sessionName] = session;
 	let sealedSession;
 	if (config.sessionHeader !== false) {
 		const headerName = typeof config.sessionHeader === "string" ? config.sessionHeader.toLowerCase() : `x-${sessionName.toLowerCase()}-session`;
 		const headerValue = event.req.headers.get(headerName);
 		if (typeof headerValue === "string") sealedSession = headerValue;
 	}
-	if (!sealedSession) sealedSession = getCookie(event, sessionName);
+	if (!sealedSession) sealedSession = getChunkedCookie(event, sessionName);
 	if (sealedSession) {
 		const promise = unsealSession(event, config, sealedSession).catch(() => {}).then((unsealed) => {
 			Object.assign(session, unsealed);
-			delete event.context.sessions[sessionName][kGetSession];
+			delete context.sessions[sessionName][kGetSession];
 			return session;
 		});
-		event.context.sessions[sessionName][kGetSession] = promise;
+		context.sessions[sessionName][kGetSession] = promise;
 		await promise;
 	}
 	if (!session.id) {
@@ -2352,12 +2467,13 @@ async function getSession(event, config) {
 */
 async function updateSession(event, config, update) {
 	const sessionName = config.name || DEFAULT_SESSION_NAME;
-	const session = event.context.sessions?.[sessionName] || await getSession(event, config);
+	const context = getEventContext(event);
+	const session = context.sessions?.[sessionName] || await getSession(event, config);
 	if (typeof update === "function") update = update(session.data);
 	if (update) Object.assign(session.data, update);
-	if (config.cookie !== false) {
+	if (config.cookie !== false && event.res) {
 		const sealed = await sealSession(event, config);
-		setCookie(event, sessionName, sealed, {
+		setChunkedCookie(event, sessionName, sealed, {
 			...DEFAULT_SESSION_COOKIE,
 			expires: config.maxAge ? new Date(session.createdAt + config.maxAge * 1e3) : void 0,
 			...config.cookie
@@ -2370,7 +2486,8 @@ async function updateSession(event, config, update) {
 */
 async function sealSession(event, config) {
 	const sessionName = config.name || DEFAULT_SESSION_NAME;
-	const session = event.context.sessions?.[sessionName] || await getSession(event, config);
+	const context = getEventContext(event);
+	const session = context.sessions?.[sessionName] || await getSession(event, config);
 	const sealed = await seal(session, config.password, {
 		...defaults,
 		ttl: config.maxAge ? config.maxAge * 1e3 : 0,
@@ -2397,9 +2514,10 @@ async function unsealSession(_event, config, sealed) {
 * Clear the session data for the current request.
 */
 function clearSession(event, config) {
+	const context = getEventContext(event);
 	const sessionName = config.name || DEFAULT_SESSION_NAME;
-	if (event.context.sessions?.[sessionName]) delete event.context.sessions[sessionName];
-	setCookie(event, sessionName, "", {
+	if (context.sessions?.[sessionName]) delete context.sessions[sessionName];
+	if (event.res && config.cookie !== false) setChunkedCookie(event, sessionName, "", {
 		...DEFAULT_SESSION_COOKIE,
 		...config.cookie
 	});
@@ -2604,7 +2722,8 @@ async function requireBasicAuth(event, opts) {
 	if (opts.username && username !== opts.username) throw autheFailed(event, opts?.realm);
 	if (opts.password && password !== opts.password) throw autheFailed(event, opts?.realm);
 	if (opts.validate && !await opts.validate(username, password)) throw autheFailed(event, opts?.realm);
-	event.context.basicAuth = {
+	const context = getEventContext(event);
+	context.basicAuth = {
 		username,
 		password,
 		realm: opts.realm
@@ -2646,7 +2765,7 @@ async function getRequestFingerprint(event, opts = {}) {
 	const fingerprint = [];
 	if (opts.ip !== false) fingerprint.push(getRequestIP(event, { xForwardedFor: opts.xForwardedFor }));
 	if (opts.method === true) fingerprint.push(event.req.method);
-	if (opts.url === true) fingerprint.push(event.url.href);
+	if (opts.url === true) fingerprint.push(event.req.url);
 	if (opts.userAgent === true) fingerprint.push(event.req.headers.get("user-agent"));
 	const fingerprintString = fingerprint.filter(Boolean).join("|");
 	if (!fingerprintString) return null;
@@ -2839,4 +2958,4 @@ const createRouter$1 = (config) => new H3(config);
 const useBase = withBase;
 
 //#endregion
-export { H3, H3Core, H3Error, H3Event, HTTPError, appendCorsHeaders, appendCorsPreflightHeaders, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, basicAuth, clearResponseHeaders, clearSession, createApp, createError, createEventStream, createRouter$1 as createRouter, defaultContentType, defineEventHandler, defineHandler, defineLazyEventHandler, defineMiddleware, defineNodeHandler, defineNodeListener, defineNodeMiddleware, definePlugin, defineRoute, defineValidatedHandler, defineWebSocket, defineWebSocketHandler, deleteCookie, dynamicEventHandler, eventHandler, fetchWithEvent, freezeApp, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getBodyStream, getCookie, getHeader, getHeaders, getMethod, getProxyRequestHeaders, getQuery, getRequestFingerprint, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestPath, getRequestProtocol, getRequestURL, getRequestWebStream, getResponseHeader, getResponseHeaders, getResponseStatus, getResponseStatusText, getRouterParam, getRouterParams, getSession, getValidatedQuery, getValidatedRouterParams, handleCacheHeaders, handleCors, html, isCorsOriginAllowed, isError, isEvent, isMethod, isPreflightRequest, iterable, lazyEventHandler, mockEvent, noContent, onError, onRequest, onResponse, parseCookies, proxy, proxyRequest, readBody, readFormData, readFormDataBody, readMultipartFormData, readRawBody, readValidatedBody, redirect, removeResponseHeader, requireBasicAuth, sanitizeStatusCode, sanitizeStatusMessage, sealSession, sendIterable, sendNoContent, sendProxy, sendRedirect, sendStream, sendWebResponse, serveStatic, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, setResponseStatus, toEventHandler, toNodeHandler$1 as toNodeHandler, toNodeListener, toResponse, toWebHandler, unsealSession, updateSession, useBase, useSession, withBase, writeEarlyHints };
+export { H3, H3Core, H3Error, H3Event, HTTPError, appendCorsHeaders, appendCorsPreflightHeaders, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, basicAuth, clearResponseHeaders, clearSession, createApp, createError, createEventStream, createRouter$1 as createRouter, defaultContentType, defineEventHandler, defineHandler, defineLazyEventHandler, defineMiddleware, defineNodeHandler, defineNodeListener, defineNodeMiddleware, definePlugin, defineRoute, defineValidatedHandler, defineWebSocket, defineWebSocketHandler, deleteCookie, dynamicEventHandler, eventHandler, fetchWithEvent, freezeApp, fromNodeHandler, fromNodeMiddleware, fromWebHandler, getBodyStream, getCookie, getEventContext, getHeader, getHeaders, getMethod, getProxyRequestHeaders, getQuery, getRequestFingerprint, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestPath, getRequestProtocol, getRequestURL, getRequestWebStream, getResponseHeader, getResponseHeaders, getResponseStatus, getResponseStatusText, getRouterParam, getRouterParams, getSession, getValidatedQuery, getValidatedRouterParams, handleCacheHeaders, handleCors, html, isCorsOriginAllowed, isError, isEvent, isHTTPEvent, isMethod, isPreflightRequest, iterable, lazyEventHandler, mockEvent, noContent, onError, onRequest, onResponse, parseCookies, proxy, proxyRequest, readBody, readFormData, readFormDataBody, readMultipartFormData, readRawBody, readValidatedBody, redirect, removeResponseHeader, requireBasicAuth, sanitizeStatusCode, sanitizeStatusMessage, sealSession, sendIterable, sendNoContent, sendProxy, sendRedirect, sendStream, sendWebResponse, serveStatic, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, setResponseStatus, toEventHandler, toNodeHandler$1 as toNodeHandler, toNodeListener, toRequest, toResponse, toWebHandler, unsealSession, updateSession, useBase, useSession, withBase, writeEarlyHints };