hono 4.6.8 → 4.6.10

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

@@ -24,18 +24,18 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 var Node = class {
-  index;
-  varIndex;
-  children = /* @__PURE__ */ Object.create(null);
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
   insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
-      if (this.index !== void 0) {
+      if (this.#index !== void 0) {
         throw PATH_ERROR;
       }
       if (pathErrorCheckOnly) {
         return;
       }
-      this.index = index;
+      this.#index = index;
       return;
     }
     const [token, ...restTokens] = tokens;
@@ -50,9 +50,9 @@ var Node = class {
           throw PATH_ERROR;
         }
       }
-      node = this.children[regexpStr];
+      node = this.#children[regexpStr];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -60,18 +60,18 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[regexpStr] = new Node();
+        node = this.#children[regexpStr] = new Node();
         if (name !== "") {
-          node.varIndex = context.varIndex++;
+          node.#varIndex = context.varIndex++;
         }
       }
       if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.varIndex]);
+        paramMap.push([name, node.#varIndex]);
       }
     } else {
-      node = this.children[token];
+      node = this.#children[token];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -79,19 +79,19 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[token] = new Node();
+        node = this.#children[token] = new Node();
       }
     }
     node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
   buildRegExpStr() {
-    const childKeys = Object.keys(this.children).sort(compareKey);
+    const childKeys = Object.keys(this.#children).sort(compareKey);
     const strList = childKeys.map((k) => {
-      const c = this.children[k];
-      return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
     });
-    if (typeof this.index === "number") {
-      strList.unshift(`#${this.index}`);
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
     }
     if (strList.length === 0) {
       return "";

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

@@ -91,14 +91,15 @@ function findMiddleware(middleware, path) {
 }
 var RegExpRouter = class {
   name = "RegExpRouter";
-  middleware;
-  routes;
+  #middleware;
+  #routes;
   constructor() {
-    this.middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
   add(method, path, handler) {
-    const { middleware, routes } = this;
+    const middleware = this.#middleware;
+    const routes = this.#routes;
     if (!middleware || !routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
@@ -155,7 +156,7 @@ var RegExpRouter = class {
   }
   match(method, path) {
     clearWildcardRegExpCache();
-    const matchers = this.buildAllMatchers();
+    const matchers = this.#buildAllMatchers();
     this.match = (method2, path2) => {
       const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
       const staticMatch = matcher[2][path2];
@@ -171,18 +172,18 @@ var RegExpRouter = class {
     };
     return this.match(method, path);
   }
-  buildAllMatchers() {
+  #buildAllMatchers() {
     const matchers = /* @__PURE__ */ Object.create(null);
-    [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
-      matchers[method] ||= this.buildMatcher(method);
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
+      matchers[method] ||= this.#buildMatcher(method);
     });
-    this.middleware = this.routes = void 0;
+    this.#middleware = this.#routes = void 0;
     return matchers;
   }
-  buildMatcher(method) {
+  #buildMatcher(method) {
     const routes = [];
     let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.middleware, this.routes].forEach((r) => {
+    [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 ||= true;

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

@@ -1,8 +1,8 @@
 // src/router/reg-exp-router/trie.ts
 import { Node } from "./node.js";
 var Trie = class {
-  context = { varIndex: 0 };
-  root = new Node();
+  #context = { varIndex: 0 };
+  #root = new Node();
   insert(path, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
@@ -29,11 +29,11 @@ var Trie = class {
         }
       }
     }
-    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
     return paramAssoc;
   }
   buildRegExp() {
-    let regexp = this.root.buildRegExpStr();
+    let regexp = this.#root.buildRegExpStr();
     if (regexp === "") {
       return [/^$/, [], []];
     }
@@ -41,11 +41,11 @@ var Trie = class {
     const indexReplacementMap = [];
     const paramReplacementMap = [];
     regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (typeof handlerIndex !== "undefined") {
+      if (handlerIndex !== void 0) {
         indexReplacementMap[++captureIndex] = Number(handlerIndex);
         return "$()";
       }
-      if (typeof paramIndex !== "undefined") {
+      if (paramIndex !== void 0) {
         paramReplacementMap[Number(paramIndex)] = ++captureIndex;
         return "";
       }

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

@@ -2,22 +2,23 @@
 import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from "../../router.js";
 var SmartRouter = class {
   name = "SmartRouter";
-  routers = [];
-  routes = [];
+  #routers = [];
+  #routes = [];
   constructor(init) {
-    Object.assign(this, init);
+    this.#routers = init.routers;
   }
   add(method, path, handler) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.routes.push([method, path, handler]);
+    this.#routes.push([method, path, handler]);
   }
   match(method, path) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error("Fatal error");
     }
-    const { routers, routes } = this;
+    const routers = this.#routers;
+    const routes = this.#routes;
     const len = routers.length;
     let i = 0;
     let res;
@@ -35,8 +36,8 @@ var SmartRouter = class {
         throw e;
       }
       this.match = router.match.bind(router);
-      this.routers = [router];
-      this.routes = void 0;
+      this.#routers = [router];
+      this.#routes = void 0;
       break;
     }
     if (i === len) {
@@ -46,10 +47,10 @@ var SmartRouter = class {
     return res;
   }
   get activeRouter() {
-    if (this.routes || this.routers.length !== 1) {
+    if (this.#routes || this.#routers.length !== 1) {
       throw new Error("No active router has been determined yet.");
     }
-    return this.routers[0];
+    return this.#routers[0];
   }
 };
 export {

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

@@ -2,63 +2,60 @@
 import { METHOD_NAME_ALL } from "../../router.js";
 import { getPattern, splitPath, splitRoutingPath } from "../../utils/url.js";
 var Node = class {
-  methods;
-  children;
-  patterns;
-  order = 0;
-  params = /* @__PURE__ */ Object.create(null);
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = /* @__PURE__ */ Object.create(null);
   constructor(method, handler, children) {
-    this.children = children || /* @__PURE__ */ Object.create(null);
-    this.methods = [];
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
     if (method && handler) {
       const m = /* @__PURE__ */ Object.create(null);
       m[method] = { handler, possibleKeys: [], score: 0 };
-      this.methods = [m];
+      this.#methods = [m];
     }
-    this.patterns = [];
+    this.#patterns = [];
   }
   insert(method, path, handler) {
-    this.order = ++this.order;
+    this.#order = ++this.#order;
     let curNode = this;
     const parts = splitRoutingPath(path);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
-      if (Object.keys(curNode.children).includes(p)) {
-        curNode = curNode.children[p];
+      if (Object.keys(curNode.#children).includes(p)) {
+        curNode = curNode.#children[p];
         const pattern2 = getPattern(p);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.children[p] = new Node();
+      curNode.#children[p] = new Node();
       const pattern = getPattern(p);
       if (pattern) {
-        curNode.patterns.push(pattern);
+        curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
       }
-      curNode = curNode.children[p];
-    }
-    if (!curNode.methods.length) {
-      curNode.methods = [];
+      curNode = curNode.#children[p];
     }
     const m = /* @__PURE__ */ Object.create(null);
     const handlerSet = {
       handler,
       possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      score: this.order
+      score: this.#order
     };
     m[method] = handlerSet;
-    curNode.methods.push(m);
+    curNode.#methods.push(m);
     return curNode;
   }
-  gHSets(node, method, nodeParams, params) {
+  #getHandlerSets(node, method, nodeParams, params) {
     const handlerSets = [];
-    for (let i = 0, len = node.methods.length; i < len; i++) {
-      const m = node.methods[i];
+    for (let i = 0, len = node.#methods.length; i < len; i++) {
+      const m = node.#methods[i];
       const handlerSet = m[method] || m[METHOD_NAME_ALL];
-      const processedSet = /* @__PURE__ */ Object.create(null);
+      const processedSet = {};
       if (handlerSet !== void 0) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
         for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
@@ -74,7 +71,7 @@ var Node = class {
   }
   search(method, path) {
     const handlerSets = [];
-    this.params = /* @__PURE__ */ Object.create(null);
+    this.#params = /* @__PURE__ */ Object.create(null);
     const curNode = this;
     let curNodes = [curNode];
     const parts = splitPath(path);
@@ -84,27 +81,36 @@ var Node = class {
       const tempNodes = [];
       for (let j = 0, len2 = curNodes.length; j < len2; j++) {
         const node = curNodes[j];
-        const nextNode = node.children[part];
+        const nextNode = node.#children[part];
         if (nextNode) {
-          nextNode.params = node.params;
+          nextNode.#params = node.#params;
           if (isLast) {
-            if (nextNode.children["*"]) {
+            if (nextNode.#children["*"]) {
               handlerSets.push(
-                ...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
+                ...this.#getHandlerSets(
+                  nextNode.#children["*"],
+                  method,
+                  node.#params,
+                  /* @__PURE__ */ Object.create(null)
+                )
               );
             }
-            handlerSets.push(...this.gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+            handlerSets.push(
+              ...this.#getHandlerSets(nextNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+            );
           } else {
             tempNodes.push(nextNode);
           }
         }
-        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
-          const pattern = node.patterns[k];
-          const params = { ...node.params };
+        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = { ...node.#params };
           if (pattern === "*") {
-            const astNode = node.children["*"];
+            const astNode = node.#children["*"];
             if (astNode) {
-              handlerSets.push(...this.gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+              handlerSets.push(
+                ...this.#getHandlerSets(astNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+              );
               tempNodes.push(astNode);
             }
             continue;
@@ -113,25 +119,25 @@ var Node = class {
             continue;
           }
           const [key, name, matcher] = pattern;
-          const child = node.children[key];
+          const child = node.#children[key];
           const restPathString = parts.slice(i).join("/");
           if (matcher instanceof RegExp && matcher.test(restPathString)) {
             params[name] = restPathString;
-            handlerSets.push(...this.gHSets(child, method, node.params, params));
+            handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
             continue;
           }
           if (matcher === true || matcher.test(part)) {
-            if (typeof key === "string") {
-              params[name] = part;
-              if (isLast) {
-                handlerSets.push(...this.gHSets(child, method, params, node.params));
-                if (child.children["*"]) {
-                  handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));
-                }
-              } else {
-                child.params = params;
-                tempNodes.push(child);
+            params[name] = part;
+            if (isLast) {
+              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
+              if (child.#children["*"]) {
+                handlerSets.push(
+                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
+                );
               }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
             }
           }
         }

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

@@ -3,22 +3,22 @@ import { checkOptionalParameter } from "../../utils/url.js";
 import { Node } from "./node.js";
 var TrieRouter = class {
   name = "TrieRouter";
-  node;
+  #node;
   constructor() {
-    this.node = new Node();
+    this.#node = new Node();
   }
   add(method, path, handler) {
     const results = checkOptionalParameter(path);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
-        this.node.insert(method, results[i], handler);
+        this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.node.insert(method, path, handler);
+    this.#node.insert(method, path, handler);
   }
   match(method, path) {
-    return this.node.search(method, path);
+    return this.#node.search(method, path);
   }
 };
 export {

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

@@ -1,2 +1,2 @@
-import type { UpgradeWebSocket } from '../../helper/websocket';
-export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket>;
+import type { UpgradeWebSocket, WSEvents } from '../../helper/websocket';
+export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, any, Omit<WSEvents<WebSocket>, "onOpen">>;

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

@@ -1,21 +1,2 @@
 import type { UpgradeWebSocket } from '../../helper/websocket';
-export interface UpgradeWebSocketOptions {
-    /**
-     * Sets the `.protocol` property on the client side web socket to the
-     * value provided here, which should be one of the strings specified in the
-     * `protocols` parameter when requesting the web socket. This is intended
-     * for clients and servers to specify sub-protocols to use to communicate to
-     * each other.
-     */
-    protocol?: string;
-    /**
-     * If the client does not respond to this frame with a
-     * `pong` within the timeout specified, the connection is deemed
-     * unhealthy and is closed. The `close` and `error` event will be emitted.
-     *
-     * The unit is seconds, with a default of 30.
-     * Set to `0` to disable timeouts.
-     */
-    idleTimeout?: number;
-}
-export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, UpgradeWebSocketOptions>;
+export declare const upgradeWebSocket: UpgradeWebSocket<WebSocket, Deno.UpgradeWebSocketOptions>;

package/dist/types/adapter/service-worker/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Cloudflare Workers Adapter for Hono.
+ * Service Worker Adapter for Hono.
  * @module
  */
 export { handle } from './handler';

package/dist/types/compose.d.ts

@@ -1,4 +1,3 @@
-import type { ParamIndexMap, Params } from './router';
 import type { Env, ErrorHandler, NotFoundHandler } from './types';
 /**
  * Interface representing the context for a composition operation.
@@ -31,6 +30,10 @@ export declare const compose: <C extends ComposeContext, E extends Env = Env>(mi
         Function,
         unknown
     ],
-    ParamIndexMap | Params
+    unknown
+][] | [
+    [
+        Function
+    ]
 ][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: C, next?: Function) => Promise<C>);
 export {};

package/dist/types/context.d.ts

@@ -434,7 +434,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * })
      * ```
      */
-    redirect: <T extends RedirectStatusCode = 302>(location: string, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
+    redirect: <T extends RedirectStatusCode = 302>(location: string | URL, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
     /**
      * `.notFound()` can return the Not Found Response.
      *

package/dist/types/helper/websocket/index.d.ts

@@ -16,7 +16,7 @@ export interface WSEvents<T = unknown> {
 /**
  * Upgrade WebSocket Type
  */
-export type UpgradeWebSocket<T = unknown, U = any> = (createEvents: (c: Context) => WSEvents<T> | Promise<WSEvents<T>>, options?: U) => MiddlewareHandler<any, string, {
+export type UpgradeWebSocket<T = unknown, U = any, _WSEvents = WSEvents<T>> = (createEvents: (c: Context) => _WSEvents | Promise<_WSEvents>, options?: U) => MiddlewareHandler<any, string, {
     outputFormat: "ws";
 }>;
 /**

package/dist/types/hono-base.d.ts

@@ -23,7 +23,7 @@ export type HonoOptions<E extends Env> = {
      */
     strict?: boolean;
     /**
-     * `router` option specifices which router to use.
+     * `router` option specifies which router to use.
      *
      * @see {@link https://hono.dev/docs/api/hono#router-option}
      *

package/dist/types/jsx/base.d.ts

@@ -1,4 +1,5 @@
 import type { HtmlEscaped, HtmlEscapedString, StringBufferWithCallbacks } from '../utils/html';
+import { DOM_MEMO } from './constants';
 import type { Context } from './context';
 import type { JSX as HonoJSX, IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
 export type Props = Record<string, any>;
@@ -45,6 +46,10 @@ export declare class JSXFragmentNode extends JSXNode {
 }
 export declare const jsx: (tag: string | Function, props: Props | null, ...children: (string | number | HtmlEscapedString)[]) => JSXNode;
 export declare const jsxFn: (tag: string | Function, props: Props, children: (string | number | HtmlEscapedString)[]) => JSXNode;
+export declare const shallowEqual: (a: Props, b: Props) => boolean;
+export type MemorableFC<T> = FC<T> & {
+    [DOM_MEMO]: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean;
+};
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export declare const Fragment: ({ children, }: {
     key?: string;

package/dist/types/jsx/constants.d.ts

@@ -2,4 +2,5 @@ export declare const DOM_RENDERER: unique symbol;
 export declare const DOM_ERROR_HANDLER: unique symbol;
 export declare const DOM_STASH: unique symbol;
 export declare const DOM_INTERNAL_TAG: unique symbol;
+export declare const DOM_MEMO: unique symbol;
 export declare const PERMALINK: unique symbol;

package/dist/types/jsx/dom/index.d.ts

@@ -2,8 +2,8 @@
  * @module
  * This module provides APIs for `hono/jsx/dom`.
  */
-import { isValidElement, memo, reactAPICompatVersion } from '../base';
-import type { Child, DOMAttributes, JSX, JSXNode, Props } from '../base';
+import { isValidElement, reactAPICompatVersion } from '../base';
+import type { Child, DOMAttributes, JSX, JSXNode, Props, FC } from '../base';
 import { Children } from '../children';
 import { useContext } from '../context';
 import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from '../hooks';
@@ -15,6 +15,7 @@ import { createPortal, flushSync } from './render';
 export { render } from './render';
 declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
 declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
+declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export { reactAPICompatVersion as version, createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useInsertionEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, useFormStatus, useActionState, useOptimistic, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, Children, Fragment, Fragment as StrictMode, DOMAttributes, flushSync, createPortal, };
 declare const _default: {
     version: string;
@@ -77,17 +78,17 @@ declare const _default: {
         T,
         (action: N) => void
     ];
-    Suspense: import("..").FC<import("..").PropsWithChildren<{
+    Suspense: FC<import("..").PropsWithChildren<{
         fallback: any;
     }>>;
-    ErrorBoundary: import("..").FC<import("..").PropsWithChildren<{
+    ErrorBoundary: FC<import("..").PropsWithChildren<{
         fallback?: Child;
         fallbackRender?: import("../components").FallbackRender;
         onError?: import("../components").ErrorHandler;
     }>>;
     createContext: <T>(defaultValue: T) => import("..").Context<T>;
     useContext: <T>(context: import("..").Context<T>) => T;
-    memo: <T>(component: import("..").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("..").FC<T>;
+    memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
     isValidElement: (element: unknown) => element is JSXNode;
     createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
     cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;

package/dist/types/jsx/dom/render.d.ts

@@ -25,6 +25,7 @@ export type NodeObject = {
     e: SupportedElement | Text | undefined;
     p?: PreserveNodeType;
     a?: boolean;
+    o?: NodeObject;
     [DOM_STASH]: [
         number,
         any[][],

package/dist/types/middleware/etag/digest.d.ts

@@ -0,0 +1 @@
+export declare const generateDigest: (stream: ReadableStream<Uint8Array> | null) => Promise<string | null>;

package/dist/types/router/linear-router/router.d.ts

@@ -1,11 +1,6 @@
 import type { Result, Router } from '../../router';
 export declare class LinearRouter<T> implements Router<T> {
     name: string;
-    routes: [
-        string,
-        string,
-        T
-    ][];
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T>;
 }

package/dist/types/router/reg-exp-router/node.d.ts

@@ -7,9 +7,6 @@ export interface Context {
     varIndex: number;
 }
 export declare class Node {
-    index?: number;
-    varIndex?: number;
-    children: Record<string, Node>;
     insert(tokens: readonly string[], index: number, paramMap: ParamAssocArray, context: Context, pathErrorCheckOnly: boolean): void;
     buildRegExpStr(): string;
 }

package/dist/types/router/reg-exp-router/router.d.ts

@@ -1,14 +1,7 @@
 import type { Result, Router } from '../../router';
-type HandlerWithMetadata<T> = [
-    T,
-    number
-];
 export declare class RegExpRouter<T> implements Router<T> {
     name: string;
-    middleware?: Record<string, Record<string, HandlerWithMetadata<T>[]>>;
-    routes?: Record<string, Record<string, HandlerWithMetadata<T>[]>>;
     constructor();
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T>;
 }
-export {};

package/dist/types/router/reg-exp-router/trie.d.ts

@@ -1,9 +1,6 @@
-import type { Context, ParamAssocArray } from './node';
-import { Node } from './node';
+import type { ParamAssocArray } from './node';
 export type ReplacementMap = number[];
 export declare class Trie {
-    context: Context;
-    root: Node;
     insert(path: string, index: number, pathErrorCheckOnly: boolean): ParamAssocArray;
     buildRegExp(): [
         RegExp,