hono 4.0.10 → 4.1.0

package/dist/cjs/http-exception.js

@@ -22,8 +22,10 @@ __export(http_exception_exports, {
 });
 module.exports = __toCommonJS(http_exception_exports);
 class HTTPException extends Error {
+  res;
+  status;
   constructor(status = 500, options) {
-    super(options?.message);
+    super(options?.message, { cause: options?.cause });
     this.res = options?.res;
     this.status = status;
   }

package/dist/cjs/jsx/base.js

@@ -96,8 +96,13 @@ const childrenToStringToBuffer = (children, buffer) => {
   }
 };
 class JSXNode {
+  tag;
+  props;
+  key;
+  children;
+  isEscaped = true;
+  localContexts;
   constructor(tag, props, children) {
-    this.isEscaped = true;
     this.tag = tag;
     this.props = props;
     this.children = children;
@@ -249,7 +254,7 @@ const memo = (component, propsAreEqual = shallowEqual) => {
       computed = void 0;
     }
     prevProps = props;
-    return computed || (computed = component(props));
+    return computed ||= component(props);
   };
 };
 const Fragment = ({

package/dist/cjs/jsx/components.js

@@ -65,7 +65,7 @@ const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) =>
     }
   }
   if (resArray.some((res) => res instanceof Promise)) {
-    fallbackStr || (fallbackStr = await fallback?.toString());
+    fallbackStr ||= await fallback?.toString();
     const index = errorBoundaryCounter++;
     const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
     const caught = false;

package/dist/cjs/jsx/dom/index.js

@@ -22,7 +22,10 @@ __export(dom_exports, {
   Suspense: () => import_components.Suspense,
   cloneElement: () => cloneElement,
   createContext: () => import_context2.createContext,
+  createElement: () => createElement,
+  default: () => dom_default,
   isValidElement: () => import_base.isValidElement,
+  jsx: () => createElement,
   memo: () => import_base.memo,
   render: () => import_render.render,
   startTransition: () => import_hooks.startTransition,
@@ -30,23 +33,34 @@ __export(dom_exports, {
   use: () => import_hooks.use,
   useCallback: () => import_hooks.useCallback,
   useContext: () => import_context.useContext,
+  useDebugValue: () => import_hooks.useDebugValue,
   useDeferredValue: () => import_hooks.useDeferredValue,
   useEffect: () => import_hooks.useEffect,
   useLayoutEffect: () => import_hooks.useLayoutEffect,
   useMemo: () => import_hooks.useMemo,
+  useReducer: () => import_hooks.useReducer,
   useRef: () => import_hooks.useRef,
   useState: () => import_hooks.useState,
   useTransition: () => import_hooks.useTransition,
   useViewTransition: () => import_hooks.useViewTransition
 });
 module.exports = __toCommonJS(dom_exports);
+var import_base = require("../base");
+var import_context = require("../context");
 var import_hooks = require("../hooks");
-var import_render = require("./render");
 var import_components = require("./components");
-var import_context = require("../context");
 var import_context2 = require("./context");
-var import_base = require("../base");
 var import_jsx_runtime = require("./jsx-runtime");
+var import_render = require("./render");
+const createElement = (tag, props, ...children) => {
+  const jsxProps = { ...props, children };
+  let key = void 0;
+  if ("key" in jsxProps) {
+    key = jsxProps.key;
+    delete jsxProps.key;
+  }
+  return (0, import_jsx_runtime.jsx)(tag, jsxProps, key);
+};
 const cloneElement = (element, props, ...children) => {
   return (0, import_jsx_runtime.jsx)(
     element.tag,
@@ -58,13 +72,39 @@ const cloneElement = (element, props, ...children) => {
     element.key
   );
 };
+var dom_default = {
+  useState: import_hooks.useState,
+  useEffect: import_hooks.useEffect,
+  useRef: import_hooks.useRef,
+  useCallback: import_hooks.useCallback,
+  use: import_hooks.use,
+  startTransition: import_hooks.startTransition,
+  useTransition: import_hooks.useTransition,
+  useDeferredValue: import_hooks.useDeferredValue,
+  startViewTransition: import_hooks.startViewTransition,
+  useViewTransition: import_hooks.useViewTransition,
+  useMemo: import_hooks.useMemo,
+  useLayoutEffect: import_hooks.useLayoutEffect,
+  useReducer: import_hooks.useReducer,
+  useDebugValue: import_hooks.useDebugValue,
+  Suspense: import_components.Suspense,
+  ErrorBoundary: import_components.ErrorBoundary,
+  createContext: import_context2.createContext,
+  useContext: import_context.useContext,
+  memo: import_base.memo,
+  isValidElement: import_base.isValidElement,
+  createElement,
+  cloneElement
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ErrorBoundary,
   Suspense,
   cloneElement,
   createContext,
+  createElement,
   isValidElement,
+  jsx,
   memo,
   render,
   startTransition,
@@ -72,10 +112,12 @@ const cloneElement = (element, props, ...children) => {
   use,
   useCallback,
   useContext,
+  useDebugValue,
   useDeferredValue,
   useEffect,
   useLayoutEffect,
   useMemo,
+  useReducer,
   useRef,
   useState,
   useTransition,

package/dist/cjs/jsx/dom/render.js

@@ -48,7 +48,7 @@ const getEventSpec = (key) => {
   return void 0;
 };
 const applyProps = (container, attributes, oldAttributes) => {
-  attributes || (attributes = {});
+  attributes ||= {};
   for (const [key, value] of Object.entries(attributes)) {
     if (!oldAttributes || oldAttributes[key] !== value) {
       const eventSpec = getEventSpec(key);
@@ -230,9 +230,9 @@ const applyNodeObject = (node, container) => {
         child.e.textContent = child[0];
       }
       child[1] = false;
-      el = child.e || (child.e = document.createTextNode(child[0]));
+      el = child.e ||= document.createTextNode(child[0]);
     } else {
-      el = child.e || (child.e = child.n ? document.createElementNS(child.n, child.tag) : document.createElement(child.tag));
+      el = child.e ||= child.n ? document.createElementNS(child.n, child.tag) : document.createElement(child.tag);
       applyProps(el, child.props, child.pP);
       applyNode(child, el);
     }
@@ -251,10 +251,10 @@ const build = (context, node, topLevelErrorHandlerNode, children) => {
     return;
   }
   let errorHandler;
-  children || (children = typeof node.tag == "function" ? invokeTag(context, node) : node.children);
+  children ||= typeof node.tag == "function" ? invokeTag(context, node) : node.children;
   if (children[0]?.tag === "") {
     errorHandler = children[0][import_constants.DOM_ERROR_HANDLER];
-    topLevelErrorHandlerNode || (topLevelErrorHandlerNode = node);
+    topLevelErrorHandlerNode ||= node;
   }
   const oldVChildren = node.vC ? [...node.vC] : [];
   const vChildren = [];
@@ -343,7 +343,7 @@ const buildNode = (node) => {
       if (ns) {
         ;
         node.n = ns;
-        nameSpaceContext || (nameSpaceContext = (0, import_context2.createContext)(""));
+        nameSpaceContext ||= (0, import_context2.createContext)("");
         node.children = [
           {
             tag: nameSpaceContext.Provider,

package/dist/cjs/jsx/hooks/index.js

@@ -23,10 +23,12 @@ __export(hooks_exports, {
   startViewTransition: () => startViewTransition,
   use: () => use,
   useCallback: () => useCallback,
+  useDebugValue: () => useDebugValue,
   useDeferredValue: () => useDeferredValue,
   useEffect: () => useEffect,
   useLayoutEffect: () => useLayoutEffect,
   useMemo: () => useMemo,
+  useReducer: () => useReducer,
   useRef: () => useRef,
   useState: () => useState,
   useTransition: () => useTransition,
@@ -131,7 +133,6 @@ const setShadow = (node) => {
   node.s?.forEach(setShadow);
 };
 const useState = (initialState) => {
-  var _a;
   const resolveInitialState = () => typeof initialState === "function" ? initialState() : initialState;
   const buildData = import_render.buildDataStack.at(-1);
   if (!buildData) {
@@ -139,9 +140,9 @@ const useState = (initialState) => {
     }];
   }
   const [, node] = buildData;
-  const stateArray = (_a = node[import_constants.DOM_STASH][1])[STASH_SATE] || (_a[STASH_SATE] = []);
+  const stateArray = node[import_constants.DOM_STASH][1][STASH_SATE] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
-  return stateArray[hookIndex] || (stateArray[hookIndex] = [
+  return stateArray[hookIndex] ||= [
     resolveInitialState(),
     (newState) => {
       const localUpdateHook = updateHook;
@@ -182,18 +183,26 @@ const useState = (initialState) => {
         }
       }
     }
-  ]);
+  ];
+};
+const useReducer = (reducer, initialArg, init) => {
+  const [state, setState] = useState(() => init ? init(initialArg) : initialArg);
+  return [
+    state,
+    (action) => {
+      setState((state2) => reducer(state2, action));
+    }
+  ];
 };
 const useEffectCommon = (index, effect, deps) => {
-  var _a;
   const buildData = import_render.buildDataStack.at(-1);
   if (!buildData) {
     return;
   }
   const [, node] = buildData;
-  const effectDepsArray = (_a = node[import_constants.DOM_STASH][1])[STASH_EFFECT] || (_a[STASH_EFFECT] = []);
+  const effectDepsArray = node[import_constants.DOM_STASH][1][STASH_EFFECT] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
-  const [prevDeps, , prevCleanup] = effectDepsArray[hookIndex] || (effectDepsArray[hookIndex] = []);
+  const [prevDeps, , prevCleanup] = effectDepsArray[hookIndex] ||= [];
   if (isDepsChanged(prevDeps, deps)) {
     if (prevCleanup) {
       prevCleanup();
@@ -210,13 +219,12 @@ const useEffectCommon = (index, effect, deps) => {
 const useEffect = (effect, deps) => useEffectCommon(3, effect, deps);
 const useLayoutEffect = (effect, deps) => useEffectCommon(1, effect, deps);
 const useCallback = (callback, deps) => {
-  var _a;
   const buildData = import_render.buildDataStack.at(-1);
   if (!buildData) {
     return callback;
   }
   const [, node] = buildData;
-  const callbackArray = (_a = node[import_constants.DOM_STASH][1])[STASH_CALLBACK] || (_a[STASH_CALLBACK] = []);
+  const callbackArray = node[import_constants.DOM_STASH][1][STASH_CALLBACK] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
   const prevDeps = callbackArray[hookIndex];
   if (isDepsChanged(prevDeps?.[1], deps)) {
@@ -227,18 +235,16 @@ const useCallback = (callback, deps) => {
   return callback;
 };
 const useRef = (initialValue) => {
-  var _a;
   const buildData = import_render.buildDataStack.at(-1);
   if (!buildData) {
     return { current: initialValue };
   }
   const [, node] = buildData;
-  const refArray = (_a = node[import_constants.DOM_STASH][1])[STASH_REF] || (_a[STASH_REF] = []);
+  const refArray = node[import_constants.DOM_STASH][1][STASH_REF] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
-  return refArray[hookIndex] || (refArray[hookIndex] = { current: initialValue });
+  return refArray[hookIndex] ||= { current: initialValue };
 };
 const use = (promise) => {
-  var _a;
   const cachedRes = resolvedPromiseValueMap.get(promise);
   if (cachedRes) {
     if (cachedRes.length === 2) {
@@ -255,7 +261,7 @@ const use = (promise) => {
     throw promise;
   }
   const [, node] = buildData;
-  const promiseArray = (_a = node[import_constants.DOM_STASH][1])[STASH_USE] || (_a[STASH_USE] = []);
+  const promiseArray = node[import_constants.DOM_STASH][1][STASH_USE] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
   promise.then(
     (res2) => {
@@ -275,13 +281,12 @@ const use = (promise) => {
   throw promise;
 };
 const useMemo = (factory, deps) => {
-  var _a;
   const buildData = import_render.buildDataStack.at(-1);
   if (!buildData) {
     return factory();
   }
   const [, node] = buildData;
-  const memoArray = (_a = node[import_constants.DOM_STASH][1])[STASH_MEMO] || (_a[STASH_MEMO] = []);
+  const memoArray = node[import_constants.DOM_STASH][1][STASH_MEMO] ||= [];
   const hookIndex = node[import_constants.DOM_STASH][0]++;
   const prevDeps = memoArray[hookIndex];
   if (isDepsChanged(prevDeps?.[1], deps)) {
@@ -289,6 +294,8 @@ const useMemo = (factory, deps) => {
   }
   return memoArray[hookIndex][0];
 };
+const useDebugValue = (value, formatter) => {
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   STASH_EFFECT,
@@ -296,10 +303,12 @@ const useMemo = (factory, deps) => {
   startViewTransition,
   use,
   useCallback,
+  useDebugValue,
   useDeferredValue,
   useEffect,
   useLayoutEffect,
   useMemo,
+  useReducer,
   useRef,
   useState,
   useTransition,

package/dist/cjs/jsx/index.js

@@ -24,6 +24,8 @@ __export(jsx_exports, {
   Suspense: () => import_streaming.Suspense,
   cloneElement: () => import_base.cloneElement,
   createContext: () => import_context.createContext,
+  createElement: () => import_base.jsx,
+  default: () => jsx_default,
   isValidElement: () => import_base.isValidElement,
   jsx: () => import_base.jsx,
   memo: () => import_base.memo,
@@ -32,10 +34,12 @@ __export(jsx_exports, {
   use: () => import_hooks.use,
   useCallback: () => import_hooks.useCallback,
   useContext: () => import_context.useContext,
+  useDebugValue: () => import_hooks.useDebugValue,
   useDeferredValue: () => import_hooks.useDeferredValue,
   useEffect: () => import_hooks.useEffect,
   useLayoutEffect: () => import_hooks.useLayoutEffect,
   useMemo: () => import_hooks.useMemo,
+  useReducer: () => import_hooks.useReducer,
   useRef: () => import_hooks.useRef,
   useState: () => import_hooks.useState,
   useTransition: () => import_hooks.useTransition,
@@ -44,10 +48,35 @@ __export(jsx_exports, {
 module.exports = __toCommonJS(jsx_exports);
 var import_base = require("./base");
 var import_components = require("./components");
-var import_streaming = require("./streaming");
-var import_hooks = require("./hooks");
 var import_context = require("./context");
+var import_hooks = require("./hooks");
+var import_streaming = require("./streaming");
 __reExport(jsx_exports, require("./types"), module.exports);
+var jsx_default = {
+  memo: import_base.memo,
+  Fragment: import_base.Fragment,
+  isValidElement: import_base.isValidElement,
+  createElement: import_base.jsx,
+  cloneElement: import_base.cloneElement,
+  ErrorBoundary: import_components.ErrorBoundary,
+  createContext: import_context.createContext,
+  useContext: import_context.useContext,
+  useState: import_hooks.useState,
+  useEffect: import_hooks.useEffect,
+  useRef: import_hooks.useRef,
+  useCallback: import_hooks.useCallback,
+  useReducer: import_hooks.useReducer,
+  useDebugValue: import_hooks.useDebugValue,
+  use: import_hooks.use,
+  startTransition: import_hooks.startTransition,
+  useTransition: import_hooks.useTransition,
+  useDeferredValue: import_hooks.useDeferredValue,
+  startViewTransition: import_hooks.startViewTransition,
+  useViewTransition: import_hooks.useViewTransition,
+  useMemo: import_hooks.useMemo,
+  useLayoutEffect: import_hooks.useLayoutEffect,
+  Suspense: import_streaming.Suspense
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ErrorBoundary,
@@ -55,6 +84,7 @@ __reExport(jsx_exports, require("./types"), module.exports);
   Suspense,
   cloneElement,
   createContext,
+  createElement,
   isValidElement,
   jsx,
   memo,
@@ -63,10 +93,12 @@ __reExport(jsx_exports, require("./types"), module.exports);
   use,
   useCallback,
   useContext,
+  useDebugValue,
   useDeferredValue,
   useEffect,
   useLayoutEffect,
   useMemo,
+  useReducer,
   useRef,
   useState,
   useTransition,

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

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var body_limit_exports = {};
+__export(body_limit_exports, {
+  bodyLimit: () => bodyLimit
+});
+module.exports = __toCommonJS(body_limit_exports);
+var import_http_exception = require("../../http-exception");
+const ERROR_MESSAGE = "Payload Too Large";
+class BodyLimitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BodyLimitError";
+  }
+}
+const bodyLimit = (options) => {
+  const onError = options.onError || (() => {
+    const res = new Response(ERROR_MESSAGE, {
+      status: 413
+    });
+    throw new import_http_exception.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);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bodyLimit
+});

package/dist/cjs/middleware/logger/index.js

@@ -21,6 +21,7 @@ __export(logger_exports, {
   logger: () => logger
 });
 module.exports = __toCommonJS(logger_exports);
+var import_color = require("../../utils/color");
 var import_url = require("../../utils/url");
 var LogPrefix = /* @__PURE__ */ ((LogPrefix2) => {
   LogPrefix2["Outgoing"] = "-->";
@@ -38,14 +39,15 @@ const time = (start) => {
   return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
 };
 const colorStatus = (status) => {
+  const colorEnabled = (0, import_color.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/cjs/request.js

@@ -16,24 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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;
-};
 var request_exports = {};
 __export(request_exports, {
   HonoRequest: () => HonoRequest
@@ -41,44 +23,32 @@ __export(request_exports, {
 module.exports = __toCommonJS(request_exports);
 var import_body = require("./utils/body");
 var import_url = require("./utils/url");
-var _validatedData, _matchResult;
 class HonoRequest {
+  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) ? (0, import_url.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) ? (0, import_url.decodeURIComponent_)(value) : value;
       }
@@ -86,7 +56,7 @@ class HonoRequest {
     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 (0, import_url.getQueryParam)(this.url, key);
@@ -112,6 +82,19 @@ class HonoRequest {
     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");
   }
@@ -128,10 +111,10 @@ class HonoRequest {
     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;
@@ -140,14 +123,12 @@ class HonoRequest {
     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();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HonoRequest

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

@@ -27,10 +27,8 @@ const emptyParams = {};
 const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 const splitByStarRe = /\*/;
 class LinearRouter {
-  constructor() {
-    this.name = "LinearRouter";
-    this.routes = [];
-  }
+  name = "LinearRouter";
+  routes = [];
   add(method, path, handler) {
     ;
     ((0, import_url.checkOptionalParameter)(path) || [path]).forEach((p) => {
@@ -113,7 +111,7 @@ class LinearRouter {
                 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) {