hono 1.3.6 → 1.4.0

package/README.md

@@ -38,13 +38,13 @@ app.fire()
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-hono - trie-router(default) x 737,602 ops/sec ±3.65% (67 runs sampled)
-hono - regexp-router x 1,188,203 ops/sec ±6.42% (60 runs sampled)
-itty-router x 163,970 ops/sec ±3.05% (91 runs sampled)
-sunder x 344,468 ops/sec ±0.87% (97 runs sampled)
-worktop x 222,044 ops/sec ±2.13% (85 runs sampled)
-Fastest is hono - regexp-router
-✨  Done in 84.04s.
+hono - trie-router(default) x 725,892 ops/sec ±4.02% (74 runs sampled)
+hono - regexp-router x 733,494 ops/sec ±3.00% (67 runs sampled)
+itty-router x 167,167 ops/sec ±1.25% (91 runs sampled)
+sunder x 327,697 ops/sec ±2.45% (92 runs sampled)
+worktop x 216,468 ops/sec ±3.01% (85 runs sampled)
+Fastest is hono - regexp-router,hono - trie-router(default)
+✨  Done in 69.57s.
 ```
 
 ## Why so fast?
@@ -137,15 +137,15 @@ npm install hono
 
 An instance of `Hono` has these methods.
 
-- app.**HTTP_METHOD**(\[パス,\]handler|middleware...)
-- app.**all**(\[パス,\]handler|middleware...)
-- app.**route**(パス, \[app\])
-- app.**use**(\[パス,\]middleware)
+- app.**HTTP_METHOD**(\[path,\]handler|middleware...)
+- app.**all**(\[path,\]handler|middleware...)
+- app.**route**(path, \[app\])
+- app.**use**(\[path,\]middleware)
 - app.**notFound**(handler)
 - app.**onError**(err, handler)
 - app.**fire**()
 - app.**fetch**(request, env, event)
-- app.**request**(パス, options)
+- app.**request**(path, options)
 
 ## Routing
 
@@ -249,12 +249,37 @@ app.route('/book', book)
 
 ## Middleware
 
-Middleware operate after/before executing Handler. We can get `Response` before dispatching or manipulate `Response` after dispatching.
+Middleware works after/before Handler. We can get `Request` before dispatching or manipulate `Response` after dispatching.
 
 ### Definition of Middleware
 
-- Handler - should return `Response` object.
-- Middleware - should return nothing, do `await next()`
+- Handler - should return `Response` object. Only one handler will be called.
+- Middleware - should return nothing, will be proceeded to next middleware with `await next()`
+
+The user can register middleware using `c.use` or using `c.HTTP_METHOD` as well as the handlers. For this feature, it's easy to specify the path and the method.
+
+```ts
+// match any method, all routes
+app.use('*', logger())
+
+// specify path
+app.use('/posts/*', cors())
+
+// specify method and path
+app.post('/posts/*', basicAuth(), bodyParse())
+```
+
+If the handler returns `Response`, it will be used for the end-user, and stopping the processing.
+
+```ts
+app.post('/posts', (c) => c.text('Created!', 201))
+```
+
+In this case, four middleware are processed before dispatching like this:
+
+```ts
+logger() -> cors() -> basicAuth() -> bodyParse() -> *handler*
+```
 
 ### Built-in Middleware
 
@@ -390,7 +415,6 @@ The Response is the same as below.
 ```ts
 new Response('Thank you for comming', {
   status: 201,
-  statusText: 'Created',
   headers: {
     'X-Message': 'Hello',
     'Content-Type': 'text/plain',
@@ -518,14 +542,47 @@ test('GET /hello is ok', async () => {
 })
 ```
 
-## routerClass
+## router
 
-The `routerClass` option specify which router is used inside. The default router is `TrieRouter`. If you want to use `RexExpRouter`, write like this:
+The `router` option specify which router is used inside. The default router is `TrieRouter`. If you want to use `RexExpRouter`, write like this:
 
 ```ts
 import { RegExpRouter } from 'hono/router/reg-exp-router'
 
-const app = new Hono({ routerClass: RegExpRouter })
+const app = new Hono({ router: new RegExpRouter() })
+```
+
+## Routing Ordering
+
+The routing priority is decided by the order of registration. Only one handler will be dispatched.
+
+```ts
+app.get('/book/a', (c) => c.text('a')) // a
+app.get('/book/:slug', (c) => c.text('common')) // common
+```
+
+```http
+GET /book/a ---> `a` // common will not be dispatched
+GET /book/b ---> `common` // a will not be dispatched
+```
+
+All scoring rules:
+
+```ts
+app.get('/api/*', 'c') // score 1.1 <--- `/*` is special wildcard
+app.get('/api/:type/:id', 'd') // score 3.2
+app.get('/api/posts/:id', 'e') // score 3.3
+app.get('/api/posts/123', 'f') // score 3.4
+app.get('/*/*/:id', 'g') // score 3.5
+app.get('/api/posts/*/comment', 'h') // score 4.6 - not match
+app.get('*', 'a') // score 0.7
+app.get('*', 'b') // score 0.8
+```
+
+```plain
+GET /api/posts/123
+---> will match => c, d, e, f, b, a, b
+---> sort by score => a, b, c, d, e, f, g
 ```
 
 ## Cloudflare Workers with Hono
@@ -615,6 +672,7 @@ export interface Bindings {
 }
 
 const api = new Hono<Bindings>()
+api.use('/posts/*', cors())
 
 api.get('/posts', (c) => {
   const { limit, offset } = c.req.query()
@@ -641,8 +699,6 @@ api.post(
   }
 )
 
-app.use('/posts/*', cors())
-
 app.route('/api', api)
 
 export default app

package/dist/compose.js

@@ -28,7 +28,6 @@ const compose = (middleware, onError, onNotFound) => {
                 if (res && context instanceof context_1.Context) {
                     context.res = res;
                     context.res.finalized = true;
-                    await dispatch(i + 1); // <--- Call next()
                 }
                 return context;
             })

package/dist/context.d.ts

@@ -8,7 +8,6 @@ export declare class Context<RequestParamKeyType extends string = string, E = En
     res: Response;
     env: E;
     event: FetchEvent;
-    private _headers;
     private _status;
     private _pretty;
     private _prettySpace;

package/dist/context.js

@@ -4,7 +4,6 @@ exports.Context = void 0;
 const url_1 = require("./utils/url");
 class Context {
     constructor(req, opts) {
-        this._headers = {};
         this._status = 200;
         this._pretty = false;
         this._prettySpace = 2;
@@ -59,10 +58,7 @@ class Context {
         return req;
     }
     header(name, value) {
-        if (this.res) {
-            this.res.headers.set(name, value);
-        }
-        this._headers[name] = value;
+        this.res.headers.set(name, value);
     }
     status(status) {
         this._status = status;
@@ -79,10 +75,15 @@ class Context {
     }
     newResponse(data, init = {}) {
         init.status = init.status || this._status || 200;
-        init.headers = Object.assign(Object.assign({}, this._headers), init.headers);
+        let headers = {};
+        this.res.headers.forEach((v, k) => {
+            headers[k] = v;
+        });
+        init.headers = Object.assign(headers, init.headers);
+        headers = {};
         return new Response(data, init);
     }
-    body(data, status = this._status, headers = this._headers) {
+    body(data, status = this._status, headers = {}) {
         return this.newResponse(data, {
             status: status,
             headers: headers,

package/dist/hono.d.ts

@@ -54,16 +54,13 @@ declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     patch: HandlerInterface<T, E_1, U>;
 };
 export declare class Hono<E = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
-    readonly routerClass: {
-        new (): Router<any>;
-    };
+    readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
-    private _router;
     private _tempPath;
     private path;
-    private _cacheResponse;
+    private _cachedResponse;
     routes: Route<E>[];
-    constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
+    constructor(init?: Partial<Pick<Hono, 'router' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
     route(path: string, app?: Hono<any>): Hono<E, P>;

package/dist/hono.js

@@ -15,7 +15,7 @@ function defineDynamicClass() {
 class Hono extends defineDynamicClass() {
     constructor(init = {}) {
         super();
-        this.routerClass = trie_router_1.TrieRouter;
+        this.router = new trie_router_1.TrieRouter();
         this.strict = true; // strict routing - default is true
         this.path = '/';
         this.routes = [];
@@ -46,10 +46,9 @@ class Hono extends defineDynamicClass() {
             };
         });
         Object.assign(this, init);
-        this._router = new this.routerClass();
         this._tempPath = null;
-        this._cacheResponse = new Response(null, { status: 404 });
-        this._cacheResponse.finalized = false;
+        this._cachedResponse = new Response(null, { status: 404 });
+        this._cachedResponse.finalized = false;
     }
     route(path, app) {
         this._tempPath = path;
@@ -86,12 +85,12 @@ class Hono extends defineDynamicClass() {
         if (this._tempPath) {
             path = (0, url_1.mergePath)(this._tempPath, path);
         }
-        this._router.add(method, path, handler);
+        this.router.add(method, path, handler);
         const r = { path: path, method: method, handler: handler };
         this.routes.push(r);
     }
     async matchRoute(method, path) {
-        return this._router.match(method, path);
+        return this.router.match(method, path);
     }
     async dispatch(request, event, env) {
         const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
@@ -111,7 +110,7 @@ class Hono extends defineDynamicClass() {
         const c = new context_1.Context(request, {
             env: env,
             event: event,
-            res: this._cacheResponse,
+            res: this._cachedResponse,
         });
         c.notFound = () => this.notFoundHandler(c);
         const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);

package/dist/middleware/jwt/index.js

@@ -8,7 +8,6 @@ const jwt = (options) => {
     }
     return async (ctx, next) => {
         const credentials = ctx.req.headers.get('Authorization');
-        await next();
         if (!credentials) {
             ctx.res = new Response('Unauthorized', {
                 status: 401,
@@ -26,6 +25,7 @@ const jwt = (options) => {
                     'WWW-Authenticate': 'Basic ${options.secret}',
                 },
             });
+            return;
         }
         let authorized = false;
         let msg = '';
@@ -43,7 +43,9 @@ const jwt = (options) => {
                     'WWW-Authenticate': 'Bearer ${options.secret}',
                 },
             });
+            return;
         }
+        await next();
     };
 };
 exports.jwt = jwt;

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

@@ -1,4 +1,4 @@
-import { Router, Result } from '../../router';
+import type { Router, Result } from '../../router';
 interface Hint {
     components: string[];
     regExpComponents: Array<true | string>;
@@ -8,16 +8,22 @@ interface Hint {
     maybeHandler: boolean;
     namedParams: [number, string, string][];
 }
+interface HandlerWithSortIndex<T> {
+    handler: T;
+    index: number;
+    componentsLength: number;
+}
 interface Route<T> {
     method: string;
     path: string;
     hint: Hint;
-    handlers: T[];
-    middleware: T[];
+    handlers: HandlerWithSortIndex<T>[];
+    middleware: HandlerWithSortIndex<T>[];
     paramAliasMap: Record<string, string[]>;
 }
-export declare class RegExpRouter<T> extends Router<T> {
+export declare class RegExpRouter<T> implements Router<T> {
     routeData?: {
+        index: number;
         routes: Route<T>[];
         methods: Set<string>;
     };

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

@@ -64,6 +64,14 @@ function compareRoute(a, b) {
     }
     return i === b.hint.regExpComponents.length || a.hint.endWithWildcard ? 1 : 0;
 }
+function compareHandler(a, b) {
+    return a.componentsLength !== b.componentsLength
+        ? a.componentsLength - b.componentsLength
+        : a.index - b.index;
+}
+function getSortedHandlers(handlers) {
+    return [...handlers].sort(compareHandler).map((h) => h.handler);
+}
 function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
     const trie = new trie_1.Trie({ reverse: hasAmbiguous });
     const handlers = [];
@@ -76,6 +84,9 @@ function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
             [...routes[i].middleware, ...routes[i].handlers],
             Object.keys(paramMap).length !== 0 ? paramMap : null,
         ];
+        if (!hasAmbiguous) {
+            handlers[i][0] = getSortedHandlers(handlers[i][0]);
+        }
     }
     const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
     for (let i = 0, len = handlers.length; i < len; i++) {
@@ -130,22 +141,28 @@ function verifyDuplicateParam(routes) {
     }
     return true;
 }
-class RegExpRouter extends router_1.Router {
+class RegExpRouter {
     constructor() {
-        super(...arguments);
-        this.routeData = { routes: [], methods: new Set() };
+        this.routeData = { index: 0, routes: [], methods: new Set() };
     }
     add(method, path, handler) {
         if (!this.routeData) {
             throw new Error('Can not add a route since the matcher is already built.');
         }
-        const { routes, methods } = this.routeData;
+        this.routeData.index++;
+        const { index, routes, methods } = this.routeData;
         if (path === '/*') {
             path = '*';
         }
+        const hint = initHint(path);
+        const handlerWithSortIndex = {
+            index,
+            handler,
+            componentsLength: hint.components.length,
+        };
         for (let i = 0, len = routes.length; i < len; i++) {
             if (routes[i].method === method && routes[i].path === path) {
-                routes[i].handlers.push(handler);
+                routes[i].handlers.push(handlerWithSortIndex);
                 return;
             }
         }
@@ -153,8 +170,8 @@ class RegExpRouter extends router_1.Router {
         routes.push({
             method,
             path,
-            handlers: [handler],
-            hint: initHint(path),
+            hint,
+            handlers: [handlerWithSortIndex],
             middleware: [],
             paramAliasMap: {},
         });
@@ -163,7 +180,8 @@ class RegExpRouter extends router_1.Router {
         const [primaryMatchers, secondaryMatchers, hasAmbiguous] = this.buildAllMatchers();
         this.match = hasAmbiguous
             ? (method, path) => {
-                const matcher = primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL];
+                const matcher = (primaryMatchers[method] ||
+                    primaryMatchers[router_1.METHOD_NAME_ALL]);
                 let match = path.match(matcher[0]);
                 if (!match) {
                     // do not support secondary matchers here.
@@ -193,10 +211,10 @@ class RegExpRouter extends router_1.Router {
                     regExpSrc = regExpSrc.replace(new RegExp(`((?:(?:\\(\\?:|.)*?\\([^)]*\\)){${index - 1}}.*?)\\(\\)`), '$1(^)');
                     match = path.match(new RegExp(regExpSrc));
                 }
-                return new router_1.Result([...handlers.values()], params);
+                return { handlers: getSortedHandlers(handlers.values()), params };
             }
             : (method, path) => {
-                let matcher = primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL];
+                let matcher = (primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL]);
                 let match = path.match(matcher[0]);
                 if (!match) {
                     const matchers = secondaryMatchers[method] || secondaryMatchers[router_1.METHOD_NAME_ALL];
@@ -209,15 +227,15 @@ class RegExpRouter extends router_1.Router {
                     }
                 }
                 const index = match.indexOf('', 1);
-                const [handler, paramMap] = matcher[1][index];
+                const [handlers, paramMap] = matcher[1][index];
                 if (!paramMap) {
-                    return new router_1.Result(handler, emptyParam);
+                    return { handlers, params: emptyParam };
                 }
                 const params = {};
                 for (let i = 0, len = paramMap.length; i < len; i++) {
                     params[paramMap[i][0]] = match[paramMap[i][1]];
                 }
-                return new router_1.Result(handler, params);
+                return { handlers, params };
             };
         return this.match(method, path);
     }
@@ -296,7 +314,17 @@ class RegExpRouter extends router_1.Router {
                             routes[j].path = components.join('');
                         }
                     }
-                    routes[j].middleware.push(...routes[i].handlers);
+                    if (routes[j].hint.components.length < routes[i].hint.components.length) {
+                        const componentsLength = routes[j].hint.components.length;
+                        routes[j].middleware.push(...routes[i].handlers.map((h) => ({
+                            componentsLength,
+                            index: h.index,
+                            handler: h.handler,
+                        })));
+                    }
+                    else {
+                        routes[j].middleware.push(...routes[i].handlers);
+                    }
                     routes[i].hint.maybeHandler = false;
                 }
                 else if (compareResult === 2) {

package/dist/router/trie-router/node.d.ts

@@ -1,13 +1,20 @@
-import { Result } from '../../router';
+import type { Result } from '../../router';
 import type { Pattern } from '../../utils/url';
+declare type HandlerSet<T> = {
+    handler: T;
+    score: number;
+    name: string;
+};
 export declare class Node<T> {
-    methods: Record<string, T>[];
-    handlers: T[];
+    methods: Record<string, HandlerSet<T>>[];
     children: Record<string, Node<T>>;
     patterns: Pattern[];
+    order: number;
+    name: string;
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
-    private getHandlers;
+    private getHandlerSets;
     private next;
     search(method: string, path: string): Result<T>;
 }
+export {};

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

@@ -19,16 +19,19 @@ function findParam(node, name) {
 }
 class Node {
     constructor(method, handler, children) {
+        this.order = 0;
         this.children = children || {};
         this.methods = [];
         if (method && handler) {
             const m = {};
-            m[method] = handler;
+            m[method] = { handler: handler, score: 0, name: this.name };
             this.methods = [m];
         }
         this.patterns = [];
     }
     insert(method, path, handler) {
+        this.name = `${method} ${path}`;
+        this.order = ++this.order;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let curNode = this;
         const parts = (0, url_1.splitPath)(path);
@@ -62,32 +65,39 @@ class Node {
             parentPatterns.push(...curNode.patterns);
             curNode = curNode.children[p];
         }
+        let score = 1;
+        if (path === '*') {
+            score = score + this.order * 0.01;
+        }
+        else {
+            score = parts.length + 1 + this.order * 0.01;
+        }
         if (!curNode.methods.length) {
             curNode.methods = [];
         }
         const m = {};
-        m[method] = handler;
+        const handlerSet = { handler: handler, name: this.name, score: score };
+        m[method] = handlerSet;
         curNode.methods.push(m);
         return curNode;
     }
-    getHandlers(node, method) {
-        const handlers = [];
+    getHandlerSets(node, method, wildcard) {
+        const handlerSets = [];
         node.methods.map((m) => {
-            let handler = m[method];
-            if (handler !== undefined) {
-                handlers.push(handler);
-                return;
-            }
-            handler = m[router_1.METHOD_NAME_ALL];
-            if (handler !== undefined) {
-                handlers.push(handler);
+            const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
+            if (handlerSet !== undefined) {
+                const hs = Object.assign({}, handlerSet);
+                if (wildcard) {
+                    hs.score = handlerSet.score - 1;
+                }
+                handlerSets.push(hs);
                 return;
             }
         });
-        return handlers;
+        return handlerSets;
     }
     next(node, part, method, isLast) {
-        const handlers = [];
+        const handlerSets = [];
         const nextNodes = [];
         const params = {};
         for (let j = 0, len = node.patterns.length; j < len; j++) {
@@ -97,7 +107,11 @@ class Node {
             if (pattern === '*') {
                 const astNode = node.children['*'];
                 if (astNode) {
-                    handlers.push(...this.getHandlers(astNode, method));
+                    let wildcard = false;
+                    if (!Object.keys(astNode.children).length) {
+                        wildcard = true;
+                    }
+                    handlerSets.push(...this.getHandlerSets(astNode, method, wildcard));
                     nextNodes.push(astNode);
                 }
             }
@@ -109,7 +123,7 @@ class Node {
             if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
                 if (typeof key === 'string') {
                     if (isLast === true) {
-                        handlers.push(...this.getHandlers(node.children[key], method));
+                        handlerSets.push(...this.getHandlerSets(node.children[key], method));
                     }
                     nextNodes.push(node.children[key]);
                 }
@@ -122,22 +136,22 @@ class Node {
         if (nextNode) {
             if (isLast === true) {
                 // '/hello/*' => match '/hello'
-                if (nextNode.children['*'] !== undefined) {
-                    handlers.push(...this.getHandlers(nextNode.children['*'], method));
+                if (nextNode.children['*']) {
+                    handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
                 }
-                handlers.push(...this.getHandlers(nextNode, method));
+                handlerSets.push(...this.getHandlerSets(nextNode, method));
             }
             nextNodes.push(nextNode);
         }
         const next = {
             nodes: nextNodes,
-            handlers: handlers,
+            handlerSets: handlerSets,
             params: params,
         };
         return next;
     }
     search(method, path) {
-        const handlers = [];
+        const handlerSets = [];
         let params = {};
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const curNode = this;
@@ -152,15 +166,22 @@ class Node {
                 if (res.nodes.length === 0) {
                     continue;
                 }
-                handlers.push(...res.handlers);
+                handlerSets.push(...res.handlerSets);
                 params = Object.assign(params, res.params);
                 tempNodes.push(...res.nodes);
             }
             curNodes = tempNodes;
         }
-        if (handlers.length <= 0)
+        if (handlerSets.length <= 0)
             return null;
-        return new router_1.Result(handlers, params);
+        const handlers = handlerSets
+            .sort((a, b) => {
+            return a.score - b.score;
+        })
+            .map((s) => {
+            return s.handler;
+        });
+        return { handlers, params };
     }
 }
 exports.Node = Node;

package/dist/router/trie-router/router.d.ts

@@ -1,7 +1,6 @@
-import { Router } from '../../router';
-import type { Result } from '../../router';
+import type { Result, Router } from '../../router';
 import { Node } from './node';
-export declare class TrieRouter<T> extends Router<T> {
+export declare class TrieRouter<T> implements Router<T> {
     node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;

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

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrieRouter = void 0;
-const router_1 = require("../../router");
 const node_1 = require("./node");
-class TrieRouter extends router_1.Router {
+class TrieRouter {
     constructor() {
-        super();
         this.node = new node_1.Node();
     }
     add(method, path, handler) {

package/dist/router.d.ts

@@ -1,11 +1,10 @@
 export declare const METHOD_NAME_ALL: "ALL";
 export declare const METHOD_NAME_ALL_LOWERCASE: "all";
-export declare abstract class Router<T> {
-    abstract add(method: string, path: string, handler: T): void;
-    abstract match(method: string, path: string): Result<T> | null;
+export interface Router<T> {
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
 }
-export declare class Result<T> {
+export interface Result<T> {
     handlers: T[];
     params: Record<string, string>;
-    constructor(handlers: T[], params: Record<string, string>);
 }

package/dist/router.js

@@ -1,15 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Result = exports.Router = exports.METHOD_NAME_ALL_LOWERCASE = exports.METHOD_NAME_ALL = void 0;
+exports.METHOD_NAME_ALL_LOWERCASE = exports.METHOD_NAME_ALL = void 0;
 exports.METHOD_NAME_ALL = 'ALL';
 exports.METHOD_NAME_ALL_LOWERCASE = 'all';
-class Router {
-}
-exports.Router = Router;
-class Result {
-    constructor(handlers, params) {
-        this.handlers = handlers;
-        this.params = params;
-    }
-}
-exports.Result = Result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "1.3.6",
+  "version": "1.4.0",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",