h3 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,977 @@
+'use strict';
+
+const ufo = require('ufo');
+const radix3 = require('radix3');
+const destr = require('destr');
+const cookieEs = require('cookie-es');
+
+function useBase(base, handler) {
+  base = ufo.withoutTrailingSlash(base);
+  if (!base) {
+    return handler;
+  }
+  return eventHandler((event) => {
+    event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
+    event.node.req.url = ufo.withoutBase(event.node.req.url || "/", base);
+    return handler(event);
+  });
+}
+
+class H3Error extends Error {
+  constructor() {
+    super(...arguments);
+    this.statusCode = 500;
+    this.fatal = false;
+    this.unhandled = false;
+    this.statusMessage = void 0;
+  }
+  toJSON() {
+    const obj = {
+      message: this.message,
+      statusCode: this.statusCode
+    };
+    if (this.statusMessage) {
+      obj.statusMessage = this.statusMessage;
+    }
+    if (this.data !== void 0) {
+      obj.data = this.data;
+    }
+    return obj;
+  }
+}
+H3Error.__h3_error__ = true;
+function createError(input) {
+  if (typeof input === "string") {
+    return new H3Error(input);
+  }
+  if (isError(input)) {
+    return input;
+  }
+  const err = new H3Error(
+    input.message ?? input.statusMessage,
+    input.cause ? { cause: input.cause } : void 0
+  );
+  if ("stack" in input) {
+    try {
+      Object.defineProperty(err, "stack", {
+        get() {
+          return input.stack;
+        }
+      });
+    } catch {
+      try {
+        err.stack = input.stack;
+      } catch {
+      }
+    }
+  }
+  if (input.data) {
+    err.data = input.data;
+  }
+  if (input.statusCode) {
+    err.statusCode = input.statusCode;
+  } else if (input.status) {
+    err.statusCode = input.status;
+  }
+  if (input.statusMessage) {
+    err.statusMessage = input.statusMessage;
+  } else if (input.statusText) {
+    err.statusMessage = input.statusText;
+  }
+  if (input.fatal !== void 0) {
+    err.fatal = input.fatal;
+  }
+  if (input.unhandled !== void 0) {
+    err.unhandled = input.unhandled;
+  }
+  return err;
+}
+function sendError(event, error, debug) {
+  if (event.node.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.node.res.writableEnded) {
+    return;
+  }
+  const _code = Number.parseInt(h3Error.statusCode);
+  if (_code) {
+    event.node.res.statusCode = _code;
+  }
+  if (h3Error.statusMessage) {
+    event.node.res.statusMessage = h3Error.statusMessage;
+  }
+  event.node.res.setHeader("content-type", MIMES.json);
+  event.node.res.end(JSON.stringify(responseBody, void 0, 2));
+}
+function isError(input) {
+  return input?.constructor?.__h3_error__ === true;
+}
+
+function getQuery(event) {
+  return ufo.getQuery(event.node.req.url || "");
+}
+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.node.req.method || defaultMethod).toUpperCase();
+}
+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) {
+  const _headers = {};
+  for (const key in event.node.req.headers) {
+    const val = event.node.req.headers[key];
+    _headers[key] = Array.isArray(val) ? val.filter(Boolean).join(", ") : val;
+  }
+  return _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.for("h3RawBody");
+const ParsedBodySymbol = Symbol.for("h3ParsedBody");
+const PayloadMethods$1 = ["PATCH", "POST", "PUT", "DELETE"];
+function readRawBody(event, encoding = "utf8") {
+  assertMethod(event, PayloadMethods$1);
+  if (RawBodySymbol in event.node.req) {
+    const promise2 = Promise.resolve(event.node.req[RawBodySymbol]);
+    return encoding ? promise2.then((buff) => buff.toString(encoding)) : promise2;
+  }
+  if ("body" in event.node.req) {
+    return Promise.resolve(event.node.req.body);
+  }
+  if (!Number.parseInt(event.node.req.headers["content-length"] || "")) {
+    return Promise.resolve(void 0);
+  }
+  const promise = event.node.req[RawBodySymbol] = new Promise(
+    (resolve, reject) => {
+      const bodyData = [];
+      event.node.req.on("error", (err) => {
+        reject(err);
+      }).on("data", (chunk) => {
+        bodyData.push(chunk);
+      }).on("end", () => {
+        resolve(Buffer.concat(bodyData));
+      });
+    }
+  );
+  const result = encoding ? promise.then((buff) => buff.toString(encoding)) : promise;
+  return result;
+}
+async function readBody(event) {
+  if (ParsedBodySymbol in event.node.req) {
+    return event.node.req[ParsedBodySymbol];
+  }
+  const body = await readRawBody(event);
+  if (event.node.req.headers["content-type"] === "application/x-www-form-urlencoded") {
+    const form = new URLSearchParams(body);
+    const parsedForm = /* @__PURE__ */ Object.create(null);
+    for (const [key, value] of form.entries()) {
+      if (key in parsedForm) {
+        if (!Array.isArray(parsedForm[key])) {
+          parsedForm[key] = [parsedForm[key]];
+        }
+        parsedForm[key].push(value);
+      } else {
+        parsedForm[key] = value;
+      }
+    }
+    return parsedForm;
+  }
+  const json = destr(body);
+  event.node.req[ParsedBodySymbol] = json;
+  return json;
+}
+
+function handleCacheHeaders(event, opts) {
+  const cacheControls = ["public", ...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.node.req.headers["if-modified-since"];
+    event.node.res.setHeader("last-modified", modifiedTime.toUTCString());
+    if (ifModifiedSince && new Date(ifModifiedSince) >= opts.modifiedTime) {
+      cacheMatched = true;
+    }
+  }
+  if (opts.etag) {
+    event.node.res.setHeader("etag", opts.etag);
+    const ifNonMatch = event.node.req.headers["if-none-match"];
+    if (ifNonMatch === opts.etag) {
+      cacheMatched = true;
+    }
+  }
+  event.node.res.setHeader("cache-control", cacheControls.join(", "));
+  if (cacheMatched) {
+    event.node.res.statusCode = 304;
+    event.node.res.end();
+    return true;
+  }
+  return false;
+}
+
+const MIMES = {
+  html: "text/html",
+  json: "application/json"
+};
+
+const defer = typeof setImmediate !== "undefined" ? setImmediate : (fn) => fn();
+function send(event, data, type) {
+  if (type) {
+    defaultContentType(event, type);
+  }
+  return new Promise((resolve) => {
+    defer(() => {
+      event.node.res.end(data);
+      resolve();
+    });
+  });
+}
+function defaultContentType(event, type) {
+  if (type && !event.node.res.getHeader("content-type")) {
+    event.node.res.setHeader("content-type", type);
+  }
+}
+function sendRedirect(event, location, code = 302) {
+  event.node.res.statusCode = code;
+  event.node.res.setHeader("location", location);
+  const encodedLoc = location.replace(/"/g, "%22");
+  const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`;
+  return send(event, html, MIMES.html);
+}
+function getResponseHeaders(event) {
+  return event.node.res.getHeaders();
+}
+function getResponseHeader(event, name) {
+  return event.node.res.getHeader(name);
+}
+function setResponseHeaders(event, headers) {
+  for (const [name, value] of Object.entries(headers)) {
+    event.node.res.setHeader(name, value);
+  }
+}
+const setHeaders = setResponseHeaders;
+function setResponseHeader(event, name, value) {
+  event.node.res.setHeader(name, value);
+}
+const setHeader = setResponseHeader;
+function appendResponseHeaders(event, headers) {
+  for (const [name, value] of Object.entries(headers)) {
+    appendResponseHeader(event, name, value);
+  }
+}
+const appendHeaders = appendResponseHeaders;
+function appendResponseHeader(event, name, value) {
+  let current = event.node.res.getHeader(name);
+  if (!current) {
+    event.node.res.setHeader(name, value);
+    return;
+  }
+  if (!Array.isArray(current)) {
+    current = [current.toString()];
+  }
+  event.node.res.setHeader(name, [...current, 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.node.res);
+    data.on("end", () => resolve());
+    data.on("error", (error) => reject(createError(error)));
+  });
+}
+const noop = () => {
+};
+function writeEarlyHints(event, hints, cb = noop) {
+  if (!event.node.res.socket) {
+    cb();
+    return;
+  }
+  if (typeof hints === "string" || Array.isArray(hints)) {
+    hints = { link: hints };
+  }
+  if (hints.link) {
+    hints.link = Array.isArray(hints.link) ? hints.link : hints.link.split(",");
+  }
+  const headers = Object.entries(hints).map(
+    (e) => [e[0].toLowerCase(), e[1]]
+  );
+  if (headers.length === 0) {
+    cb();
+    return;
+  }
+  let hint = "HTTP/1.1 103 Early Hints";
+  if (hints.link) {
+    hint += `\r
+Link: ${hints.link.join(", ")}`;
+  }
+  for (const [header, value] of headers) {
+    if (header === "link") {
+      continue;
+    }
+    hint += `\r
+${header}: ${value}`;
+  }
+  if (event.node.res.socket) {
+    event.node.res.socket.write(
+      `${hint}\r
+\r
+`,
+      "utf8",
+      cb
+    );
+  } else {
+    cb();
+  }
+}
+
+function parseCookies(event) {
+  return cookieEs.parse(event.node.req.headers.cookie || "");
+}
+function getCookie(event, name) {
+  return parseCookies(event)[name];
+}
+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
+  });
+}
+
+const PayloadMethods = /* @__PURE__ */ new Set(["PATCH", "POST", "PUT", "DELETE"]);
+const ignoredHeaders = /* @__PURE__ */ new Set([
+  "transfer-encoding",
+  "connection",
+  "keep-alive",
+  "upgrade",
+  "expect"
+]);
+async function proxyRequest(event, target, opts = {}) {
+  const method = getMethod(event);
+  let body;
+  if (PayloadMethods.has(method)) {
+    body = await readRawBody(event).catch(() => void 0);
+  }
+  const headers = /* @__PURE__ */ Object.create(null);
+  const reqHeaders = getRequestHeaders(event);
+  for (const name in reqHeaders) {
+    if (!ignoredHeaders.has(name)) {
+      headers[name] = reqHeaders[name];
+    }
+  }
+  if (opts.fetchOptions?.headers) {
+    Object.assign(headers, opts.fetchOptions.headers);
+  }
+  if (opts.headers) {
+    Object.assign(headers, opts.headers);
+  }
+  return sendProxy(event, target, {
+    ...opts,
+    fetchOptions: {
+      headers,
+      method,
+      body,
+      ...opts.fetchOptions
+    }
+  });
+}
+async function sendProxy(event, target, opts = {}) {
+  const _fetch = opts.fetch || globalThis.fetch;
+  if (!_fetch) {
+    throw new Error(
+      "fetch is not available. Try importing `node-fetch-native/polyfill` for Node.js."
+    );
+  }
+  const response = await _fetch(target, {
+    headers: opts.headers,
+    ...opts.fetchOptions
+  });
+  event.node.res.statusCode = response.status;
+  event.node.res.statusMessage = response.statusText;
+  for (const [key, value] of response.headers.entries()) {
+    if (key === "content-encoding") {
+      continue;
+    }
+    if (key === "content-length") {
+      continue;
+    }
+    event.node.res.setHeader(key, value);
+  }
+  try {
+    if (response.body) {
+      if (opts.sendStream === false) {
+        const data = new Uint8Array(await response.arrayBuffer());
+        event.node.res.end(data);
+      } else {
+        for await (const chunk of response.body) {
+          event.node.res.write(chunk);
+        }
+        event.node.res.end();
+      }
+    }
+  } catch (error) {
+    event.node.res.end();
+    throw error;
+  }
+}
+
+class H3Headers {
+  constructor(init) {
+    if (!init) {
+      this._headers = {};
+    } else if (Array.isArray(init)) {
+      this._headers = Object.fromEntries(
+        init.map(([key, value]) => [key.toLowerCase(), value])
+      );
+    } else if (init && "append" in init) {
+      this._headers = Object.fromEntries(init.entries());
+    } else {
+      this._headers = Object.fromEntries(
+        Object.entries(init).map(([key, value]) => [key.toLowerCase(), value])
+      );
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  entries() {
+    throw Object.entries(this._headers)[Symbol.iterator]();
+  }
+  keys() {
+    return Object.keys(this._headers)[Symbol.iterator]();
+  }
+  values() {
+    throw Object.values(this._headers)[Symbol.iterator]();
+  }
+  append(name, value) {
+    const _name = name.toLowerCase();
+    this.set(_name, [this.get(_name), value].filter(Boolean).join(", "));
+  }
+  delete(name) {
+    delete this._headers[name.toLowerCase()];
+  }
+  get(name) {
+    return this._headers[name.toLowerCase()];
+  }
+  has(name) {
+    return name.toLowerCase() in this._headers;
+  }
+  set(name, value) {
+    this._headers[name.toLowerCase()] = String(value);
+  }
+  forEach(callbackfn) {
+    for (const [key, value] of Object.entries(this._headers)) {
+      callbackfn(value, key, this);
+    }
+  }
+}
+
+class H3Response {
+  constructor(body = null, init = {}) {
+    this.body = null;
+    this.type = "default";
+    this.bodyUsed = false;
+    this.headers = new H3Headers(init.headers);
+    this.status = init.status ?? 200;
+    this.statusText = init.statusText || "";
+    this.redirected = !!init.status && [301, 302, 307, 308].includes(init.status);
+    this._body = body;
+    this.url = "";
+    this.ok = this.status < 300 && this.status > 199;
+  }
+  clone() {
+    return new H3Response(this.body, {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText
+    });
+  }
+  arrayBuffer() {
+    return Promise.resolve(this._body);
+  }
+  blob() {
+    return Promise.resolve(this._body);
+  }
+  formData() {
+    return Promise.resolve(this._body);
+  }
+  json() {
+    return Promise.resolve(this._body);
+  }
+  text() {
+    return Promise.resolve(this._body);
+  }
+}
+
+class H3Event {
+  constructor(req, res) {
+    this["__is_event__"] = true;
+    this.context = {};
+    this.node = { req, res };
+  }
+  get path() {
+    return this.req.url;
+  }
+  get req() {
+    return this.node.req;
+  }
+  get res() {
+    return this.node.res;
+  }
+  respondWith(r) {
+    Promise.resolve(r).then((_response) => {
+      if (this.res.writableEnded) {
+        return;
+      }
+      const response = _response instanceof H3Response ? _response : new H3Response(_response);
+      for (const [key, value] of response.headers.entries()) {
+        this.res.setHeader(key, value);
+      }
+      if (response.status) {
+        this.res.statusCode = response.status;
+      }
+      if (response.statusText) {
+        this.res.statusMessage = response.statusText;
+      }
+      if (response.redirected) {
+        this.res.setHeader("location", response.url);
+      }
+      if (!response._body) {
+        return this.res.end();
+      }
+      if (typeof response._body === "string" || "buffer" in response._body || "byteLength" in response._body) {
+        return this.res.end(response._body);
+      }
+      if (!response.headers.has("content-type")) {
+        response.headers.set("content-type", MIMES.json);
+      }
+      this.res.end(JSON.stringify(response._body));
+    });
+  }
+}
+function isEvent(input) {
+  return "__is_event__" in input;
+}
+function createEvent(req, res) {
+  return new H3Event(req, res);
+}
+
+function defineEventHandler(handler) {
+  handler.__is_handler__ = true;
+  return handler;
+}
+const eventHandler = defineEventHandler;
+function isEventHandler(input) {
+  return "__is_handler__" in input;
+}
+function toEventHandler(input, _, _route) {
+  if (!isEventHandler(input)) {
+    console.warn(
+      "[h3] Implicit event handler conversion is deprecated. Use `eventHandler()` or `fromNodeMiddleware()` to define event handlers.",
+      _route && _route !== "/" ? `
+     Route: ${_route}` : "",
+      `
+     Handler: ${input}`
+    );
+  }
+  return input;
+}
+function dynamicEventHandler(initial) {
+  let current = initial;
+  const wrapper = eventHandler((event) => {
+    if (current) {
+      return current(event);
+    }
+  });
+  wrapper.set = (handler) => {
+    current = handler;
+  };
+  return wrapper;
+}
+function defineLazyEventHandler(factory) {
+  let _promise;
+  let _resolved;
+  const resolveHandler = () => {
+    if (_resolved) {
+      return Promise.resolve(_resolved);
+    }
+    if (!_promise) {
+      _promise = Promise.resolve(factory()).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 = toEventHandler(r.default || r);
+        return _resolved;
+      });
+    }
+    return _promise;
+  };
+  return eventHandler((event) => {
+    if (_resolved) {
+      return _resolved(event);
+    }
+    return resolveHandler().then((handler) => handler(event));
+  });
+}
+const lazyEventHandler = defineLazyEventHandler;
+
+function createApp(options = {}) {
+  const stack = [];
+  const handler = createAppEventHandler(stack, options);
+  const app = {
+    use: (arg1, arg2, arg3) => use(app, arg1, arg2, arg3),
+    handler,
+    stack,
+    options
+  };
+  return app;
+}
+function use(app, arg1, arg2, arg3) {
+  if (Array.isArray(arg1)) {
+    for (const i of arg1) {
+      use(app, i, arg2, arg3);
+    }
+  } else if (Array.isArray(arg2)) {
+    for (const i of arg2) {
+      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.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
+    const reqUrl = event.node.req.url || "/";
+    for (const layer of stack) {
+      if (layer.route.length > 1) {
+        if (!reqUrl.startsWith(layer.route)) {
+          continue;
+        }
+        event.node.req.url = reqUrl.slice(layer.route.length) || "/";
+      } else {
+        event.node.req.url = reqUrl;
+      }
+      if (layer.match && !layer.match(event.node.req.url, event)) {
+        continue;
+      }
+      const val = await layer.handler(event);
+      if (event.node.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.node.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, void 0, spacing),
+            MIMES.json
+          );
+        }
+      }
+    }
+    if (!event.node.res.writableEnded) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: `Cannot find any route matching ${event.node.req.url || "/"}.`
+      });
+    }
+  });
+}
+function normalizeLayer(input) {
+  let handler = input.handler;
+  if (handler.handler) {
+    handler = handler.handler;
+  }
+  if (input.lazy) {
+    handler = lazyEventHandler(handler);
+  } else if (!isEventHandler(handler)) {
+    handler = toEventHandler(handler, void 0, input.route);
+  }
+  return {
+    route: ufo.withoutTrailingSlash(input.route),
+    match: input.match,
+    handler
+  };
+}
+
+const defineNodeListener = (handler) => handler;
+const defineNodeMiddleware = (middleware) => middleware;
+function fromNodeMiddleware(handler) {
+  if (isEventHandler(handler)) {
+    return handler;
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError(
+      "Invalid handler. It should be a function:",
+      handler
+    );
+  }
+  return eventHandler((event) => {
+    return callNodeListener(
+      handler,
+      event.node.req,
+      event.node.res
+    );
+  });
+}
+function toNodeListener(app) {
+  const toNodeHandle = async function(req, res) {
+    const event = createEvent(req, res);
+    try {
+      await app.handler(event);
+    } catch (_error) {
+      const error = createError(_error);
+      if (!isError(_error)) {
+        error.unhandled = true;
+      }
+      if (app.options.onError) {
+        await app.options.onError(error, event);
+      } else {
+        if (error.unhandled || error.fatal) {
+          console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
+        }
+        await sendError(event, error, !!app.options.debug);
+      }
+    }
+  };
+  return toNodeHandle;
+}
+function promisifyNodeListener(handler) {
+  return function(req, res) {
+    return callNodeListener(handler, req, res);
+  };
+}
+function callNodeListener(handler, req, res) {
+  const isMiddleware = handler.length > 2;
+  return new Promise((resolve, reject) => {
+    const next = (err) => {
+      if (isMiddleware) {
+        res.off("close", next);
+        res.off("error", next);
+      }
+      return err ? reject(createError(err)) : resolve(void 0);
+    };
+    try {
+      const returned = handler(req, res, next);
+      if (isMiddleware && returned === void 0) {
+        res.once("close", next);
+        res.once("error", next);
+      } else {
+        resolve(returned);
+      }
+    } catch (error) {
+      next(error);
+    }
+  });
+}
+
+const RouterMethods = [
+  "connect",
+  "delete",
+  "get",
+  "head",
+  "options",
+  "post",
+  "put",
+  "trace",
+  "patch"
+];
+function createRouter(opts = {}) {
+  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)) {
+      for (const m of method) {
+        addRoute(path, handler, m);
+      }
+    } else {
+      route.handlers[method] = toEventHandler(handler, void 0, path);
+    }
+    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.node.req.url || "/";
+    const qIndex = path.indexOf("?");
+    if (qIndex !== -1) {
+      path = path.slice(0, Math.max(0, qIndex));
+    }
+    const matched = _router.lookup(path);
+    if (!matched || !matched.handlers) {
+      if (opts.preemptive || opts.preemtive) {
+        throw createError({
+          statusCode: 404,
+          name: "Not Found",
+          statusMessage: `Cannot find any route matching ${event.node.req.url || "/"}.`
+        });
+      } else {
+        return;
+      }
+    }
+    const method = (event.node.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.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.callNodeListener = callNodeListener;
+exports.createApp = createApp;
+exports.createAppEventHandler = createAppEventHandler;
+exports.createError = createError;
+exports.createEvent = createEvent;
+exports.createRouter = createRouter;
+exports.defaultContentType = defaultContentType;
+exports.defineEventHandler = defineEventHandler;
+exports.defineLazyEventHandler = defineLazyEventHandler;
+exports.defineNodeListener = defineNodeListener;
+exports.defineNodeMiddleware = defineNodeMiddleware;
+exports.deleteCookie = deleteCookie;
+exports.dynamicEventHandler = dynamicEventHandler;
+exports.eventHandler = eventHandler;
+exports.fromNodeMiddleware = fromNodeMiddleware;
+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.parseCookies = parseCookies;
+exports.promisifyNodeListener = promisifyNodeListener;
+exports.proxyRequest = proxyRequest;
+exports.readBody = readBody;
+exports.readRawBody = readRawBody;
+exports.send = send;
+exports.sendError = sendError;
+exports.sendProxy = sendProxy;
+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.toNodeListener = toNodeListener;
+exports.use = use;
+exports.useBase = useBase;
+exports.writeEarlyHints = writeEarlyHints;