h3 0.7.18 → 0.7.19

package/dist/index.cjs

@@ -2,9 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('destr');
-require('ufo');
-require('cookie-es');
+const ufo = require('ufo');
+const destr = require('destr');
+const cookieEs = require('cookie-es');
+const radix3 = require('radix3');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+const destr__default = /*#__PURE__*/_interopDefaultLegacy(destr);
 
 class H3Error extends Error {
   constructor() {
@@ -53,16 +58,247 @@ function createError(input) {
   }
   return err;
 }
+function sendError(event, error, debug) {
+  if (event.res.writableEnded) {
+    return;
+  }
+  const h3Error = isError(error) ? error : createError(error);
+  const responseBody = {
+    statusCode: h3Error.statusCode,
+    statusMessage: h3Error.statusMessage,
+    stack: [],
+    data: h3Error.data
+  };
+  if (debug) {
+    responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
+  }
+  if (event.res.writableEnded) {
+    return;
+  }
+  event.res.statusCode = h3Error.statusCode;
+  event.res.statusMessage = h3Error.statusMessage;
+  event.res.setHeader("Content-Type", MIMES.json);
+  event.res.end(JSON.stringify(responseBody, null, 2));
+}
 function isError(input) {
   return input?.constructor?.__h3_error__ === true;
 }
 
+function getQuery(event) {
+  return ufo.getQuery(event.req.url || "");
+}
+const useQuery = getQuery;
+function getRouterParams(event) {
+  return event.context.params || {};
+}
+function getRouterParam(event, name) {
+  const params = getRouterParams(event);
+  return params[name];
+}
+function getMethod(event, defaultMethod = "GET") {
+  return (event.req.method || defaultMethod).toUpperCase();
+}
+const useMethod = getMethod;
+function isMethod(event, expected, allowHead) {
+  const method = getMethod(event);
+  if (allowHead && method === "HEAD") {
+    return true;
+  }
+  if (typeof expected === "string") {
+    if (method === expected) {
+      return true;
+    }
+  } else if (expected.includes(method)) {
+    return true;
+  }
+  return false;
+}
+function assertMethod(event, expected, allowHead) {
+  if (!isMethod(event, expected, allowHead)) {
+    throw createError({
+      statusCode: 405,
+      statusMessage: "HTTP method is not allowed."
+    });
+  }
+}
+function getRequestHeaders(event) {
+  return event.req.headers;
+}
+const getHeaders = getRequestHeaders;
+function getRequestHeader(event, name) {
+  const headers = getRequestHeaders(event);
+  const value = headers[name.toLowerCase()];
+  return value;
+}
+const getHeader = getRequestHeader;
+
+const RawBodySymbol = Symbol("h3RawBody");
+const ParsedBodySymbol = Symbol("h3RawBody");
+const PayloadMethods = ["PATCH", "POST", "PUT", "DELETE"];
+function readRawBody(event, encoding = "utf-8") {
+  assertMethod(event, PayloadMethods);
+  if (RawBodySymbol in event.req) {
+    const promise2 = Promise.resolve(event.req[RawBodySymbol]);
+    return encoding ? promise2.then((buff) => buff.toString(encoding)) : promise2;
+  }
+  if ("body" in event.req) {
+    return Promise.resolve(event.req.body);
+  }
+  const promise = event.req[RawBodySymbol] = new Promise((resolve, reject) => {
+    const bodyData = [];
+    event.req.on("error", (err) => {
+      reject(err);
+    }).on("data", (chunk) => {
+      bodyData.push(chunk);
+    }).on("end", () => {
+      resolve(Buffer.concat(bodyData));
+    });
+  });
+  return encoding ? promise.then((buff) => buff.toString(encoding)) : promise;
+}
+const useRawBody = readRawBody;
+async function readBody(event) {
+  if (ParsedBodySymbol in event.req) {
+    return event.req[ParsedBodySymbol];
+  }
+  const body = await readRawBody(event);
+  if (event.req.headers["content-type"] === "application/x-www-form-urlencoded") {
+    const parsedForm = Object.fromEntries(new URLSearchParams(body));
+    return parsedForm;
+  }
+  const json = destr__default(body);
+  event.req[ParsedBodySymbol] = json;
+  return json;
+}
+const useBody = readBody;
+
+function handleCacheHeaders(event, opts) {
+  const cacheControls = ["public"].concat(opts.cacheControls || []);
+  let cacheMatched = false;
+  if (opts.maxAge !== void 0) {
+    cacheControls.push(`max-age=${+opts.maxAge}`, `s-maxage=${+opts.maxAge}`);
+  }
+  if (opts.modifiedTime) {
+    const modifiedTime = new Date(opts.modifiedTime);
+    const ifModifiedSince = event.req.headers["if-modified-since"];
+    event.res.setHeader("Last-Modified", modifiedTime.toUTCString());
+    if (ifModifiedSince) {
+      if (new Date(ifModifiedSince) >= opts.modifiedTime) {
+        cacheMatched = true;
+      }
+    }
+  }
+  if (opts.etag) {
+    event.res.setHeader("Etag", opts.etag);
+    const ifNonMatch = event.req.headers["if-none-match"];
+    if (ifNonMatch === opts.etag) {
+      cacheMatched = true;
+    }
+  }
+  event.res.setHeader("Cache-Control", cacheControls.join(", "));
+  if (cacheMatched) {
+    event.res.statusCode = 304;
+    event.res.end("");
+    return true;
+  }
+  return false;
+}
+
 const MIMES = {
   html: "text/html",
   json: "application/json"
 };
 
-typeof setImmediate !== "undefined" ? setImmediate : (fn) => fn();
+const defer = typeof setImmediate !== "undefined" ? setImmediate : (fn) => fn();
+function send(event, data, type) {
+  if (type) {
+    defaultContentType(event, type);
+  }
+  return new Promise((resolve) => {
+    defer(() => {
+      event.res.end(data);
+      resolve(void 0);
+    });
+  });
+}
+function defaultContentType(event, type) {
+  if (type && !event.res.getHeader("Content-Type")) {
+    event.res.setHeader("Content-Type", type);
+  }
+}
+function sendRedirect(event, location, code = 302) {
+  const encodedLoc = encodeURI(decodeURI(location));
+  event.res.statusCode = code;
+  event.res.setHeader("Location", encodedLoc);
+  const html = `<!DOCTYPE html>
+<html>
+  <head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head>
+  <body>Redirecting to <a href=${JSON.stringify(encodedLoc)}>${encodedLoc}</a></body>
+</html>`;
+  return send(event, html, MIMES.html);
+}
+function getResponseHeaders(event) {
+  return event.res.getHeaders();
+}
+function getResponseHeader(event, name) {
+  return event.res.getHeader(name);
+}
+function setResponseHeaders(event, headers) {
+  Object.entries(headers).forEach(([name, value]) => event.res.setHeader(name, value));
+}
+const setHeaders = setResponseHeaders;
+function setResponseHeader(event, name, value) {
+  event.res.setHeader(name, value);
+}
+const setHeader = setResponseHeader;
+function appendResponseHeaders(event, headers) {
+  Object.entries(headers).forEach(([name, value]) => appendResponseHeader(event, name, value));
+}
+const appendHeaders = appendResponseHeaders;
+function appendResponseHeader(event, name, value) {
+  let current = event.res.getHeader(name);
+  if (!current) {
+    event.res.setHeader(name, value);
+    return;
+  }
+  if (!Array.isArray(current)) {
+    current = [current.toString()];
+  }
+  event.res.setHeader(name, current.concat(value));
+}
+const appendHeader = appendResponseHeader;
+function isStream(data) {
+  return data && typeof data === "object" && typeof data.pipe === "function" && typeof data.on === "function";
+}
+function sendStream(event, data) {
+  return new Promise((resolve, reject) => {
+    data.pipe(event.res);
+    data.on("end", () => resolve(void 0));
+    data.on("error", (error) => reject(createError(error)));
+  });
+}
+
+function parseCookies(event) {
+  return cookieEs.parse(event.req.headers.cookie || "");
+}
+const useCookies = parseCookies;
+function getCookie(event, name) {
+  return parseCookies(event)[name];
+}
+const useCookie = getCookie;
+function setCookie(event, name, value, serializeOptions) {
+  const cookieStr = cookieEs.serialize(name, value, {
+    path: "/",
+    ...serializeOptions
+  });
+  appendHeader(event, "Set-Cookie", cookieStr);
+}
+function deleteCookie(event, name, serializeOptions) {
+  setCookie(event, name, "", {
+    ...serializeOptions,
+    maxAge: 0
+  });
+}
 
 class H3Headers {
   constructor(init) {
@@ -189,6 +425,15 @@ function createEvent(req, res) {
   return new H3Event(req, res);
 }
 
+const defineHandler = (handler) => handler;
+const defineHandle = defineHandler;
+const defineMiddleware = (middleware) => middleware;
+function promisifyHandler(handler) {
+  return function(req, res) {
+    return callHandler(handler, req, res);
+  };
+}
+const promisifyHandle = promisifyHandler;
 function callHandler(handler, req, res) {
   const isMiddleware = handler.length > 2;
   return new Promise((resolve, reject) => {
@@ -212,6 +457,30 @@ function callHandler(handler, req, res) {
     }
   });
 }
+function defineLazyHandler(handler, promisify) {
+  let _promise;
+  const resolve = () => {
+    if (!_promise) {
+      _promise = Promise.resolve(handler()).then((r) => promisify ? promisifyHandler(r.default || r) : r.default || r);
+    }
+    return _promise;
+  };
+  return function(req, res) {
+    return resolve().then((h) => h(req, res));
+  };
+}
+const lazyHandle = defineLazyHandler;
+function useBase(base, handler) {
+  base = ufo.withoutTrailingSlash(base);
+  if (!base) {
+    return handler;
+  }
+  return function(req, res) {
+    req.originalUrl = req.originalUrl || req.url || "/";
+    req.url = ufo.withoutBase(req.url || "/", base);
+    return handler(req, res);
+  };
+}
 
 function defineEventHandler(handler) {
   handler.__is_handler__ = true;
@@ -272,15 +541,228 @@ function defineLazyEventHandler(factory) {
 }
 const lazyEventHandler = defineLazyEventHandler;
 
+function createApp(options = {}) {
+  const stack = [];
+  const handler = createAppEventHandler(stack, options);
+  const nodeHandler = async function(req, res) {
+    const event = createEvent(req, res);
+    try {
+      await handler(event);
+    } catch (_error) {
+      const error = createError(_error);
+      if (!isError(_error)) {
+        error.unhandled = true;
+      }
+      if (options.onError) {
+        await options.onError(error, event);
+      } else {
+        if (error.unhandled || error.fatal) {
+          console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
+        }
+        await sendError(event, error, !!options.debug);
+      }
+    }
+  };
+  const app = nodeHandler;
+  app.nodeHandler = nodeHandler;
+  app.stack = stack;
+  app.handler = handler;
+  app.use = (arg1, arg2, arg3) => use(app, arg1, arg2, arg3);
+  return app;
+}
+function use(app, arg1, arg2, arg3) {
+  if (Array.isArray(arg1)) {
+    arg1.forEach((i) => use(app, i, arg2, arg3));
+  } else if (Array.isArray(arg2)) {
+    arg2.forEach((i) => use(app, arg1, i, arg3));
+  } else if (typeof arg1 === "string") {
+    app.stack.push(normalizeLayer({ ...arg3, route: arg1, handler: arg2 }));
+  } else if (typeof arg1 === "function") {
+    app.stack.push(normalizeLayer({ ...arg2, route: "/", handler: arg1 }));
+  } else {
+    app.stack.push(normalizeLayer({ ...arg1 }));
+  }
+  return app;
+}
+function createAppEventHandler(stack, options) {
+  const spacing = options.debug ? 2 : void 0;
+  return eventHandler(async (event) => {
+    event.req.originalUrl = event.req.originalUrl || event.req.url || "/";
+    const reqUrl = event.req.url || "/";
+    for (const layer of stack) {
+      if (layer.route.length > 1) {
+        if (!reqUrl.startsWith(layer.route)) {
+          continue;
+        }
+        event.req.url = reqUrl.slice(layer.route.length) || "/";
+      } else {
+        event.req.url = reqUrl;
+      }
+      if (layer.match && !layer.match(event.req.url, event)) {
+        continue;
+      }
+      const val = await layer.handler(event);
+      if (event.res.writableEnded) {
+        return;
+      }
+      const type = typeof val;
+      if (type === "string") {
+        return send(event, val, MIMES.html);
+      } else if (isStream(val)) {
+        return sendStream(event, val);
+      } else if (val === null) {
+        event.res.statusCode = 204;
+        return send(event);
+      } else if (type === "object" || type === "boolean" || type === "number") {
+        if (val.buffer) {
+          return send(event, val);
+        } else if (val instanceof Error) {
+          throw createError(val);
+        } else {
+          return send(event, JSON.stringify(val, null, spacing), MIMES.json);
+        }
+      }
+    }
+    if (!event.res.writableEnded) {
+      throw createError({ statusCode: 404, statusMessage: "Not Found" });
+    }
+  });
+}
+function normalizeLayer(input) {
+  let handler = input.handler || input.handle;
+  if (handler.handler) {
+    handler = handler.handler;
+  }
+  if (input.lazy) {
+    handler = lazyEventHandler(handler);
+  } else if (!isEventHandler(handler)) {
+    handler = toEventHandler(handler);
+  }
+  return {
+    route: ufo.withoutTrailingSlash(input.route),
+    match: input.match,
+    handler
+  };
+}
+
+const RouterMethods = ["connect", "delete", "get", "head", "options", "post", "put", "trace", "patch"];
+function createRouter() {
+  const _router = radix3.createRouter({});
+  const routes = {};
+  const router = {};
+  const addRoute = (path, handler, method) => {
+    let route = routes[path];
+    if (!route) {
+      routes[path] = route = { handlers: {} };
+      _router.insert(path, route);
+    }
+    if (Array.isArray(method)) {
+      method.forEach((m) => addRoute(path, handler, m));
+    } else {
+      route.handlers[method] = toEventHandler(handler);
+    }
+    return router;
+  };
+  router.use = router.add = (path, handler, method) => addRoute(path, handler, method || "all");
+  for (const method of RouterMethods) {
+    router[method] = (path, handle) => router.add(path, handle, method);
+  }
+  router.handler = eventHandler((event) => {
+    let path = event.req.url || "/";
+    const queryUrlIndex = path.lastIndexOf("?");
+    if (queryUrlIndex > -1) {
+      path = path.substring(0, queryUrlIndex);
+    }
+    const matched = _router.lookup(path);
+    if (!matched) {
+      throw createError({
+        statusCode: 404,
+        name: "Not Found",
+        statusMessage: `Cannot find any route matching ${event.req.url || "/"}.`
+      });
+    }
+    const method = (event.req.method || "get").toLowerCase();
+    const handler = matched.handlers[method] || matched.handlers.all;
+    if (!handler) {
+      throw createError({
+        statusCode: 405,
+        name: "Method Not Allowed",
+        statusMessage: `Method ${method} is not allowed on this route.`
+      });
+    }
+    const params = matched.params || {};
+    event.event.context.params = params;
+    event.req.context.params = params;
+    return handler(event);
+  });
+  return router;
+}
+
+exports.H3Error = H3Error;
 exports.H3Event = H3Event;
 exports.H3Headers = H3Headers;
 exports.H3Response = H3Response;
+exports.MIMES = MIMES;
+exports.appendHeader = appendHeader;
+exports.appendHeaders = appendHeaders;
+exports.appendResponseHeader = appendResponseHeader;
+exports.appendResponseHeaders = appendResponseHeaders;
+exports.assertMethod = assertMethod;
+exports.callHandler = callHandler;
+exports.createApp = createApp;
+exports.createAppEventHandler = createAppEventHandler;
+exports.createError = createError;
 exports.createEvent = createEvent;
+exports.createRouter = createRouter;
+exports.defaultContentType = defaultContentType;
 exports.defineEventHandler = defineEventHandler;
+exports.defineHandle = defineHandle;
+exports.defineHandler = defineHandler;
 exports.defineLazyEventHandler = defineLazyEventHandler;
+exports.defineLazyHandler = defineLazyHandler;
+exports.defineMiddleware = defineMiddleware;
+exports.deleteCookie = deleteCookie;
 exports.dynamicEventHandler = dynamicEventHandler;
 exports.eventHandler = eventHandler;
+exports.getCookie = getCookie;
+exports.getHeader = getHeader;
+exports.getHeaders = getHeaders;
+exports.getMethod = getMethod;
+exports.getQuery = getQuery;
+exports.getRequestHeader = getRequestHeader;
+exports.getRequestHeaders = getRequestHeaders;
+exports.getResponseHeader = getResponseHeader;
+exports.getResponseHeaders = getResponseHeaders;
+exports.getRouterParam = getRouterParam;
+exports.getRouterParams = getRouterParams;
+exports.handleCacheHeaders = handleCacheHeaders;
+exports.isError = isError;
 exports.isEvent = isEvent;
 exports.isEventHandler = isEventHandler;
+exports.isMethod = isMethod;
+exports.isStream = isStream;
 exports.lazyEventHandler = lazyEventHandler;
+exports.lazyHandle = lazyHandle;
+exports.parseCookies = parseCookies;
+exports.promisifyHandle = promisifyHandle;
+exports.promisifyHandler = promisifyHandler;
+exports.readBody = readBody;
+exports.readRawBody = readRawBody;
+exports.send = send;
+exports.sendError = sendError;
+exports.sendRedirect = sendRedirect;
+exports.sendStream = sendStream;
+exports.setCookie = setCookie;
+exports.setHeader = setHeader;
+exports.setHeaders = setHeaders;
+exports.setResponseHeader = setResponseHeader;
+exports.setResponseHeaders = setResponseHeaders;
 exports.toEventHandler = toEventHandler;
+exports.use = use;
+exports.useBase = useBase;
+exports.useBody = useBody;
+exports.useCookie = useCookie;
+exports.useCookies = useCookies;
+exports.useMethod = useMethod;
+exports.useQuery = useQuery;
+exports.useRawBody = useRawBody;

package/dist/index.d.ts

@@ -1,31 +1,6 @@
-import http from 'http';
-
-interface CompatibilityRequestProps {
-    event: H3Event;
-    context: H3EventContext;
-    /** Only available with connect and press */
-    originalUrl?: string;
-}
-interface IncomingMessage extends http.IncomingMessage, CompatibilityRequestProps {
-    req: H3Event['req'];
-    res: H3Event['res'];
-}
-interface ServerResponse extends http.ServerResponse {
-    event: H3Event;
-    res: H3Event['res'];
-    req: http.ServerResponse['req'] & CompatibilityRequestProps;
-}
-declare type Handler<T = any, ReqT = {}> = (req: IncomingMessage & ReqT, res: ServerResponse) => T;
-declare type Middleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any;
-interface H3EventContext extends Record<string, any> {
-}
-declare type HandlerResponse<T = any> = T | Promise<T>;
-interface EventHandler<T = any> {
-    '__is_handler__'?: true;
-    (event: H3Event): HandlerResponse<T>;
-}
-declare type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
-declare type CompatibilityEventHandler = EventHandler | Handler | Middleware;
+import http, { OutgoingMessage } from 'http';
+import { CookieSerializeOptions } from 'cookie-es';
+import * as ufo from 'ufo';
 
 declare class H3Headers implements Headers {
     _headers: Record<string, string>;
@@ -81,4 +56,256 @@ declare function dynamicEventHandler(initial?: EventHandler): DynamicEventHandle
 declare function defineLazyEventHandler(factory: LazyEventHandler): EventHandler;
 declare const lazyEventHandler: typeof defineLazyEventHandler;
 
-export { DynamicEventHandler, H3Event, H3Headers, H3Response, createEvent, defineEventHandler, defineLazyEventHandler, dynamicEventHandler, eventHandler, isEvent, isEventHandler, lazyEventHandler, toEventHandler };
+interface CompatibilityRequestProps {
+    event: H3Event;
+    context: H3EventContext;
+    /** Only available with connect and press */
+    originalUrl?: string;
+}
+interface IncomingMessage extends http.IncomingMessage, CompatibilityRequestProps {
+    req: H3Event['req'];
+    res: H3Event['res'];
+}
+interface ServerResponse extends http.ServerResponse {
+    event: H3Event;
+    res: H3Event['res'];
+    req: http.ServerResponse['req'] & CompatibilityRequestProps;
+}
+declare type Handler<T = any, ReqT = {}> = (req: IncomingMessage & ReqT, res: ServerResponse) => T;
+declare type PromisifiedHandler = Handler<Promise<any>>;
+declare type Middleware = (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => any;
+declare type LazyHandler = () => Handler | Promise<Handler>;
+declare type Encoding = false | 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'latin1' | 'binary' | 'hex';
+declare type HTTPMethod = 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE';
+interface H3EventContext extends Record<string, any> {
+}
+declare type CompatibilityEvent = H3Event | IncomingMessage;
+declare type HandlerResponse<T = any> = T | Promise<T>;
+interface EventHandler<T = any> {
+    '__is_handler__'?: true;
+    (event: H3Event): HandlerResponse<T>;
+}
+declare type LazyEventHandler = () => EventHandler | Promise<EventHandler>;
+declare type CompatibilityEventHandler = EventHandler | Handler | Middleware;
+
+interface Layer {
+    route: string;
+    match?: Matcher;
+    handler: EventHandler;
+}
+declare type Stack = Layer[];
+interface InputLayer {
+    route?: string;
+    match?: Matcher;
+    handler: Handler | LazyHandler | EventHandler | LazyEventHandler;
+    lazy?: boolean;
+    /** @deprecated */
+    handle?: Handler;
+    /** @deprecated */
+    promisify?: boolean;
+}
+declare type InputStack = InputLayer[];
+declare type Matcher = (url: string, event?: CompatibilityEvent) => boolean;
+interface AppUse {
+    (route: string | string[], handler: CompatibilityEventHandler | CompatibilityEventHandler[], options?: Partial<InputLayer>): App;
+    (handler: CompatibilityEventHandler | CompatibilityEventHandler[], options?: Partial<InputLayer>): App;
+    (options: InputLayer): App;
+}
+declare type NodeHandler = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+interface App extends NodeHandler {
+    stack: Stack;
+    handler: EventHandler;
+    nodeHandler: NodeHandler;
+    use: AppUse;
+}
+interface AppOptions {
+    debug?: boolean;
+    onError?: (error: Error, event: CompatibilityEvent) => any;
+}
+declare function createApp(options?: AppOptions): App;
+declare function use(app: App, arg1: string | Handler | InputLayer | InputLayer[], arg2?: Handler | Partial<InputLayer> | Handler[] | Middleware | Middleware[], arg3?: Partial<InputLayer>): App;
+declare function createAppEventHandler(stack: Stack, options: AppOptions): EventHandler<void>;
+
+/**
+ * H3 Runtime Error
+ * @class
+ * @extends Error
+ * @property {Number} statusCode An Integer indicating the HTTP response status code.
+ * @property {String} statusMessage A String representing the HTTP status message
+ * @property {String} fatal Indicates if the error is a fatal error.
+ * @property {String} unhandled Indicates if the error was unhandled and auto captured.
+ * @property {Any} data An extra data that will includes in the response.<br>
+ *  This can be used to pass additional information about the error.
+ * @property {Boolean} internal Setting this property to <code>true</code> will mark error as an internal error
+ */
+declare class H3Error extends Error {
+    static __h3_error__: boolean;
+    statusCode: number;
+    fatal: boolean;
+    unhandled: boolean;
+    statusMessage: string;
+    data?: any;
+}
+/**
+ * Creates new `Error` that can be used to handle both internal and runtime errors.
+ *
+ * @param input {Partial<H3Error>}
+ * @return {H3Error} An instance of the H3Error
+ */
+declare function createError(input: string | Partial<H3Error>): H3Error;
+/**
+ * Receive an error and return the corresponding response.<br>
+ *  H3 internally uses this function to handle unhandled errors.<br>
+ *  Note that calling this function will close the connection and no other data will be sent to client afterwards.
+ *
+ @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @param error {H3Error|Error} Raised error
+ * @param debug {Boolean} Whether application is in debug mode.<br>
+ *  In the debug mode the stack trace of errors will be return in response.
+ */
+declare function sendError(event: CompatibilityEvent, error: Error | H3Error, debug?: boolean): void;
+declare function isError(input: any): input is H3Error;
+
+declare const defineHandler: <T>(handler: Handler<T, {}>) => Handler<T, {}>;
+/** @deprecated Use defineHandler */
+declare const defineHandle: <T>(handler: Handler<T, {}>) => Handler<T, {}>;
+declare const defineMiddleware: (middleware: Middleware) => Middleware;
+declare function promisifyHandler(handler: Handler | Middleware): PromisifiedHandler;
+/** @deprecated Use defineHandler */
+declare const promisifyHandle: typeof promisifyHandler;
+declare function callHandler(handler: Middleware, req: IncomingMessage, res: ServerResponse): Promise<unknown>;
+declare function defineLazyHandler(handler: LazyHandler, promisify?: boolean): Handler;
+/** @deprecated Use defineLazyHandler */
+declare const lazyHandle: typeof defineLazyHandler;
+declare function useBase(base: string, handler: Handler): Handler;
+
+/**
+ * Reads body of the request and returns encoded raw string (default) or `Buffer` if encoding if falsy.
+ * @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @param encoding {Encoding} encoding="utf-8" - The character encoding to use.
+ *
+ * @return {String|Buffer} Encoded raw string or raw Buffer of the body
+ */
+declare function readRawBody(event: CompatibilityEvent, encoding?: Encoding): Encoding extends false ? Buffer : Promise<string | Buffer>;
+/** @deprecated Use `h3.readRawBody` */
+declare const useRawBody: typeof readRawBody;
+/**
+ * Reads request body and try to safely parse using [destr](https://github.com/unjs/destr)
+ * @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @param encoding {Encoding} encoding="utf-8" - The character encoding to use.
+ *
+ * @return {*} The `Object`, `Array`, `String`, `Number`, `Boolean`, or `null` value corresponding to the request JSON body
+ *
+ * ```ts
+ * const body = await useBody(req)
+ * ```
+ */
+declare function readBody<T = any>(event: CompatibilityEvent): Promise<T>;
+/** @deprecated Use `h3.readBody` */
+declare const useBody: typeof readBody;
+
+interface CacheConditions {
+    modifiedTime?: string | Date;
+    maxAge?: number;
+    etag?: string;
+    cacheControls?: string[];
+}
+/**
+ * Check request caching headers (`If-Modified-Since`) and add caching headers (Last-Modified, Cache-Control)
+ * Note: `public` cache control will be added by default
+ * @returns `true` when cache headers are matching. When `true` is returned, no reponse should be sent anymore
+ */
+declare function handleCacheHeaders(event: CompatibilityEvent, opts: CacheConditions): boolean;
+
+declare const MIMES: {
+    html: string;
+    json: string;
+};
+
+/**
+ * Parse the request to get HTTP Cookie header string and returning an object of all cookie name-value pairs.
+ * @param event {CompatibilityEvent} H3 event or req passed by h3 handler
+ * @returns Object of cookie name-value pairs
+ * ```ts
+ * const cookies = parseCookies(event)
+ * ```
+ */
+declare function parseCookies(event: CompatibilityEvent): Record<string, string>;
+/** @deprecated Use `h3.parseCookies` */
+declare const useCookies: typeof parseCookies;
+/**
+ * Get a cookie value by name.
+ * @param event {CompatibilityEvent} 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
+ * const authorization = useCookie(request, 'Authorization')
+ * ```
+ */
+declare function getCookie(event: CompatibilityEvent, name: string): string | undefined;
+/** @deprecated Use `h3.getCookie` */
+declare const useCookie: typeof getCookie;
+/**
+ * Set a cookie value by name.
+ * @param event {CompatibilityEvent} 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 serializeOptions {CookieSerializeOptions} Options for serializing the cookie
+ * ```ts
+ * setCookie(res, 'Authorization', '1234567')
+ * ```
+ */
+declare function setCookie(event: CompatibilityEvent, name: string, value: string, serializeOptions?: CookieSerializeOptions): void;
+/**
+ * Set a cookie value by name.
+ * @param event {CompatibilityEvent} H3 event or res passed by h3 handler
+ * @param name Name of the cookie to delete
+ * @param serializeOptions {CookieSerializeOptions} Cookie options
+ * ```ts
+ * deleteCookie(res, 'SessionId')
+ * ```
+ */
+declare function deleteCookie(event: CompatibilityEvent, name: string, serializeOptions?: CookieSerializeOptions): void;
+
+declare function getQuery(event: CompatibilityEvent): ufo.QueryObject;
+/** @deprecated Use `h3.getQuery` */
+declare const useQuery: typeof getQuery;
+declare function getRouterParams(event: CompatibilityEvent): CompatibilityEvent['context'];
+declare function getRouterParam(event: CompatibilityEvent, name: string): CompatibilityEvent['context'][string];
+declare function getMethod(event: CompatibilityEvent, defaultMethod?: HTTPMethod): HTTPMethod;
+/** @deprecated Use `h3.getMethod` */
+declare const useMethod: typeof getMethod;
+declare function isMethod(event: CompatibilityEvent, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): boolean;
+declare function assertMethod(event: CompatibilityEvent, expected: HTTPMethod | HTTPMethod[], allowHead?: boolean): void;
+declare function getRequestHeaders(event: CompatibilityEvent): CompatibilityEvent['req']['headers'];
+declare const getHeaders: typeof getRequestHeaders;
+declare function getRequestHeader(event: CompatibilityEvent, name: string): CompatibilityEvent['req']['headers'][string];
+declare const getHeader: typeof getRequestHeader;
+
+declare function send(event: CompatibilityEvent, data?: any, type?: string): Promise<void>;
+declare function defaultContentType(event: CompatibilityEvent, type?: string): void;
+declare function sendRedirect(event: CompatibilityEvent, location: string, code?: number): Promise<void>;
+declare function getResponseHeaders(event: CompatibilityEvent): ReturnType<CompatibilityEvent['res']['getHeaders']>;
+declare function getResponseHeader(event: CompatibilityEvent, name: string): ReturnType<CompatibilityEvent['res']['getHeader']>;
+declare function setResponseHeaders(event: CompatibilityEvent, headers: Record<string, Parameters<OutgoingMessage['setHeader']>[1]>): void;
+declare const setHeaders: typeof setResponseHeaders;
+declare function setResponseHeader(event: CompatibilityEvent, name: string, value: Parameters<OutgoingMessage['setHeader']>[1]): void;
+declare const setHeader: typeof setResponseHeader;
+declare function appendResponseHeaders(event: CompatibilityEvent, headers: Record<string, string>): void;
+declare const appendHeaders: typeof appendResponseHeaders;
+declare function appendResponseHeader(event: CompatibilityEvent, name: string, value: string): void;
+declare const appendHeader: typeof appendResponseHeader;
+declare function isStream(data: any): any;
+declare function sendStream(event: CompatibilityEvent, data: any): Promise<void>;
+
+declare type RouterMethod = Lowercase<HTTPMethod>;
+declare type RouterUse = (path: string, handler: CompatibilityEventHandler, method?: RouterMethod | RouterMethod[]) => Router;
+declare type AddRouteShortcuts = Record<RouterMethod, RouterUse>;
+interface Router extends AddRouteShortcuts {
+    add: RouterUse;
+    use: RouterUse;
+    handler: EventHandler;
+}
+declare function createRouter(): Router;
+
+export { AddRouteShortcuts, App, AppOptions, AppUse, CacheConditions, CompatibilityEvent, CompatibilityEventHandler, DynamicEventHandler, Encoding, EventHandler, H3Error, H3Event, H3EventContext, H3Headers, H3Response, HTTPMethod, Handler, HandlerResponse, IncomingMessage, InputLayer, InputStack, Layer, LazyEventHandler, LazyHandler, MIMES, Matcher, Middleware, NodeHandler, PromisifiedHandler, Router, RouterMethod, RouterUse, ServerResponse, Stack, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, dynamicEventHandler, eventHandler, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, lazyHandle, parseCookies, promisifyHandle, promisifyHandler, readBody, readRawBody, send, sendError, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import 'destr';
-import 'ufo';
-import 'cookie-es';
+import { getQuery as getQuery$1, withoutTrailingSlash, withoutBase } from 'ufo';
+import destr from 'destr';
+import { parse, serialize } from 'cookie-es';
+import { createRouter as createRouter$1 } from 'radix3';
 
 class H3Error extends Error {
   constructor() {
@@ -49,16 +50,247 @@ function createError(input) {
   }
   return err;
 }
+function sendError(event, error, debug) {
+  if (event.res.writableEnded) {
+    return;
+  }
+  const h3Error = isError(error) ? error : createError(error);
+  const responseBody = {
+    statusCode: h3Error.statusCode,
+    statusMessage: h3Error.statusMessage,
+    stack: [],
+    data: h3Error.data
+  };
+  if (debug) {
+    responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
+  }
+  if (event.res.writableEnded) {
+    return;
+  }
+  event.res.statusCode = h3Error.statusCode;
+  event.res.statusMessage = h3Error.statusMessage;
+  event.res.setHeader("Content-Type", MIMES.json);
+  event.res.end(JSON.stringify(responseBody, null, 2));
+}
 function isError(input) {
   return input?.constructor?.__h3_error__ === true;
 }
 
+function getQuery(event) {
+  return getQuery$1(event.req.url || "");
+}
+const useQuery = getQuery;
+function getRouterParams(event) {
+  return event.context.params || {};
+}
+function getRouterParam(event, name) {
+  const params = getRouterParams(event);
+  return params[name];
+}
+function getMethod(event, defaultMethod = "GET") {
+  return (event.req.method || defaultMethod).toUpperCase();
+}
+const useMethod = getMethod;
+function isMethod(event, expected, allowHead) {
+  const method = getMethod(event);
+  if (allowHead && method === "HEAD") {
+    return true;
+  }
+  if (typeof expected === "string") {
+    if (method === expected) {
+      return true;
+    }
+  } else if (expected.includes(method)) {
+    return true;
+  }
+  return false;
+}
+function assertMethod(event, expected, allowHead) {
+  if (!isMethod(event, expected, allowHead)) {
+    throw createError({
+      statusCode: 405,
+      statusMessage: "HTTP method is not allowed."
+    });
+  }
+}
+function getRequestHeaders(event) {
+  return event.req.headers;
+}
+const getHeaders = getRequestHeaders;
+function getRequestHeader(event, name) {
+  const headers = getRequestHeaders(event);
+  const value = headers[name.toLowerCase()];
+  return value;
+}
+const getHeader = getRequestHeader;
+
+const RawBodySymbol = Symbol("h3RawBody");
+const ParsedBodySymbol = Symbol("h3RawBody");
+const PayloadMethods = ["PATCH", "POST", "PUT", "DELETE"];
+function readRawBody(event, encoding = "utf-8") {
+  assertMethod(event, PayloadMethods);
+  if (RawBodySymbol in event.req) {
+    const promise2 = Promise.resolve(event.req[RawBodySymbol]);
+    return encoding ? promise2.then((buff) => buff.toString(encoding)) : promise2;
+  }
+  if ("body" in event.req) {
+    return Promise.resolve(event.req.body);
+  }
+  const promise = event.req[RawBodySymbol] = new Promise((resolve, reject) => {
+    const bodyData = [];
+    event.req.on("error", (err) => {
+      reject(err);
+    }).on("data", (chunk) => {
+      bodyData.push(chunk);
+    }).on("end", () => {
+      resolve(Buffer.concat(bodyData));
+    });
+  });
+  return encoding ? promise.then((buff) => buff.toString(encoding)) : promise;
+}
+const useRawBody = readRawBody;
+async function readBody(event) {
+  if (ParsedBodySymbol in event.req) {
+    return event.req[ParsedBodySymbol];
+  }
+  const body = await readRawBody(event);
+  if (event.req.headers["content-type"] === "application/x-www-form-urlencoded") {
+    const parsedForm = Object.fromEntries(new URLSearchParams(body));
+    return parsedForm;
+  }
+  const json = destr(body);
+  event.req[ParsedBodySymbol] = json;
+  return json;
+}
+const useBody = readBody;
+
+function handleCacheHeaders(event, opts) {
+  const cacheControls = ["public"].concat(opts.cacheControls || []);
+  let cacheMatched = false;
+  if (opts.maxAge !== void 0) {
+    cacheControls.push(`max-age=${+opts.maxAge}`, `s-maxage=${+opts.maxAge}`);
+  }
+  if (opts.modifiedTime) {
+    const modifiedTime = new Date(opts.modifiedTime);
+    const ifModifiedSince = event.req.headers["if-modified-since"];
+    event.res.setHeader("Last-Modified", modifiedTime.toUTCString());
+    if (ifModifiedSince) {
+      if (new Date(ifModifiedSince) >= opts.modifiedTime) {
+        cacheMatched = true;
+      }
+    }
+  }
+  if (opts.etag) {
+    event.res.setHeader("Etag", opts.etag);
+    const ifNonMatch = event.req.headers["if-none-match"];
+    if (ifNonMatch === opts.etag) {
+      cacheMatched = true;
+    }
+  }
+  event.res.setHeader("Cache-Control", cacheControls.join(", "));
+  if (cacheMatched) {
+    event.res.statusCode = 304;
+    event.res.end("");
+    return true;
+  }
+  return false;
+}
+
 const MIMES = {
   html: "text/html",
   json: "application/json"
 };
 
-typeof setImmediate !== "undefined" ? setImmediate : (fn) => fn();
+const defer = typeof setImmediate !== "undefined" ? setImmediate : (fn) => fn();
+function send(event, data, type) {
+  if (type) {
+    defaultContentType(event, type);
+  }
+  return new Promise((resolve) => {
+    defer(() => {
+      event.res.end(data);
+      resolve(void 0);
+    });
+  });
+}
+function defaultContentType(event, type) {
+  if (type && !event.res.getHeader("Content-Type")) {
+    event.res.setHeader("Content-Type", type);
+  }
+}
+function sendRedirect(event, location, code = 302) {
+  const encodedLoc = encodeURI(decodeURI(location));
+  event.res.statusCode = code;
+  event.res.setHeader("Location", encodedLoc);
+  const html = `<!DOCTYPE html>
+<html>
+  <head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head>
+  <body>Redirecting to <a href=${JSON.stringify(encodedLoc)}>${encodedLoc}</a></body>
+</html>`;
+  return send(event, html, MIMES.html);
+}
+function getResponseHeaders(event) {
+  return event.res.getHeaders();
+}
+function getResponseHeader(event, name) {
+  return event.res.getHeader(name);
+}
+function setResponseHeaders(event, headers) {
+  Object.entries(headers).forEach(([name, value]) => event.res.setHeader(name, value));
+}
+const setHeaders = setResponseHeaders;
+function setResponseHeader(event, name, value) {
+  event.res.setHeader(name, value);
+}
+const setHeader = setResponseHeader;
+function appendResponseHeaders(event, headers) {
+  Object.entries(headers).forEach(([name, value]) => appendResponseHeader(event, name, value));
+}
+const appendHeaders = appendResponseHeaders;
+function appendResponseHeader(event, name, value) {
+  let current = event.res.getHeader(name);
+  if (!current) {
+    event.res.setHeader(name, value);
+    return;
+  }
+  if (!Array.isArray(current)) {
+    current = [current.toString()];
+  }
+  event.res.setHeader(name, current.concat(value));
+}
+const appendHeader = appendResponseHeader;
+function isStream(data) {
+  return data && typeof data === "object" && typeof data.pipe === "function" && typeof data.on === "function";
+}
+function sendStream(event, data) {
+  return new Promise((resolve, reject) => {
+    data.pipe(event.res);
+    data.on("end", () => resolve(void 0));
+    data.on("error", (error) => reject(createError(error)));
+  });
+}
+
+function parseCookies(event) {
+  return parse(event.req.headers.cookie || "");
+}
+const useCookies = parseCookies;
+function getCookie(event, name) {
+  return parseCookies(event)[name];
+}
+const useCookie = getCookie;
+function setCookie(event, name, value, serializeOptions) {
+  const cookieStr = serialize(name, value, {
+    path: "/",
+    ...serializeOptions
+  });
+  appendHeader(event, "Set-Cookie", cookieStr);
+}
+function deleteCookie(event, name, serializeOptions) {
+  setCookie(event, name, "", {
+    ...serializeOptions,
+    maxAge: 0
+  });
+}
 
 class H3Headers {
   constructor(init) {
@@ -185,6 +417,15 @@ function createEvent(req, res) {
   return new H3Event(req, res);
 }
 
+const defineHandler = (handler) => handler;
+const defineHandle = defineHandler;
+const defineMiddleware = (middleware) => middleware;
+function promisifyHandler(handler) {
+  return function(req, res) {
+    return callHandler(handler, req, res);
+  };
+}
+const promisifyHandle = promisifyHandler;
 function callHandler(handler, req, res) {
   const isMiddleware = handler.length > 2;
   return new Promise((resolve, reject) => {
@@ -208,6 +449,30 @@ function callHandler(handler, req, res) {
     }
   });
 }
+function defineLazyHandler(handler, promisify) {
+  let _promise;
+  const resolve = () => {
+    if (!_promise) {
+      _promise = Promise.resolve(handler()).then((r) => promisify ? promisifyHandler(r.default || r) : r.default || r);
+    }
+    return _promise;
+  };
+  return function(req, res) {
+    return resolve().then((h) => h(req, res));
+  };
+}
+const lazyHandle = defineLazyHandler;
+function useBase(base, handler) {
+  base = withoutTrailingSlash(base);
+  if (!base) {
+    return handler;
+  }
+  return function(req, res) {
+    req.originalUrl = req.originalUrl || req.url || "/";
+    req.url = withoutBase(req.url || "/", base);
+    return handler(req, res);
+  };
+}
 
 function defineEventHandler(handler) {
   handler.__is_handler__ = true;
@@ -268,4 +533,161 @@ function defineLazyEventHandler(factory) {
 }
 const lazyEventHandler = defineLazyEventHandler;
 
-export { H3Event, H3Headers, H3Response, createEvent, defineEventHandler, defineLazyEventHandler, dynamicEventHandler, eventHandler, isEvent, isEventHandler, lazyEventHandler, toEventHandler };
+function createApp(options = {}) {
+  const stack = [];
+  const handler = createAppEventHandler(stack, options);
+  const nodeHandler = async function(req, res) {
+    const event = createEvent(req, res);
+    try {
+      await handler(event);
+    } catch (_error) {
+      const error = createError(_error);
+      if (!isError(_error)) {
+        error.unhandled = true;
+      }
+      if (options.onError) {
+        await options.onError(error, event);
+      } else {
+        if (error.unhandled || error.fatal) {
+          console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
+        }
+        await sendError(event, error, !!options.debug);
+      }
+    }
+  };
+  const app = nodeHandler;
+  app.nodeHandler = nodeHandler;
+  app.stack = stack;
+  app.handler = handler;
+  app.use = (arg1, arg2, arg3) => use(app, arg1, arg2, arg3);
+  return app;
+}
+function use(app, arg1, arg2, arg3) {
+  if (Array.isArray(arg1)) {
+    arg1.forEach((i) => use(app, i, arg2, arg3));
+  } else if (Array.isArray(arg2)) {
+    arg2.forEach((i) => use(app, arg1, i, arg3));
+  } else if (typeof arg1 === "string") {
+    app.stack.push(normalizeLayer({ ...arg3, route: arg1, handler: arg2 }));
+  } else if (typeof arg1 === "function") {
+    app.stack.push(normalizeLayer({ ...arg2, route: "/", handler: arg1 }));
+  } else {
+    app.stack.push(normalizeLayer({ ...arg1 }));
+  }
+  return app;
+}
+function createAppEventHandler(stack, options) {
+  const spacing = options.debug ? 2 : void 0;
+  return eventHandler(async (event) => {
+    event.req.originalUrl = event.req.originalUrl || event.req.url || "/";
+    const reqUrl = event.req.url || "/";
+    for (const layer of stack) {
+      if (layer.route.length > 1) {
+        if (!reqUrl.startsWith(layer.route)) {
+          continue;
+        }
+        event.req.url = reqUrl.slice(layer.route.length) || "/";
+      } else {
+        event.req.url = reqUrl;
+      }
+      if (layer.match && !layer.match(event.req.url, event)) {
+        continue;
+      }
+      const val = await layer.handler(event);
+      if (event.res.writableEnded) {
+        return;
+      }
+      const type = typeof val;
+      if (type === "string") {
+        return send(event, val, MIMES.html);
+      } else if (isStream(val)) {
+        return sendStream(event, val);
+      } else if (val === null) {
+        event.res.statusCode = 204;
+        return send(event);
+      } else if (type === "object" || type === "boolean" || type === "number") {
+        if (val.buffer) {
+          return send(event, val);
+        } else if (val instanceof Error) {
+          throw createError(val);
+        } else {
+          return send(event, JSON.stringify(val, null, spacing), MIMES.json);
+        }
+      }
+    }
+    if (!event.res.writableEnded) {
+      throw createError({ statusCode: 404, statusMessage: "Not Found" });
+    }
+  });
+}
+function normalizeLayer(input) {
+  let handler = input.handler || input.handle;
+  if (handler.handler) {
+    handler = handler.handler;
+  }
+  if (input.lazy) {
+    handler = lazyEventHandler(handler);
+  } else if (!isEventHandler(handler)) {
+    handler = toEventHandler(handler);
+  }
+  return {
+    route: withoutTrailingSlash(input.route),
+    match: input.match,
+    handler
+  };
+}
+
+const RouterMethods = ["connect", "delete", "get", "head", "options", "post", "put", "trace", "patch"];
+function createRouter() {
+  const _router = createRouter$1({});
+  const routes = {};
+  const router = {};
+  const addRoute = (path, handler, method) => {
+    let route = routes[path];
+    if (!route) {
+      routes[path] = route = { handlers: {} };
+      _router.insert(path, route);
+    }
+    if (Array.isArray(method)) {
+      method.forEach((m) => addRoute(path, handler, m));
+    } else {
+      route.handlers[method] = toEventHandler(handler);
+    }
+    return router;
+  };
+  router.use = router.add = (path, handler, method) => addRoute(path, handler, method || "all");
+  for (const method of RouterMethods) {
+    router[method] = (path, handle) => router.add(path, handle, method);
+  }
+  router.handler = eventHandler((event) => {
+    let path = event.req.url || "/";
+    const queryUrlIndex = path.lastIndexOf("?");
+    if (queryUrlIndex > -1) {
+      path = path.substring(0, queryUrlIndex);
+    }
+    const matched = _router.lookup(path);
+    if (!matched) {
+      throw createError({
+        statusCode: 404,
+        name: "Not Found",
+        statusMessage: `Cannot find any route matching ${event.req.url || "/"}.`
+      });
+    }
+    const method = (event.req.method || "get").toLowerCase();
+    const handler = matched.handlers[method] || matched.handlers.all;
+    if (!handler) {
+      throw createError({
+        statusCode: 405,
+        name: "Method Not Allowed",
+        statusMessage: `Method ${method} is not allowed on this route.`
+      });
+    }
+    const params = matched.params || {};
+    event.event.context.params = params;
+    event.req.context.params = params;
+    return handler(event);
+  });
+  return router;
+}
+
+export { H3Error, H3Event, H3Headers, H3Response, MIMES, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, dynamicEventHandler, eventHandler, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, lazyHandle, parseCookies, promisifyHandle, promisifyHandler, readBody, readRawBody, send, sendError, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h3",
-  "version": "0.7.18",
+  "version": "0.7.19",
   "description": "Tiny JavaScript Server",
   "repository": "unjs/h3",
   "license": "MIT",
@@ -12,9 +12,9 @@
       "require": "./dist/index.cjs"
     }
   },
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],