hono 4.0.10 → 4.1.0

package/dist/jsx/hooks/index.js

@@ -97,7 +97,6 @@ var setShadow = (node) => {
   node.s?.forEach(setShadow);
 };
 var useState = (initialState) => {
-  var _a;
   const resolveInitialState = () => typeof initialState === "function" ? initialState() : initialState;
   const buildData = buildDataStack.at(-1);
   if (!buildData) {
@@ -105,9 +104,9 @@ var useState = (initialState) => {
     }];
   }
   const [, node] = buildData;
-  const stateArray = (_a = node[DOM_STASH][1])[STASH_SATE] || (_a[STASH_SATE] = []);
+  const stateArray = node[DOM_STASH][1][STASH_SATE] ||= [];
   const hookIndex = node[DOM_STASH][0]++;
-  return stateArray[hookIndex] || (stateArray[hookIndex] = [
+  return stateArray[hookIndex] ||= [
     resolveInitialState(),
     (newState) => {
       const localUpdateHook = updateHook;
@@ -148,18 +147,26 @@ var useState = (initialState) => {
         }
       }
     }
-  ]);
+  ];
+};
+var useReducer = (reducer, initialArg, init) => {
+  const [state, setState] = useState(() => init ? init(initialArg) : initialArg);
+  return [
+    state,
+    (action) => {
+      setState((state2) => reducer(state2, action));
+    }
+  ];
 };
 var useEffectCommon = (index, effect, deps) => {
-  var _a;
   const buildData = buildDataStack.at(-1);
   if (!buildData) {
     return;
   }
   const [, node] = buildData;
-  const effectDepsArray = (_a = node[DOM_STASH][1])[STASH_EFFECT] || (_a[STASH_EFFECT] = []);
+  const effectDepsArray = node[DOM_STASH][1][STASH_EFFECT] ||= [];
   const hookIndex = node[DOM_STASH][0]++;
-  const [prevDeps, , prevCleanup] = effectDepsArray[hookIndex] || (effectDepsArray[hookIndex] = []);
+  const [prevDeps, , prevCleanup] = effectDepsArray[hookIndex] ||= [];
   if (isDepsChanged(prevDeps, deps)) {
     if (prevCleanup) {
       prevCleanup();
@@ -176,13 +183,12 @@ var useEffectCommon = (index, effect, deps) => {
 var useEffect = (effect, deps) => useEffectCommon(3, effect, deps);
 var useLayoutEffect = (effect, deps) => useEffectCommon(1, effect, deps);
 var useCallback = (callback, deps) => {
-  var _a;
   const buildData = buildDataStack.at(-1);
   if (!buildData) {
     return callback;
   }
   const [, node] = buildData;
-  const callbackArray = (_a = node[DOM_STASH][1])[STASH_CALLBACK] || (_a[STASH_CALLBACK] = []);
+  const callbackArray = node[DOM_STASH][1][STASH_CALLBACK] ||= [];
   const hookIndex = node[DOM_STASH][0]++;
   const prevDeps = callbackArray[hookIndex];
   if (isDepsChanged(prevDeps?.[1], deps)) {
@@ -193,18 +199,16 @@ var useCallback = (callback, deps) => {
   return callback;
 };
 var useRef = (initialValue) => {
-  var _a;
   const buildData = buildDataStack.at(-1);
   if (!buildData) {
     return { current: initialValue };
   }
   const [, node] = buildData;
-  const refArray = (_a = node[DOM_STASH][1])[STASH_REF] || (_a[STASH_REF] = []);
+  const refArray = node[DOM_STASH][1][STASH_REF] ||= [];
   const hookIndex = node[DOM_STASH][0]++;
-  return refArray[hookIndex] || (refArray[hookIndex] = { current: initialValue });
+  return refArray[hookIndex] ||= { current: initialValue };
 };
 var use = (promise) => {
-  var _a;
   const cachedRes = resolvedPromiseValueMap.get(promise);
   if (cachedRes) {
     if (cachedRes.length === 2) {
@@ -221,7 +225,7 @@ var use = (promise) => {
     throw promise;
   }
   const [, node] = buildData;
-  const promiseArray = (_a = node[DOM_STASH][1])[STASH_USE] || (_a[STASH_USE] = []);
+  const promiseArray = node[DOM_STASH][1][STASH_USE] ||= [];
   const hookIndex = node[DOM_STASH][0]++;
   promise.then(
     (res2) => {
@@ -241,13 +245,12 @@ var use = (promise) => {
   throw promise;
 };
 var useMemo = (factory, deps) => {
-  var _a;
   const buildData = buildDataStack.at(-1);
   if (!buildData) {
     return factory();
   }
   const [, node] = buildData;
-  const memoArray = (_a = node[DOM_STASH][1])[STASH_MEMO] || (_a[STASH_MEMO] = []);
+  const memoArray = node[DOM_STASH][1][STASH_MEMO] ||= [];
   const hookIndex = node[DOM_STASH][0]++;
   const prevDeps = memoArray[hookIndex];
   if (isDepsChanged(prevDeps?.[1], deps)) {
@@ -255,16 +258,20 @@ var useMemo = (factory, deps) => {
   }
   return memoArray[hookIndex][0];
 };
+var useDebugValue = (value, formatter) => {
+};
 export {
   STASH_EFFECT,
   startTransition,
   startViewTransition,
   use,
   useCallback,
+  useDebugValue,
   useDeferredValue,
   useEffect,
   useLayoutEffect,
   useMemo,
+  useReducer,
   useRef,
   useState,
   useTransition,

package/dist/jsx/index.js

@@ -1,7 +1,7 @@
 // src/jsx/index.ts
 import { jsx, memo, Fragment, isValidElement, cloneElement } from "./base.js";
 import { ErrorBoundary } from "./components.js";
-import { Suspense } from "./streaming.js";
+import { createContext, useContext } from "./context.js";
 import {
   useState,
   useEffect,
@@ -14,16 +14,45 @@ import {
   startViewTransition,
   useViewTransition,
   useMemo,
-  useLayoutEffect
+  useLayoutEffect,
+  useReducer,
+  useDebugValue
 } from "./hooks/index.js";
-import { createContext, useContext } from "./context.js";
+import { Suspense } from "./streaming.js";
 export * from "./types.js";
+var jsx_default = {
+  memo,
+  Fragment,
+  isValidElement,
+  createElement: jsx,
+  cloneElement,
+  ErrorBoundary,
+  createContext,
+  useContext,
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  useReducer,
+  useDebugValue,
+  use,
+  startTransition,
+  useTransition,
+  useDeferredValue,
+  startViewTransition,
+  useViewTransition,
+  useMemo,
+  useLayoutEffect,
+  Suspense
+};
 export {
   ErrorBoundary,
   Fragment,
   Suspense,
   cloneElement,
   createContext,
+  jsx as createElement,
+  jsx_default as default,
   isValidElement,
   jsx,
   memo,
@@ -32,10 +61,12 @@ export {
   use,
   useCallback,
   useContext,
+  useDebugValue,
   useDeferredValue,
   useEffect,
   useLayoutEffect,
   useMemo,
+  useReducer,
   useRef,
   useState,
   useTransition,

package/dist/middleware/body-limit/index.js

@@ -0,0 +1,57 @@
+// src/middleware/body-limit/index.ts
+import { HTTPException } from "../../http-exception.js";
+var ERROR_MESSAGE = "Payload Too Large";
+var BodyLimitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BodyLimitError";
+  }
+};
+var bodyLimit = (options) => {
+  const onError = options.onError || (() => {
+    const res = new Response(ERROR_MESSAGE, {
+      status: 413
+    });
+    throw new HTTPException(413, { res });
+  });
+  const maxSize = options.maxSize;
+  return async function bodyLimit2(c, next) {
+    if (!c.req.raw.body) {
+      return next();
+    }
+    if (c.req.raw.headers.has("content-length")) {
+      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
+      return contentLength > maxSize ? onError(c) : next();
+    }
+    let size = 0;
+    const rawReader = c.req.raw.body.getReader();
+    const reader = new ReadableStream({
+      async start(controller) {
+        try {
+          for (; ; ) {
+            const { done, value } = await rawReader.read();
+            if (done) {
+              break;
+            }
+            size += value.length;
+            if (size > maxSize) {
+              controller.error(new BodyLimitError(ERROR_MESSAGE));
+              break;
+            }
+            controller.enqueue(value);
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    c.req.raw = new Request(c.req.raw, { body: reader });
+    await next();
+    if (c.error instanceof BodyLimitError) {
+      c.res = await onError(c);
+    }
+  };
+};
+export {
+  bodyLimit
+};

package/dist/middleware/logger/index.js

@@ -1,4 +1,5 @@
 // src/middleware/logger/index.ts
+import { getColorEnabled } from "../../utils/color.js";
 import { getPath } from "../../utils/url.js";
 var humanize = (times) => {
   const [delimiter, separator] = [",", "."];
@@ -10,14 +11,15 @@ var time = (start) => {
   return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
 };
 var colorStatus = (status) => {
+  const colorEnabled = getColorEnabled();
   const out = {
-    7: `\x1B[35m${status}\x1B[0m`,
-    5: `\x1B[31m${status}\x1B[0m`,
-    4: `\x1B[33m${status}\x1B[0m`,
-    3: `\x1B[36m${status}\x1B[0m`,
-    2: `\x1B[32m${status}\x1B[0m`,
-    1: `\x1B[32m${status}\x1B[0m`,
-    0: `\x1B[33m${status}\x1B[0m`
+    7: colorEnabled ? `\x1B[35m${status}\x1B[0m` : `${status}`,
+    5: colorEnabled ? `\x1B[31m${status}\x1B[0m` : `${status}`,
+    4: colorEnabled ? `\x1B[33m${status}\x1B[0m` : `${status}`,
+    3: colorEnabled ? `\x1B[36m${status}\x1B[0m` : `${status}`,
+    2: colorEnabled ? `\x1B[32m${status}\x1B[0m` : `${status}`,
+    1: colorEnabled ? `\x1B[32m${status}\x1B[0m` : `${status}`,
+    0: colorEnabled ? `\x1B[33m${status}\x1B[0m` : `${status}`
   };
   const calculateStatus = status / 100 | 0;
   return out[calculateStatus];

package/dist/request.js

@@ -1,63 +1,32 @@
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-
 // src/request.ts
 import { parseBody } from "./utils/body.js";
 import { getQueryParam, getQueryParams, decodeURIComponent_ } from "./utils/url.js";
-var _validatedData, _matchResult;
 var HonoRequest = class {
+  raw;
+  #validatedData;
+  #matchResult;
+  routeIndex = 0;
+  path;
+  bodyCache = {};
   constructor(request, path = "/", matchResult = [[]]) {
-    __privateAdd(this, _validatedData, void 0);
-    __privateAdd(this, _matchResult, void 0);
-    this.routeIndex = 0;
-    this.bodyCache = {};
-    this.cachedBody = (key) => {
-      const { bodyCache, raw } = this;
-      const cachedBody = bodyCache[key];
-      if (cachedBody) {
-        return cachedBody;
-      }
-      if (bodyCache.arrayBuffer) {
-        return (async () => {
-          return await new Response(bodyCache.arrayBuffer)[key]();
-        })();
-      }
-      return bodyCache[key] = raw[key]();
-    };
     this.raw = request;
     this.path = path;
-    __privateSet(this, _matchResult, matchResult);
-    __privateSet(this, _validatedData, {});
+    this.#matchResult = matchResult;
+    this.#validatedData = {};
   }
   param(key) {
     return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
   }
   getDecodedParam(key) {
-    const paramKey = __privateGet(this, _matchResult)[0][this.routeIndex][1][key];
+    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
     const param = this.getParamValue(paramKey);
     return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
   }
   getAllDecodedParams() {
     const decoded = {};
-    const keys = Object.keys(__privateGet(this, _matchResult)[0][this.routeIndex][1]);
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
     for (const key of keys) {
-      const value = this.getParamValue(__privateGet(this, _matchResult)[0][this.routeIndex][1][key]);
+      const value = this.getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value && typeof value === "string") {
         decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
       }
@@ -65,7 +34,7 @@ var HonoRequest = class {
     return decoded;
   }
   getParamValue(paramKey) {
-    return __privateGet(this, _matchResult)[1] ? __privateGet(this, _matchResult)[1][paramKey] : paramKey;
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
   }
   query(key) {
     return getQueryParam(this.url, key);
@@ -91,6 +60,19 @@ var HonoRequest = class {
     this.bodyCache.parsedBody = parsedBody;
     return parsedBody;
   }
+  cachedBody = (key) => {
+    const { bodyCache, raw } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    if (bodyCache.arrayBuffer) {
+      return (async () => {
+        return await new Response(bodyCache.arrayBuffer)[key]();
+      })();
+    }
+    return bodyCache[key] = raw[key]();
+  };
   json() {
     return this.cachedBody("json");
   }
@@ -107,10 +89,10 @@ var HonoRequest = class {
     return this.cachedBody("formData");
   }
   addValidatedData(target, data) {
-    __privateGet(this, _validatedData)[target] = data;
+    this.#validatedData[target] = data;
   }
   valid(target) {
-    return __privateGet(this, _validatedData)[target];
+    return this.#validatedData[target];
   }
   get url() {
     return this.raw.url;
@@ -119,14 +101,12 @@ var HonoRequest = class {
     return this.raw.method;
   }
   get matchedRoutes() {
-    return __privateGet(this, _matchResult)[0].map(([[, route]]) => route);
+    return this.#matchResult[0].map(([[, route]]) => route);
   }
   get routePath() {
-    return __privateGet(this, _matchResult)[0].map(([[, route]]) => route)[this.routeIndex].path;
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
   }
 };
-_validatedData = new WeakMap();
-_matchResult = new WeakMap();
 export {
   HonoRequest
 };

package/dist/router/linear-router/router.js

@@ -5,10 +5,8 @@ var emptyParams = {};
 var splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 var splitByStarRe = /\*/;
 var LinearRouter = class {
-  constructor() {
-    this.name = "LinearRouter";
-    this.routes = [];
-  }
+  name = "LinearRouter";
+  routes = [];
   add(method, path, handler) {
     ;
     (checkOptionalParameter(path) || [path]).forEach((p) => {
@@ -91,7 +89,7 @@ var LinearRouter = class {
                 value = path.slice(pos + 1, endValuePos);
                 pos = endValuePos;
               }
-              params[name] || (params[name] = value);
+              params[name] ||= value;
             } else {
               const index = path.indexOf(part, pos);
               if (index !== pos) {

package/dist/router/pattern-router/router.js

@@ -1,10 +1,8 @@
 // src/router/pattern-router/router.ts
 import { METHOD_NAME_ALL, UnsupportedPathError } from "../../router.js";
 var PatternRouter = class {
-  constructor() {
-    this.name = "PatternRouter";
-    this.routes = [];
-  }
+  name = "PatternRouter";
+  routes = [];
   add(method, path, handler) {
     const endsWithWildcard = path[path.length - 1] === "*";
     if (endsWithWildcard) {

package/dist/router/reg-exp-router/node.js

@@ -23,9 +23,9 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 var Node = class {
-  constructor() {
-    this.children = {};
-  }
+  index;
+  varIndex;
+  children = {};
   insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
       if (this.index !== void 0) {

package/dist/router/reg-exp-router/router.js

@@ -11,9 +11,9 @@ var emptyParam = [];
 var nullMatcher = [/^$/, [], {}];
 var wildcardRegExpCache = {};
 function buildWildcardRegExp(path) {
-  return wildcardRegExpCache[path] ?? (wildcardRegExpCache[path] = new RegExp(
+  return wildcardRegExpCache[path] ??= new RegExp(
     path === "*" ? "" : `^${path.replace(/\/\*/, "(?:|/.*)")}$`
-  ));
+  );
 }
 function clearWildcardRegExpCache() {
   wildcardRegExpCache = {};
@@ -87,13 +87,14 @@ function findMiddleware(middleware, path) {
   return void 0;
 }
 var RegExpRouter = class {
+  name = "RegExpRouter";
+  middleware;
+  routes;
   constructor() {
-    this.name = "RegExpRouter";
     this.middleware = { [METHOD_NAME_ALL]: {} };
     this.routes = { [METHOD_NAME_ALL]: {} };
   }
   add(method, path, handler) {
-    var _a;
     const { middleware, routes } = this;
     if (!middleware || !routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
@@ -115,11 +116,10 @@ var RegExpRouter = class {
       const re = buildWildcardRegExp(path);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          var _a2;
-          (_a2 = middleware[m])[path] || (_a2[path] = findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || []);
+          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
         });
       } else {
-        (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || []);
+        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -141,11 +141,10 @@ var RegExpRouter = class {
     for (let i = 0, len = paths.length; i < len; i++) {
       const path2 = paths[i];
       Object.keys(routes).forEach((m) => {
-        var _a2;
         if (method === METHOD_NAME_ALL || method === m) {
-          (_a2 = routes[m])[path2] || (_a2[path2] = [
+          routes[m][path2] ||= [
             ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
-          ]);
+          ];
           routes[m][path2].push([handler, paramCount - len + i + 1]);
         }
       });
@@ -172,7 +171,7 @@ var RegExpRouter = class {
   buildAllMatchers() {
     const matchers = {};
     [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
-      matchers[method] || (matchers[method] = this.buildMatcher(method));
+      matchers[method] ||= this.buildMatcher(method);
     });
     this.middleware = this.routes = void 0;
     return matchers;
@@ -183,7 +182,7 @@ var RegExpRouter = class {
     [this.middleware, this.routes].forEach((r) => {
       const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
       if (ownRoute.length !== 0) {
-        hasOwnRoute || (hasOwnRoute = true);
+        hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(

package/dist/router/reg-exp-router/trie.js

@@ -1,10 +1,8 @@
 // src/router/reg-exp-router/trie.ts
 import { Node } from "./node.js";
 var Trie = class {
-  constructor() {
-    this.context = { varIndex: 0 };
-    this.root = new Node();
-  }
+  context = { varIndex: 0 };
+  root = new Node();
   insert(path, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];

package/dist/router/smart-router/router.js

@@ -1,10 +1,10 @@
 // src/router/smart-router/router.ts
 import { UnsupportedPathError, MESSAGE_MATCHER_IS_ALREADY_BUILT } from "../../router.js";
 var SmartRouter = class {
+  name = "SmartRouter";
+  routers = [];
+  routes = [];
   constructor(init) {
-    this.name = "SmartRouter";
-    this.routers = [];
-    this.routes = [];
     Object.assign(this, init);
   }
   add(method, path, handler) {

package/dist/router/trie-router/node.js

@@ -2,9 +2,13 @@
 import { METHOD_NAME_ALL } from "../../router.js";
 import { splitPath, splitRoutingPath, getPattern } from "../../utils/url.js";
 var Node = class {
+  methods;
+  children;
+  patterns;
+  order = 0;
+  name;
+  params = {};
   constructor(method, handler, children) {
-    this.order = 0;
-    this.params = {};
     this.children = children || {};
     this.methods = [];
     this.name = "";

package/dist/router/trie-router/router.js

@@ -2,8 +2,9 @@
 import { checkOptionalParameter } from "../../utils/url.js";
 import { Node } from "./node.js";
 var TrieRouter = class {
+  name = "TrieRouter";
+  node;
   constructor() {
-    this.name = "TrieRouter";
     this.node = new Node();
   }
   add(method, path, handler) {

package/dist/test-utils/setup-vitest.js

@@ -3,6 +3,8 @@ import crypto from "node:crypto";
 import { vi } from "vitest";
 vi.stubGlobal("crypto", crypto);
 var MockCache = class {
+  name;
+  store;
   constructor(name, store) {
     this.name = name;
     this.store = store;

package/dist/types/adapter/bun/index.d.ts

@@ -1,2 +1,3 @@
 export { serveStatic } from './serve-static';
 export { bunFileSystemModule, toSSG } from './ssg';
+export { createBunWebSocket } from './websocket';

package/dist/types/adapter/bun/websocket.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { type UpgradeWebSocket } from '../../helper/websocket';
+interface BunServerWebSocket<T> {
+    send(data: string | ArrayBufferLike, compress?: boolean): void;
+    close(code?: number, reason?: string): void;
+    data: T;
+    readyState: 0 | 1 | 2 | 3;
+}
+interface BunWebSocketHandler<T> {
+    open(ws: BunServerWebSocket<T>): void;
+    close(ws: BunServerWebSocket<T>, code?: number, reason?: string): void;
+    message(ws: BunServerWebSocket<T>, message: string | Buffer): void;
+}
+interface CreateWebSocket {
+    (): {
+        upgradeWebSocket: UpgradeWebSocket;
+        websocket: BunWebSocketHandler<BunWebSocketData>;
+    };
+}
+export interface BunWebSocketData {
+    connId: number;
+    url: URL;
+    protocol: string;
+}
+export declare const createBunWebSocket: CreateWebSocket;
+export {};

package/dist/types/adapter/cloudflare-workers/index.d.ts

@@ -1 +1,2 @@
 export { serveStatic } from './serve-static-module';
+export { upgradeWebSocket } from './websocket';

package/dist/types/adapter/cloudflare-workers/websocket.d.ts

@@ -0,0 +1,2 @@
+import type { UpgradeWebSocket } from '../../helper/websocket';
+export declare const upgradeWebSocket: UpgradeWebSocket;

package/dist/types/adapter/deno/index.d.ts

@@ -1,2 +1,3 @@
 export { serveStatic } from './serve-static';
 export { toSSG, denoFileSystemModule } from './ssg';
+export { upgradeWebSocket } from './websocket';

package/dist/types/adapter/deno/websocket.d.ts

@@ -0,0 +1,2 @@
+import type { UpgradeWebSocket } from '../../helper/websocket';
+export declare const upgradeWebSocket: UpgradeWebSocket;