h3 0.8.6 → 1.0.1

package/dist/index.mjs

@@ -9,8 +9,8 @@ function useBase(base, handler) {
     return handler;
   }
   return eventHandler((event) => {
-    event.req.originalUrl = event.req.originalUrl || event.req.url || "/";
-    event.req.url = withoutBase(event.req.url || "/", base);
+    event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
+    event.node.req.url = withoutBase(event.node.req.url || "/", base);
     return handler(event);
   });
 }
@@ -80,7 +80,7 @@ function createError(input) {
   return err;
 }
 function sendError(event, error, debug) {
-  if (event.res.writableEnded) {
+  if (event.node.res.writableEnded) {
     return;
   }
   const h3Error = isError(error) ? error : createError(error);
@@ -93,27 +93,26 @@ function sendError(event, error, debug) {
   if (debug) {
     responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
   }
-  if (event.res.writableEnded) {
+  if (event.node.res.writableEnded) {
     return;
   }
-  const _code = parseInt(h3Error.statusCode);
+  const _code = Number.parseInt(h3Error.statusCode);
   if (_code) {
-    event.res.statusCode = _code;
+    event.node.res.statusCode = _code;
   }
   if (h3Error.statusMessage) {
-    event.res.statusMessage = h3Error.statusMessage;
+    event.node.res.statusMessage = h3Error.statusMessage;
   }
-  event.res.setHeader("content-type", MIMES.json);
-  event.res.end(JSON.stringify(responseBody, null, 2));
+  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 getQuery$1(event.req.url || "");
+  return getQuery$1(event.node.req.url || "");
 }
-const useQuery = getQuery;
 function getRouterParams(event) {
   return event.context.params || {};
 }
@@ -122,9 +121,8 @@ function getRouterParam(event, name) {
   return params[name];
 }
 function getMethod(event, defaultMethod = "GET") {
-  return (event.req.method || defaultMethod).toUpperCase();
+  return (event.node.req.method || defaultMethod).toUpperCase();
 }
-const useMethod = getMethod;
 function isMethod(event, expected, allowHead) {
   const method = getMethod(event);
   if (allowHead && method === "HEAD") {
@@ -149,8 +147,8 @@ function assertMethod(event, expected, allowHead) {
 }
 function getRequestHeaders(event) {
   const _headers = {};
-  for (const key in event.req.headers) {
-    const val = event.req.headers[key];
+  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;
@@ -165,22 +163,22 @@ const getHeader = getRequestHeader;
 
 const RawBodySymbol = Symbol.for("h3RawBody");
 const ParsedBodySymbol = Symbol.for("h3ParsedBody");
-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]);
+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.req) {
-    return Promise.resolve(event.req.body);
+  if ("body" in event.node.req) {
+    return Promise.resolve(event.node.req.body);
   }
-  if (!parseInt(event.req.headers["content-length"] || "")) {
+  if (!Number.parseInt(event.node.req.headers["content-length"] || "")) {
     return Promise.resolve(void 0);
   }
-  const promise = event.req[RawBodySymbol] = new Promise((resolve, reject) => {
+  const promise = event.node.req[RawBodySymbol] = new Promise((resolve, reject) => {
     const bodyData = [];
-    event.req.on("error", (err) => {
+    event.node.req.on("error", (err) => {
       reject(err);
     }).on("data", (chunk) => {
       bodyData.push(chunk);
@@ -190,49 +188,45 @@ function readRawBody(event, encoding = "utf-8") {
   });
   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];
+  if (ParsedBodySymbol in event.node.req) {
+    return event.node.req[ParsedBodySymbol];
   }
   const body = await readRawBody(event);
-  if (event.req.headers["content-type"] === "application/x-www-form-urlencoded") {
+  if (event.node.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;
+  event.node.req[ParsedBodySymbol] = json;
   return json;
 }
-const useBody = readBody;
 
 function handleCacheHeaders(event, opts) {
-  const cacheControls = ["public"].concat(opts.cacheControls || []);
+  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.req.headers["if-modified-since"];
-    event.res.setHeader("last-modified", modifiedTime.toUTCString());
-    if (ifModifiedSince) {
-      if (new Date(ifModifiedSince) >= opts.modifiedTime) {
-        cacheMatched = true;
-      }
+    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.res.setHeader("etag", opts.etag);
-    const ifNonMatch = event.req.headers["if-none-match"];
+    event.node.res.setHeader("etag", opts.etag);
+    const ifNonMatch = event.node.req.headers["if-none-match"];
     if (ifNonMatch === opts.etag) {
       cacheMatched = true;
     }
   }
-  event.res.setHeader("cache-control", cacheControls.join(", "));
+  event.node.res.setHeader("cache-control", cacheControls.join(", "));
   if (cacheMatched) {
-    event.res.statusCode = 304;
-    event.res.end();
+    event.node.res.statusCode = 304;
+    event.node.res.end();
     return true;
   }
   return false;
@@ -250,51 +244,55 @@ function send(event, data, type) {
   }
   return new Promise((resolve) => {
     defer(() => {
-      event.res.end(data);
-      resolve(void 0);
+      event.node.res.end(data);
+      resolve();
     });
   });
 }
 function defaultContentType(event, type) {
-  if (type && !event.res.getHeader("content-type")) {
-    event.res.setHeader("content-type", type);
+  if (type && !event.node.res.getHeader("content-type")) {
+    event.node.res.setHeader("content-type", type);
   }
 }
 function sendRedirect(event, location, code = 302) {
-  event.res.statusCode = code;
-  event.res.setHeader("location", location);
+  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.res.getHeaders();
+  return event.node.res.getHeaders();
 }
 function getResponseHeader(event, name) {
-  return event.res.getHeader(name);
+  return event.node.res.getHeader(name);
 }
 function setResponseHeaders(event, headers) {
-  Object.entries(headers).forEach(([name, value]) => event.res.setHeader(name, value));
+  for (const [name, value] of Object.entries(headers)) {
+    event.node.res.setHeader(name, value);
+  }
 }
 const setHeaders = setResponseHeaders;
 function setResponseHeader(event, name, value) {
-  event.res.setHeader(name, value);
+  event.node.res.setHeader(name, value);
 }
 const setHeader = setResponseHeader;
 function appendResponseHeaders(event, headers) {
-  Object.entries(headers).forEach(([name, value]) => appendResponseHeader(event, name, value));
+  for (const [name, value] of Object.entries(headers)) {
+    appendResponseHeader(event, name, value);
+  }
 }
 const appendHeaders = appendResponseHeaders;
 function appendResponseHeader(event, name, value) {
-  let current = event.res.getHeader(name);
+  let current = event.node.res.getHeader(name);
   if (!current) {
-    event.res.setHeader(name, value);
+    event.node.res.setHeader(name, value);
     return;
   }
   if (!Array.isArray(current)) {
     current = [current.toString()];
   }
-  event.res.setHeader(name, current.concat(value));
+  event.node.res.setHeader(name, [...current, value]);
 }
 const appendHeader = appendResponseHeader;
 function isStream(data) {
@@ -302,15 +300,15 @@ function isStream(data) {
 }
 function sendStream(event, data) {
   return new Promise((resolve, reject) => {
-    data.pipe(event.res);
-    data.on("end", () => resolve(void 0));
+    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.res.socket) {
+  if (!event.node.res.socket) {
     cb();
     return;
   }
@@ -321,7 +319,7 @@ function writeEarlyHints(event, hints, cb = noop) {
     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) {
+  if (headers.length === 0) {
     cb();
     return;
   }
@@ -337,19 +335,17 @@ Link: ${hints.link.join(", ")}`;
     hint += `\r
 ${header}: ${value}`;
   }
-  event.res.socket.write(`${hint}\r
+  event.node.res.socket.write(`${hint}\r
 \r
-`, "utf-8", cb);
+`, "utf8", cb);
 }
 
 function parseCookies(event) {
-  return parse(event.req.headers.cookie || "");
+  return parse(event.node.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: "/",
@@ -364,6 +360,43 @@ function deleteCookie(event, name, serializeOptions) {
   });
 }
 
+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) {
@@ -373,8 +406,8 @@ async function sendProxy(event, target, opts = {}) {
     headers: opts.headers,
     ...opts.fetchOptions
   });
-  event.res.statusCode = response.status;
-  event.res.statusMessage = response.statusText;
+  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;
@@ -382,23 +415,23 @@ async function sendProxy(event, target, opts = {}) {
     if (key === "content-length") {
       continue;
     }
-    event.res.setHeader(key, value);
+    event.node.res.setHeader(key, value);
   }
   try {
     if (response.body) {
       if (opts.sendStream === false) {
         const data = new Uint8Array(await response.arrayBuffer());
-        event.res.end(data);
+        event.node.res.end(data);
       } else {
         for await (const chunk of response.body) {
-          event.res.write(chunk);
+          event.node.res.write(chunk);
         }
-        event.res.end();
+        event.node.res.end();
       }
     }
-  } catch (err) {
-    event.res.end();
-    throw err;
+  } catch (error) {
+    event.node.res.end();
+    throw error;
   }
 }
 
@@ -409,7 +442,7 @@ class H3Headers {
     } 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()]);
+      this._headers = Object.fromEntries(init.entries());
     } else {
       this._headers = Object.fromEntries(Object.entries(init).map(([key, value]) => [key.toLowerCase(), value]));
     }
@@ -443,7 +476,9 @@ class H3Headers {
     this._headers[name.toLowerCase()] = String(value);
   }
   forEach(callbackfn) {
-    Object.entries(this._headers).forEach(([key, value]) => callbackfn(value, key, this));
+    for (const [key, value] of Object.entries(this._headers)) {
+      callbackfn(value, key, this);
+    }
   }
 }
 
@@ -488,8 +523,16 @@ class H3Event {
   constructor(req, res) {
     this["__is_event__"] = true;
     this.context = {};
-    this.req = req;
-    this.res = res;
+    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) => {
@@ -497,9 +540,9 @@ class H3Event {
         return;
       }
       const response = _response instanceof H3Response ? _response : new H3Response(_response);
-      response.headers.forEach((value, key) => {
+      for (const [key, value] of response.headers.entries()) {
         this.res.setHeader(key, value);
-      });
+      }
       if (response.status) {
         this.res.statusCode = response.status;
       }
@@ -602,9 +645,13 @@ function createApp(options = {}) {
 }
 function use(app, arg1, arg2, arg3) {
   if (Array.isArray(arg1)) {
-    arg1.forEach((i) => use(app, i, arg2, arg3));
+    for (const i of arg1) {
+      use(app, i, arg2, arg3);
+    }
   } else if (Array.isArray(arg2)) {
-    arg2.forEach((i) => use(app, arg1, i, arg3));
+    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") {
@@ -617,22 +664,22 @@ function use(app, arg1, arg2, arg3) {
 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 || "/";
+    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.req.url = reqUrl.slice(layer.route.length) || "/";
+        event.node.req.url = reqUrl.slice(layer.route.length) || "/";
       } else {
-        event.req.url = reqUrl;
+        event.node.req.url = reqUrl;
       }
-      if (layer.match && !layer.match(event.req.url, event)) {
+      if (layer.match && !layer.match(event.node.req.url, event)) {
         continue;
       }
       const val = await layer.handler(event);
-      if (event.res.writableEnded) {
+      if (event.node.res.writableEnded) {
         return;
       }
       const type = typeof val;
@@ -641,7 +688,7 @@ function createAppEventHandler(stack, options) {
       } else if (isStream(val)) {
         return sendStream(event, val);
       } else if (val === null) {
-        event.res.statusCode = 204;
+        event.node.res.statusCode = 204;
         return send(event);
       } else if (type === "object" || type === "boolean" || type === "number") {
         if (val.buffer) {
@@ -649,14 +696,14 @@ function createAppEventHandler(stack, options) {
         } else if (val instanceof Error) {
           throw createError(val);
         } else {
-          return send(event, JSON.stringify(val, null, spacing), MIMES.json);
+          return send(event, JSON.stringify(val, void 0, spacing), MIMES.json);
         }
       }
     }
-    if (!event.res.writableEnded) {
+    if (!event.node.res.writableEnded) {
       throw createError({
         statusCode: 404,
-        statusMessage: `Cannot find any route matching ${event.req.url || "/"}.`
+        statusMessage: `Cannot find any route matching ${event.node.req.url || "/"}.`
       });
     }
   });
@@ -669,7 +716,7 @@ function normalizeLayer(input) {
   if (input.lazy) {
     handler = lazyEventHandler(handler);
   } else if (!isEventHandler(handler)) {
-    handler = toEventHandler(handler, null, input.route);
+    handler = toEventHandler(handler, void 0, input.route);
   }
   return {
     route: withoutTrailingSlash(input.route),
@@ -688,7 +735,7 @@ function fromNodeMiddleware(handler) {
     throw new TypeError("Invalid handler. It should be a function:", handler);
   }
   return eventHandler((event) => {
-    return callNodeListener(handler, event.req, event.res);
+    return callNodeListener(handler, event.node.req, event.node.res);
   });
 }
 function toNodeListener(app) {
@@ -736,8 +783,8 @@ function callNodeListener(handler, req, res) {
       } else {
         resolve(returned);
       }
-    } catch (err) {
-      next(err);
+    } catch (error) {
+      next(error);
     }
   });
 }
@@ -754,9 +801,11 @@ function createRouter(opts = {}) {
       _router.insert(path, route);
     }
     if (Array.isArray(method)) {
-      method.forEach((m) => addRoute(path, handler, m));
+      for (const m of method) {
+        addRoute(path, handler, m);
+      }
     } else {
-      route.handlers[method] = toEventHandler(handler, null, path);
+      route.handlers[method] = toEventHandler(handler, void 0, path);
     }
     return router;
   };
@@ -765,10 +814,10 @@ function createRouter(opts = {}) {
     router[method] = (path, handle) => router.add(path, handle, method);
   }
   router.handler = eventHandler((event) => {
-    let path = event.req.url || "/";
+    let path = event.node.req.url || "/";
     const qIndex = path.indexOf("?");
     if (qIndex !== -1) {
-      path = path.substring(0, qIndex);
+      path = path.slice(0, Math.max(0, qIndex));
     }
     const matched = _router.lookup(path);
     if (!matched) {
@@ -776,13 +825,13 @@ function createRouter(opts = {}) {
         throw createError({
           statusCode: 404,
           name: "Not Found",
-          statusMessage: `Cannot find any route matching ${event.req.url || "/"}.`
+          statusMessage: `Cannot find any route matching ${event.node.req.url || "/"}.`
         });
       } else {
         return;
       }
     }
-    const method = (event.req.method || "get").toLowerCase();
+    const method = (event.node.req.method || "get").toLowerCase();
     const handler = matched.handlers[method] || matched.handlers.all;
     if (!handler) {
       throw createError({
@@ -798,4 +847,4 @@ function createRouter(opts = {}) {
   return router;
 }
 
-export { H3Error, H3Event, H3Headers, H3Response, MIMES, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callNodeListener, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, deleteCookie, dynamicEventHandler, eventHandler, fromNodeMiddleware, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, parseCookies, promisifyNodeListener, readBody, readRawBody, send, sendError, sendProxy, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, toNodeListener, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody, writeEarlyHints };
+export { H3Error, H3Event, H3Headers, H3Response, MIMES, appendHeader, appendHeaders, appendResponseHeader, appendResponseHeaders, assertMethod, callNodeListener, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineLazyEventHandler, defineNodeListener, defineNodeMiddleware, deleteCookie, dynamicEventHandler, eventHandler, fromNodeMiddleware, getCookie, getHeader, getHeaders, getMethod, getQuery, getRequestHeader, getRequestHeaders, getResponseHeader, getResponseHeaders, getRouterParam, getRouterParams, handleCacheHeaders, isError, isEvent, isEventHandler, isMethod, isStream, lazyEventHandler, parseCookies, promisifyNodeListener, proxyRequest, readBody, readRawBody, send, sendError, sendProxy, sendRedirect, sendStream, setCookie, setHeader, setHeaders, setResponseHeader, setResponseHeaders, toEventHandler, toNodeListener, use, useBase, writeEarlyHints };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h3",
-  "version": "0.8.6",
+  "version": "1.0.1",
   "description": "Tiny JavaScript Server",
   "repository": "unjs/h3",
   "license": "MIT",
@@ -19,41 +19,41 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --ext ts,mjs,cjs .",
+    "play": "jiti ./playground/index.ts",
+    "profile": "0x -o -D .profile -P 'autocannon -c 100 -p 10 -d 40 http://localhost:$PORT' ./playground/server.cjs",
+    "release": "pnpm test && pnpm build && changelogen --release && pnpm publish && git push --follow-tags",
+    "test": "pnpm lint && vitest run --coverage"
+  },
   "dependencies": {
     "cookie-es": "^0.5.0",
-    "destr": "^1.2.0",
-    "radix3": "^0.2.1",
-    "ufo": "^0.8.6"
+    "destr": "^1.2.1",
+    "radix3": "^1.0.0",
+    "ufo": "^1.0.0"
   },
   "devDependencies": {
     "0x": "^5.4.1",
-    "@nuxtjs/eslint-config-typescript": "^11.0.0",
     "@types/express": "^4.17.14",
-    "@types/node": "^18.11.7",
+    "@types/node": "^18.11.9",
     "@types/supertest": "^2.0.12",
-    "@vitest/coverage-c8": "^0.24.3",
+    "@vitest/coverage-c8": "^0.25.2",
     "autocannon": "^7.10.0",
-    "changelogen": "^0.3.5",
+    "changelogen": "^0.4.0",
     "connect": "^3.7.0",
-    "eslint": "^8.26.0",
+    "eslint": "^8.27.0",
+    "eslint-config-unjs": "^0.0.2",
     "express": "^4.18.2",
     "get-port": "^6.1.2",
     "jiti": "^1.16.0",
-    "listhen": "^0.3.4",
-    "node-fetch-native": "^0.1.8",
+    "listhen": "^1.0.0",
+    "node-fetch-native": "^1.0.1",
     "supertest": "^6.3.1",
     "typescript": "^4.8.4",
     "unbuild": "^0.9.4",
-    "vitest": "^0.24.3"
+    "vitest": "^0.25.2"
   },
-  "packageManager": "pnpm@7.14.0",
-  "scripts": {
-    "build": "unbuild",
-    "dev": "vitest",
-    "lint": "eslint --ext ts,mjs,cjs .",
-    "play": "jiti ./playground/index.ts",
-    "profile": "0x -o -D .profile -P 'autocannon -c 100 -p 10 -d 40 http://localhost:$PORT' ./playground/server.cjs",
-    "release": "pnpm test && pnpm build && changelogen --release && pnpm publish && git push --follow-tags",
-    "test": "pnpm lint && vitest run --coverage"
-  }
-}
+  "packageManager": "pnpm@7.16.0"
+}