update dev dependencies

.editorconfig

@@ -0,0 +1,17 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = false
+
+[src/**.ts]
+charset = utf-8
+indent_style = tab
+
+[README.md]
+indent_style = space
+indent_size = 4
+
+[{package,package-lock}.json]
+indent_style = space
+indent_size = 2

.github/workflows/publish-main.yml

@@ -1,30 +0,0 @@
-name: Publish (main)
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-      - name: Install dependencies
-        run: npm ci
-      - name: Build
-        run: npm run build
-      - name: Publish to npmjs
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
-        run: npm publish --tag latest --access public
-      - uses: actions/setup-node@v1
-        with:
-          registry-url: https://npm.pkg.github.com/
-      - name: Publish to GPR
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-        run: npm publish --tag latest --access public

.github/workflows/publish.yml

@@ -0,0 +1,40 @@
+name: Publish
+run-name: Publish ${{ github.ref_name }}
+
+on:
+  release:
+    types: [ published ]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: latest
+          registry-url: https://registry.npmjs.org/
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish to npmjs
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npm publish --tag ${{ contains(github.ref_name, '-') && 'pre' || 'latest' }} --access public
+
+      - uses: actions/setup-node@v3
+        with:
+          node-version: latest
+          registry-url: https://npm.pkg.github.com/
+
+      - name: Publish to GPR
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npm publish --tag ${{ contains(github.ref_name, '-') && 'pre' || 'latest' }} --access public

.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release
+run-name: Release ${{ github.ref_name }}
+
+on:
+  push:
+    tags:
+    - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: latest
+          registry-url: https://registry.npmjs.org/
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Build
+        run: npm run build
+
+      - name: Create release
+        run: gh release create ${{ github.ref_name }} --draft --generate-notes ${{ contains(github.ref_name, '-') && '--prerelease --latest=false' || '--latest' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -0,0 +1,26 @@
+name: Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: latest
+          registry-url: https://registry.npmjs.org/
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Build
+        run: npm run build

.npmignore

@@ -1,6 +1,10 @@
+.editorconfig
 .github/
-src/
-test/
+.gitignore
 .nvmrc
+coverage/
+jest.config.ts
 MIGRATION.md
+src/
+tests/
 tsconfig.json

.nvmrc

@@ -1 +0,0 @@
-v16

MIGRATION.md

@@ -1,71 +1,69 @@
 # Migration Guide
 
-From `v1.x.x` to `v2.x.x`.
+From `v2.x.x` to `v3.x.x`.
+
 
 ## Contents
 
-- [Preparation](#preparation)
-- [Update](#update)
-- [Import / Require](#import--require)
-- [Routes](#routes)
-- [Fetch](#fetch--routerhandle)
+- [Update Router](#update-router)
+- [Handlers](#handlers)
 
 
-## Preparation
+## Update Router
 
-Follow Cloudflare's [Migration Guide](https://developers.cloudflare.com/workers/wrangler/migration/migrating-from-wrangler-1/) to update your protject to [wrangler2](https://github.com/cloudflare/wrangler2).
-
-## Update
-
-Update to the latest version verstion
+Update to the latest version version of the router.
 
 ```bash
-npm i -D @tsndr/cloudflare-worker-router
+npm i -D @tsndr/cloudflare-worker-router@^3
 ```
 
-## Import / Require
 
-Switch to ESModules.
+## Handlers
+
+- Remove `res` and `next` from handler parameter list.
+- Replace `res.` with `return new Response()` / `return Response.json()`.
+- Remove `next()` calls from middlewares.
+
 
 ### Before
 
-```javascript
-const Router = require('@tsndr/cloudflare-worker-router')
+```typescript
+// Register global middleware
+router.use(({ env, req, res, next }) => {
+    if (req.headers.get('authorization') !== env.SECRET_TOKEN) {
+        res.status = 401
+        return
+    }
+
+    next()
+})
+
+// Simple get
+router.get('/user', ({ res }) => {
+    res.body = {
+        id: 1,
+        name: 'John Doe'
+    }
+})
 ```
 
 
 ### After
 
-```javascript
-import Router from '@tsndr/cloudflare-worker-router'
+```typescript
+// Register global middleware
+router.use(({ env, req }) => {
+    // Intercept if token doesn't match
+    if (req.headers.get('authorization') !== env.SECRET_TOKEN) {
+        return new Response(null, { status: 401 })
+    }
+})
+
+// Simple get
+router.get('/user', () => {
+    return Response.json({
+        id: 1,
+        name: 'John Doe'
+    })
+})
 ```
-
-
-## Routes
-
-Just add curly braces.
-
-
-### Before
-
-<a href="https://gist.github.com/tsndr/34e8544266ae15d51abd019d7c3d27ca" target="_blank"><img width="469" alt="Petrify 2022-06-24 at 5 57 01 PM" src="https://user-images.githubusercontent.com/2940127/175572731-a8729c1b-15e2-45ac-be80-7e8527c5502a.png"></a>
-
-
-### After
-
-<a href="https://gist.github.com/tsndr/8db6e8dd55e348015c2ff8e93dd6aa31" target="_blank"><img width="469" alt="Petrify 2022-06-24 at 5 55 56 PM" src="https://user-images.githubusercontent.com/2940127/175572549-0eea8fc4-3d90-412a-89cc-d2f4569f1139.png"></a>
-
-
-## Fetch / `router.handle()`
-
-❗️ Be aware that with `v2.0.0` the parameters of `router.handle()` changed ❗️
-
-
-### Before
-
-<a href="https://gist.github.com/tsndr/12b0f800269760c597646c90a562ef88" target="_blank"><img width="469" alt="Petrify 2022-06-24 at 5 58 43 PM" src="https://user-images.githubusercontent.com/2940127/175572993-fb4681c2-eece-4c92-88e8-1c2f57644769.png"></a>
-
-
-### After
-
-<a href="https://gist.github.com/tsndr/30902b01b134e2a58cf3a53648dd3e47" target="_blank"><img width="393" alt="Petrify 2022-06-24 at 5 59 22 PM" src="https://user-images.githubusercontent.com/2940127/175573110-b7dfcfb2-855d-4529-a957-6f8b9ec439f3.png"></a>

README.md

@@ -1,37 +1,42 @@
 # Cloudflare Workers Router
 
-Cloudflare Workers Router is a super lightweight router (1.3K gzipped) with middleware support and **ZERO dependencies** for [Cloudflare Workers](https://workers.cloudflare.com/).
+Cloudflare Workers Router is a super lightweight router (1.0K gzipped) with middleware support and **ZERO dependencies** for [Cloudflare Workers](https://workers.cloudflare.com/).
 
 When I was trying out Cloudflare Workers I almost immediately noticed how fast it was compared to other serverless offerings. So I wanted to build a full-fledged API to see how it performs doing real work, but since I wasn't able to find a router that suited my needs I created my own.
 
-I worked a lot with [Express.js](https://expressjs.com/) in the past and really enjoyed their middleware approach, but since none of the available Cloudflare Worker routers offered middleware support at the time, I felt the need to create this router.
-
 
 ## Contents
 
 - [Features](#features)
 - [Usage](#usage)
 - [Reference](#reference)
-- [Setup](#setup)
+- [Getting started](#getting-started)
 
 
 ## Features
 
 - ZERO dependencies
-- Lightweight (1.3K gzipped)
+- Lightweight (1.0K gzipped)
 - Fully written in TypeScript
-- Integrated Debug-Mode & CORS helper
 - Built specifically around Middlewares
+- Debug-Mode, CORS and Bearer helpers
+- Allows accessing request body multiple times
 
 
 ## Usage
 
+Migrating from `v2.x.x`, check out the [Migration Guide](MIGRATION.md).
+
 ### TypeScript Example
 
 ```typescript
 import { Router } from '@tsndr/cloudflare-worker-router'
 
-export interface Env {
+// Env Types
+export type Var<T = string> = T
+export type Secret<T = string> = T
+
+export type Env = {
     // Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
     // MY_KV_NAMESPACE: KVNamespace
     //
@@ -40,71 +45,80 @@ export interface Env {
     //
     // Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
     // MY_BUCKET: R2Bucket
+
+    ENVIRONMENT: Var<'dev' | 'prod'>
+
+    SECRET_TOKEN: Secret
 }
 
+// Request Extension
+export type ExtReq = {
+    userId?: number
+}
 
-// Initialize router
-const router = new Router<Env>()
+// Context Extension
+export type ExtCtx = {
+    //sentry?: Toucan
+}
+
+// Initialize Router
+const router = new Router<Env, ExtCtx, ExtReq>()
 
 // Enabling build in CORS support
 router.cors()
 
 // Register global middleware
-router.use(({ req, res, next }) => {
-    res.headers.set('X-Global-Middlewares', 'true')
-    next()
+router.use(({ env, req }) => {
+    // Intercept if token doesn't match
+    if (req.headers.get('authorization') !== env.SECRET_TOKEN)
+        return new Response(null, { status: 401 })
 })
 
 // Simple get
-router.get('/user', ({ req, res }) => {
-    res.body = {
-        data: {
-            id: 1,
-            name: 'John Doe'
-        }
-    }
+router.get('/user', () => {
+    return Response.json({
+        id: 1,
+        name: 'John Doe'
+    })
 })
 
 // Post route with url parameter
-router.post('/user/:id', ({ req, res }) => {
+router.post('/user/:id', ({ req }) => {
 
     const userId = req.params.id
 
-    // Do stuff...
+    // Do stuff
 
-    if (errorDoingStuff) {
-        res.status = 400
-        res.body = {
-            error: 'User did stupid stuff!'
-        }
-        return
+    if (!true) {
+        return Response.json({
+            error: 'Error doing stuff!'
+        }, { status: 400 })
     }
 
-    res.status = 204
+    return Response.json({ userId }, { status: 204 })
 })
 
 // Delete route using a middleware
-router.delete('/user/:id', ({ req, res, next }) => {
+router.delete('/user/:id', ({ env, req }) => {
+    if (req.headers.get('authorization') === env.SECRET_TOKEN)
+        return new Response(null, { status: 401 })
 
-    if (!apiTokenIsCorrect) {
-        res.status = 401
-        return
-    }
+}, ({ req }) => {
 
-    await next()
-}, (req, res) => {
+  const userId = req.params.id
 
-    const userId = req.params.id
+  // Do stuff...
 
-    // Do stuff...
+  return Response.json({ userId })
 })
 
 // Listen Cloudflare Workers Fetch Event
 export default {
-    async fetch(request: Request, env: Env): Promise<Response> {
-        return router.handle(env, request)
+    async fetch(request: Request, env: Env, ctx: ExecutionContext) {
+        return router.handle(request, env, ctx)
     }
 }
+
 ```
 
 <details>
@@ -120,59 +134,54 @@ const router = new Router()
 router.cors()
 
 // Register global middleware
-router.use(({ req, res, next }) => {
-    res.headers.set('X-Global-Middlewares', 'true')
-    next()
+router.use(({ env, req }) => {
+    // Intercept if token doesn't match
+    if (req.headers.get('authorization') !== env.SECRET_TOKEN)
+        return new Response(null, { status: 401 })
 })
 
 // Simple get
-router.get('/user', ({ req, res }) => {
-    res.body = {
-        data: {
-            id: 1,
-            name: 'John Doe'
-        }
-    }
+router.get('/user', () => {
+    return Response.json({
+        id: 1,
+        name: 'John Doe'
+    })
 })
 
 // Post route with url parameter
-router.post('/user/:id', ({ req, res }) => {
+router.post('/user/:id', ({ req }) => {
 
     const userId = req.params.id
 
-    // Do stuff...
+    // Do stuff
 
-        if (errorDoingStuff) {
-            res.status = 400
-            res.body = {
-                error: 'User did stupid stuff!'
-            }
-            return
-        }
+    if (!true) {
+        return Response.json({
+            error: 'Error doing stuff!'
+        }, { status: 400 })
+    }
 
-    res.status = 204
+    return Response.json({ userId }, { status: 204 })
 })
 
 // Delete route using a middleware
-router.delete('/user/:id', ({ req, res, next }) => {
+router.delete('/user/:id', ({ env, req }) => {
+    if (req.headers.get('authorization') === env.SECRET_TOKEN)
+        return new Response(null, { status: 401 })
 
-    if (!apiTokenIsCorrect) {
-        res.status = 401
-        return
-    }
+}, ({ req }) => {
 
-    await next()
-}, (req, res) => {
+  const userId = req.params.id
 
-    const userId = req.params.id
+  // Do stuff...
 
-    // Do stuff...
+  return Response.json({ userId })
 })
 
 // Listen Cloudflare Workers Fetch Event
 export default {
-    async fetch(request, env) {
-        return router.handle(env, request)
+    async fetch(request, env, ctx) {
+        return router.handle(request, env, ctx)
     }
 }
 ```
@@ -206,7 +215,7 @@ Handler is a `function` which will be called for every request.
 
 #### `ctx`
 
-Object containing `env`, [`req`](#req-object), [`res`](#res-object), `next`
+Object containing `env`, [`req`](#req-object)
 
 
 ### `router.cors([config])`
@@ -216,19 +225,20 @@ If enabled will overwrite other `OPTIONS` requests.
 
 #### `config` (object, optional)
 
-Key                    | Type      | Default Value
----------------------- | --------- | -------------
-`allowOrigin`          | `string`  | `*`
-`allowMethods`         | `string`  | `*`
-`allowHeaders`         | `string`  | `*`
-`maxAge`               | `integer` | `86400`
-`optionsSuccessStatus` | `integer` | `204`
+Key                        | Type       | Default Value
+-------------------------- | ---------- | -------------
+`allowOrigin`              | `string`   | `*`
+`allowMethods`             | `string`   | `*`
+`allowHeaders`             | `string`   | `*`
+`allowCredentials`         | `boolean`  | `undefined`
+`vary`                     | `string`   | `undefined`
+`maxAge`                   | `integer`  | `86400`
+`optionsSuccessStatus`     | `integer`  | `204`
 
 
 ### Supported Methods
 
 - `router.any(url, [...handlers])`
-- `router.connect(url, [...handlers])`
 - `router.delete(url, [...handlers])`
 - `router.get(url, [...handlers])`
 - `router.head(url, [...handlers])`
@@ -236,7 +246,6 @@ Key                    | Type      | Default Value
 - `router.patch(url, [...handlers])`
 - `router.post(url, [...handlers])`
 - `router.put(url, [...handlers])`
-- `router.trace(url, [...handlers])`
 
 
 #### `url` (string)
@@ -247,16 +256,16 @@ Supports the use of dynamic parameters, prefixed with a `:` (i.e. `/user/:userId
 
 #### `handlers` (function, optional)
 
-An unlimited number of functions getting [`req`](#req-object) and [`res`](#res-object) passed into them.
+An unlimited number of functions getting [`ctx`](#ctx-object) passed into them.
 
 
 ### `ctx`-Object
+
 Key       | Type                | Description
 --------- | ------------------- | -----------
 `env`     | `object`            | Environment
 `req`     | `req`-Object        | Request Object
-`res`     | `res`-Object        | Response Object
-`next`    | `next`-Handler      | Next Handler
+`ctx`     | `ctx`-Object        | Cloudflare's `ctx`-Object
 
 
 ### `req`-Object
@@ -270,17 +279,7 @@ Key       | Type                | Description
 `query`   | `object`            | Object containing all query parameters
 
 
-### `res`-Object
-
-Key         | Type                | Description
------------ | ------------------- | -----------
-`body`      | `object` / `string` | Either set an `object` (will be converted to JSON) or a string
-`headers`   | `Headers`           | Response [Headers Object](https://developer.mozilla.org/en-US/docs/Web/API/Headers)
-`status`    | `integer`           | Return status code (default: `204`)
-`webSocket` | `WebSocket`         | Upgraded websocket connection
-
-
-## Setup
+## Getting started
 
 Please follow Cloudflare's [Get started guide](https://developers.cloudflare.com/workers/get-started/guide/) to install wrangler.
 
@@ -294,7 +293,7 @@ wrangler init <name>
 Use of TypeScript is strongly encouraged :)
 
 ```bash
-npm i -D @tsndr/cloudflare-worker-router
+npm i @tsndr/cloudflare-worker-router
 ```
 
 
@@ -303,7 +302,11 @@ npm i -D @tsndr/cloudflare-worker-router
 ```typescript
 import { Router } from '@tsndr/cloudflare-worker-router'
 
-export interface Env {
+// Env Types
+export type Var<T = string> = T
+export type Secret<T = string> = T
+
+export type Env = {
   // Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
   // MY_KV_NAMESPACE: KVNamespace
   //
@@ -312,32 +315,57 @@ export interface Env {
   //
   // Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
   // MY_BUCKET: R2Bucket
+  //
+  // Example Variable
+  // ENVIRONMENT: Var<'dev' | 'prod'>
+  //
+  // Example Secret
+  // JWT_SECRET: Secret
 }
 
-const router = new Router<Env>()
+// Request Extension
+export type ExtReq = {
+  userId?: number
+}
+
+// Context Extension
+export type ExtCtx = {
+  //sentry?: Toucan
+}
+
+// Handler Type
+export type Handler = RouterHandler<Env, ExtCtx, ExtReq>
+
+// Initialize Router
+const router = new Router<Env, ExtCtx, ExtReq>()
+
+// Enable Debug Mode
+router.debug()
+
+// Enabling build in CORS support
+//router.cors()
 
 /// Example Route
 //
-// router.get(/'hi', ({ res }) => {
-//    res.body = 'Hello World'
-//}
+// router.get('/hi', async () => {
+//   return new Response('Hello World')
+// })
 
 
 /// Example Route for splitting into multiple files
 //
-// const hiHandler: RouteHandler<Env> = ({ res }) => {
-//     res.body = 'Hello World'
+// const helloHandler: Handler = async () => {
+//    return new Response('Hello World')
 // }
 //
-// router.get('/hi', hiHandler)
-
+// router.get('/hellow', helloHandler)
 
 // TODO: add your routes here
 
 export default {
-    async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
-        return router.handle(env, request)
-    }
+  async fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    return router.handle(request, env, ctx)
+  }
 }
 ```
 
@@ -352,15 +380,31 @@ import { Router } from '@tsndr/cloudflare-worker-router'
 
 const router = new Router()
 
-// router.get(/'hi', ({ res }) => {
-//    res.body = 'Hello World'
-//}
+// Enable Debug Mode
+//router.debug()
+
+// Enabling build in CORS support
+//router.cors()
+
+/// Example Route
+//
+// router.get('/hi', async () => {
+//    return new Response('Hello World')
+//})
+
+/// Example Route for splitting into multiple files
+//
+// async function hiHandler() {
+//    return new Response('Hello World')
+// }
+//
+// router.get('/hi', hiHandler)
 
 // TODO: add your routes here
 
 export default {
     async fetch(request, env, ctx) {
-        return router.handle(env, request)
+        return router.handle(request, env, ctx)
     }
 }
-```
+```

package.json

@@ -1,22 +1,23 @@
 {
   "name": "@tsndr/cloudflare-worker-router",
-  "version": "2.3.0",
+  "version": "3.3.0",
   "description": "",
-  "main": "index.js",
+  "type": "module",
+  "exports": "./index.js",
   "types": "index.d.ts",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "vitest"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tsndr/cloudflare-worker-router.git"
   },
   "keywords": [
+    "api",
     "cloudflare",
     "cloudflare-worker",
     "cloudflare-workers",
-    "express",
-    "expressjs",
     "framework",
     "middleware",
     "router",
@@ -31,7 +32,9 @@
   },
   "homepage": "https://github.com/tsndr/cloudflare-worker-router#readme",
   "devDependencies": {
-    "@cloudflare/workers-types": "^3.13.0",
-    "typescript": "^4.7.4"
+    "@cloudflare/workers-types": "^4.20250724.0",
+    "@edge-runtime/vm": "^5.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
   }
 }

src/index.ts

@@ -1,481 +1,450 @@
 /**
- * Route Object
- *
- * @typedef Route
- * @property {string} method HTTP request method
- * @property {string} url URL String
- * @property {RouterHandler[]} handlers Array of handler functions
- */
- export interface Route<TEnv> {
-    method: string
-    url: string
-    handlers: RouterHandler<TEnv>[]
+* Route Object
+*
+* @typedef Route
+* @property {string} method HTTP request method
+* @property {string} url URL String
+* @property {RouterHandler[]} handlers Array of handler functions
+*/
+export type Route<Env, CtxExt, ReqExt> = {
+	method: string
+	url: string
+	handlers: RouterHandler<Env, CtxExt, ReqExt>[]
 }
 
 /**
- * Router Context
- *
- * @typedef RouterContext
- * @property {RouterEnv} env Environment
- * @property {RouterRequest} req Request Object
- * @property {RouterResponse} res Response Object
- * @property {RouterNext} next Next Handler
- */
-export interface RouterContext<TEnv> {
-    env: TEnv
-    req: RouterRequest
-    res: RouterResponse
-    next: RouterNext
+* Router Context
+*
+* @typedef RouterContext
+* @property {RouterEnv} env Environment
+* @property {RouterRequest} req Request Object
+* @property {ExecutionContext} ctx Context Object
+*/
+export type RouterContext<Env = any, CtxExt = {}, ReqExt = {}> = CtxExt & {
+	env: Env
+	req: RouterRequest<ReqExt>
+	dbg: boolean
+	ctx?: ExecutionContext
 }
 
 /**
- * Request Object
- *
- * @typedef RouterRequest
- * @property {string} url URL
- * @property {string} method HTTP request method
- * @property {RouterRequestParams} params Object containing all parameters defined in the url string
- * @property {RouterRequestQuery} query Object containing all query parameters
- * @property {Headers} headers Request headers object
- * @property {string | any} body Only available if method is `POST`, `PUT`, `PATCH` or `DELETE`. Contains either the received body string or a parsed object if valid JSON was sent.
- * @property {IncomingRequestCfProperties} [cf] object containing custom Cloudflare properties. (https://developers.cloudflare.com/workers/examples/accessing-the-cloudflare-object)
- */
-export interface RouterRequest {
-    url: string
-    method: string
-    params: RouterRequestParams
-    query: RouterRequestQuery
-    headers: Headers
-    body: string | any
-    cf?: IncomingRequestCfProperties
-    [key: string]: any
+* Request Object
+*
+* @typedef RouterRequest
+* @property {string} url URL
+* @property {string} method HTTP request method
+* @property {RouterRequestParams} params Object containing all parameters defined in the url string
+* @property {RouterRequestQuery} query Object containing all query parameters
+* @property {Headers} headers Request headers object
+* @property {Request} raw Raw Request Object
+* @property {IncomingRequestCfProperties} [cf] object containing custom Cloudflare properties. (https://developers.cloudflare.com/workers/examples/accessing-the-cloudflare-object)
+*/
+export type RouterRequest<ReqExt> = ReqExt & {
+	url: string
+	method: string
+	params: RouterRequestParams
+	query: RouterRequestQuery
+	headers: Headers
+	raw: Request
+	arrayBuffer(): Promise<ArrayBuffer>
+	text(): Promise<string>
+	json<T>(): Promise<T>
+	formData(): Promise<FormData>
+	blob(): Promise<Blob>
+	bearer(): string | undefined
+	basic(): [string, string]
+	cf?: IncomingRequestCfProperties
 }
 
 /**
- * Request Parameters
- *
- * @typedef RouterRequestParams
- */
-export interface RouterRequestParams {
-    [key: string]: string
+* Request Parameters
+*
+* @typedef RouterRequestParams
+*/
+export type RouterRequestParams = {
+	[key: string]: string
 }
 
 /**
- * Request Query
- *
- * @typedef RouterRequestQuery
- */
-export interface RouterRequestQuery {
-    [key: string]: string
+* Request Query
+*
+* @typedef RouterRequestQuery
+*/
+export type RouterRequestQuery = {
+	[key: string]: string
 }
 
 /**
- * Response Object
- *
- * @typedef RouterResponse
- * @property {Headers} headers Response headers object
- * @property {number} [status=204] Return status code (default: `204`)
- * @property {string | any} [body] Either an `object` (will be converted to JSON) or a string
- * @property {Response} [raw] A response object that is to be returned, this will void all other res properties and return this as is.
- */
-export interface RouterResponse {
-    headers: Headers
-    status?: number
-    body?: string | any
-    raw?: Response,
-    webSocket?: WebSocket
+* Handler Function
+*
+* @callback RouterHandler
+* @param {RouterContext} ctx
+* @returns {Promise<Response | void> Response | void}
+*/
+export type RouterHandler<Env = any, CtxExt = {}, ReqExt = {}> = {
+	(ctx: RouterContext<Env, CtxExt, ReqExt>): Promise<Response | void> | Response | void
 }
 
 /**
- * Next Function
- *
- * @callback RouterNext
- * @returns {Promise<void>}
- */
-export interface RouterNext {
-    (): Promise<void>
+* CORS Config
+*
+* @typedef RouterCorsConfig
+* @property {string} [allowOrigin="*"] Access-Control-Allow-Origin (default: `*`)
+* @property {string} [allowMethods="*"] Access-Control-Allow-Methods (default: `*`)
+* @property {string} [allowHeaders="*"] Access-Control-Allow-Headers (default: `*`)
+* @property {boolean} [allowCredentials="true"] Access-Control-Allow-Credentials (default: undefined)
+* @property {string} [vary="origin"] vary (default: undefined)
+* @property {number} [maxAge=86400] Access-Control-Max-Age (default: `86400`)
+* @property {number} [optionsSuccessStatus=204] Return status code for OPTIONS request (default: `204`)
+*/
+export type RouterCorsConfig = {
+	allowOrigin?: string
+	allowMethods?: string
+	allowHeaders?: string
+	allowCredentials?: boolean
+	vary?: string
+	maxAge?: number
+	optionsSuccessStatus?: number
+}
+
+export type RouterBuffer = {
+	arrayBuffer?: ArrayBuffer
+	text?: string
+	json?: any
+	formData?: FormData
+	blob?: Blob
 }
 
 /**
- * Handler Function
- *
- * @callback RouterHandler
- * @param {RouterContext} ctx
- * @returns {Promise<void> | void}
- */
-export interface RouterHandler<TEnv = any> {
-    (ctx: RouterContext<TEnv>): Promise<void> | void
-}
+* Router
+*
+* @public
+* @class
+*/
+export class Router<Env = any, CtxExt = {}, ReqExt = {}> {
 
-/**
- * CORS Config
- *
- * @typedef RouterCorsConfig
- * @property {string} [allowOrigin="*"] Access-Control-Allow-Origin (default: `*`)
- * @property {string} [allowMethods="*"] Access-Control-Allow-Methods (default: `*`)
- * @property {string} [allowHeaders="*"] Access-Control-Allow-Headers (default: `*`)
- * @property {number} [maxAge=86400] Access-Control-Max-Age (default: `86400`)
- * @property {number} [optionsSuccessStatus=204] Return status code for OPTIONS request (default: `204`)
- */
-export interface RouterCorsConfig {
-    allowOrigin?: string
-    allowMethods?: string
-    allowHeaders?: string
-    maxAge?: number
-    optionsSuccessStatus?: number
-}
+	/**
+	* Router Array
+	*
+	* @protected
+	* @type {Route[]}
+	*/
+	protected routes: Route<Env, CtxExt, ReqExt>[] = []
 
-/**
- * Router
- *
- * @public
- * @class
- */
-export class Router<TEnv = any> {
+	/**
+	* Global Handlers
+	*
+	* @protected
+	* @type {RouterHandler[]}
+	*/
+	protected globalHandlers: RouterHandler<Env, CtxExt, ReqExt>[] = []
 
-    /**
-     * Router Array
-     *
-     * @protected
-     * @type {Route[]}
-     */
-    protected routes: Route<TEnv>[] = []
+	/**
+	* Debug Mode
+	*
+	* @protected
+	* @type {boolean}
+	*/
+	protected debugMode: boolean = false
 
-    /**
-     * Global Handlers
-     *
-     * @protected
-     * @type {RouterHandler[]}
-     */
-    protected globalHandlers: RouterHandler<TEnv>[] = []
+	/**
+	* CORS Config
+	*
+	* @protected
+	* @type {RouterCorsConfig}
+	*/
+	protected corsConfig: RouterCorsConfig = {}
 
-    /**
-     * Debug Mode
-     *
-     * @protected
-     * @type {boolean}
-     */
-    protected debugMode: boolean = false
+	/**
+	* CORS enabled
+	*
+	* @protected
+	* @type {boolean}
+	*/
+	protected corsEnabled: boolean = false
 
-    /**
-     * CORS Config
-     *
-     * @protected
-     * @type {RouterCorsConfig}
-     */
-    protected corsConfig: RouterCorsConfig = {}
+	/**
+	* Register global handlers
+	*
+	* @param {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public use(...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		for (let handler of handlers) {
+			this.globalHandlers.push(handler)
+		}
+		return this
+	}
 
-    /**
-     * CORS enabled
-     *-
-     * @protected
-     * @type {boolean}
-     */
-    protected corsEnabled: boolean = false
+	/**
+	* Register DELETE route
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public delete(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('DELETE', url, handlers)
+	}
 
-    /**
-     * Register global handlers
-     *
-     * @param {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public use(...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        for (let handler of handlers) {
-            this.globalHandlers.push(handler)
-        }
-        return this
-    }
+	/**
+	* Register GET route
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public get(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('GET', url, handlers)
+	}
 
-    /**
-     * Register CONNECT route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public connect(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('CONNECT', url, handlers)
-    }
+	/**
+	* Register HEAD route
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public head(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('HEAD', url, handlers)
+	}
 
-    /**
-     * Register DELETE route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public delete(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('DELETE', url, handlers)
-    }
+	/**
+	* Register OPTIONS route
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public options(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('OPTIONS', url, handlers)
+	}
 
-    /**
-     * Register GET route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public get(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('GET', url, handlers)
-    }
+	/**
+	* Register PATCH route
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public patch(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('PATCH', url, handlers)
+	}
 
-    /**
-     * Register HEAD route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public head(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('HEAD', url, handlers)
-    }
+	/**
+	* Register POST route
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public post(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('POST', url, handlers)
+	}
 
-    /**
-     * Register OPTIONS route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public options(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('OPTIONS', url, handlers)
-    }
+	/**
+	* Register PUT route
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public put(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('PUT', url, handlers)
+	}
 
-    /**
-     * Register PATCH route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public patch(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('PATCH', url, handlers)
-    }
+	/**
+	* Register route, ignoring method
+	*
+	* @param {string} url
+	* @param  {RouterHandler[]} handlers
+	* @returns {Router}
+	*/
+	public any(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		return this.register('*', url, handlers)
+	}
 
-    /**
-     * Register POST route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public post(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('POST', url, handlers)
-    }
+	/**
+	* Debug Mode
+	*
+	* @param {boolean} [state=true] Whether to turn on or off debug mode (default: true)
+	* @returns {Router}
+	*/
+	public debug(state: boolean = true): Router<Env, CtxExt, ReqExt> {
+		this.debugMode = state
+		return this
+	}
 
-    /**
-     * Register PUT route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public put(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('PUT', url, handlers)
-    }
+	/**
+	* Enable CORS support
+	*
+	* @param {RouterCorsConfig} [config]
+	* @returns {Router}
+	*/
+	public cors(config?: RouterCorsConfig): Router<Env, CtxExt, ReqExt> {
+		this.corsEnabled = true
+		this.corsConfig = {
+			allowOrigin: config?.allowOrigin ?? '*',
+			allowMethods: config?.allowMethods ?? '*',
+			allowHeaders: config?.allowHeaders ?? '*',
+			allowCredentials: config?.allowCredentials ?? undefined,
+			vary: config?.vary ?? undefined,
+			maxAge: config?.maxAge ?? 86400,
+			optionsSuccessStatus: config?.optionsSuccessStatus ?? 204
+		}
+		return this
+	}
 
-    /**
-     * Register TRACE route
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public trace(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('TRACE', url, handlers)
-    }
+	private setCorsHeaders(headers: Headers = new Headers()): Headers {
+		if (this.corsConfig.allowOrigin && !headers.has('Access-Control-Allow-Origin'))
+			headers.set('Access-Control-Allow-Origin', this.corsConfig.allowOrigin)
+		if (this.corsConfig.allowMethods && !headers.has('Access-Control-Allow-Methods'))
+			headers.set('Access-Control-Allow-Methods', this.corsConfig.allowMethods)
+		if (this.corsConfig.allowHeaders && !headers.has('Access-Control-Allow-Headers'))
+			headers.set('Access-Control-Allow-Headers', this.corsConfig.allowHeaders)
+		if (this.corsConfig.allowCredentials && !headers.has('Access-Control-Allow-Credentials'))
+			headers.set('Access-Control-Allow-Credentials', this.corsConfig.allowCredentials.toString())
+		if (this.corsConfig.vary && !headers.has('vary'))
+			headers.set('vary', this.corsConfig.vary.toString())
+		if (this.corsConfig.maxAge && !headers.has('Access-Control-Max-Age'))
+			headers.set('Access-Control-Max-Age', this.corsConfig.maxAge.toString())
+		return headers
+	}
 
-    /**
-     * Register route, ignoring method
-     *
-     * @param {string} url
-     * @param  {RouterHandler[]} handlers
-     * @returns {Router}
-     */
-    public any(url: string, ...handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        return this.register('*', url, handlers)
-    }
+	/**
+	* Register route
+	*
+	* @private
+	* @param {string} method HTTP request method
+	* @param {string} url URL String
+	* @param {RouterHandler[]} handlers Arrar of handler functions
+	* @returns {Router}
+	*/
+	private register(method: string, url: string, handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
+		this.routes.push({
+			method,
+			url,
+			handlers
+		})
 
-    /**
-     * Debug Mode
-     *
-     * @param {boolean} [state=true] Whether to turn on or off debug mode (default: true)
-     * @returns {Router}
-     */
-    public debug(state: boolean = true): Router<TEnv> {
-        this.debugMode = state
-        return this
-    }
+		return this
+	}
 
-    /**
-     * Enable CORS support
-     *
-     * @param {RouterCorsConfig} [config]
-     * @returns {Router}
-     */
-    public cors(config?: RouterCorsConfig): Router<TEnv> {
-        this.corsEnabled = true
-        this.corsConfig = {
-            allowOrigin: config?.allowOrigin || '*',
-            allowMethods: config?.allowMethods || '*',
-            allowHeaders: config?.allowHeaders || '*',
-            maxAge: config?.maxAge || 86400,
-            optionsSuccessStatus: config?.optionsSuccessStatus || 204
-        }
-        return this
-    }
+	/**
+	* Get Route by request
+	*
+	* @private
+	* @param {RouterRequest} request
+	* @returns {Route | undefined}
+	*/
+	private getRoute(request: RouterRequest<ReqExt>): Route<Env, CtxExt, ReqExt> | undefined {
+		const url = new URL(request.url)
+		const pathArr = url.pathname.split('/').filter(i => i)
 
-    /**
-     * Register route
-     *
-     * @private
-     * @param {string} method HTTP request method
-     * @param {string} url URL String
-     * @param {RouterHandler[]} handlers Arrar of handler functions
-     * @returns {Router}
-     */
-    private register(method: string, url: string, handlers: RouterHandler<TEnv>[]): Router<TEnv> {
-        this.routes.push({
-            method,
-            url,
-            handlers
-        })
+		return this.routes.find(r => {
+			const routeArr = r.url.split('/').filter(i => i)
 
-        return this
-    }
+			if (![request.method, '*'].includes(r.method) || routeArr.length !== pathArr.length)
+				return false
 
-    /**
-     * Get Route by request
-     *
-     * @private
-     * @param {RouterRequest} request
-     * @returns {Route | undefined}
-     */
-    private getRoute(request: RouterRequest): Route<TEnv> | undefined {
-        const url = new URL(request.url)
-        const pathArr = url.pathname.split('/').filter(i => i)
+			const params: RouterRequestParams = {}
 
-        return this.routes.find(r => {
-            const routeArr = r.url.split('/').filter(i => i)
+			for (let i = 0; i < routeArr.length; i++) {
+				if (routeArr[i] !== pathArr[i] && routeArr[i][0] !== ':')
+					return false
 
-            if (![request.method, '*'].includes(r.method) || routeArr.length !== pathArr.length)
-                return false
+				if (routeArr[i][0] === ':')
+					params[routeArr[i].substring(1)] = pathArr[i]
+			}
 
-            const params: RouterRequestParams = {}
+			request.params = params
 
-            for (let i = 0; i < routeArr.length; i++) {
-                if (routeArr[i] !== pathArr[i] && routeArr[i][0] !== ':')
-                    return false
+			const query: any = {}
 
-                if (routeArr[i][0] === ':')
-                    params[routeArr[i].substring(1)] = pathArr[i]
-            }
+			for (const [k, v] of url.searchParams.entries()) {
+				query[k] = v
+			}
 
-            request.params = params
+			request.query = query
 
-            const query: any = {}
+			return true
+		}) || this.routes.find(r => r.url === '*' && [request.method, '*'].includes(r.method))
+	}
 
-            for (const [k, v] of url.searchParams.entries()) {
-                query[k] = v
-            }
+	/**
+	* Handle requests
+	*
+	* @param {Request} request
+	* @param {Env} env
+	* @param {CtxExt} [ctxExt]
+	* @param {ReqExt} [reqExt]
+	* @returns {Promise<Response>}
+	*/
+	public async handle(request: Request, env: Env, ctx?: ExecutionContext, ctxExt?: CtxExt, reqExt?: ReqExt): Promise<Response> {
+		const buffer: RouterBuffer = {}
+		const req = {
+			...(reqExt ?? {}),
+			method: request.method,
+			headers: request.headers,
+			url: request.url,
+			cf: request.cf,
+			raw: request,
+			params: {},
+			query: {},
+			arrayBuffer: async (): Promise<ArrayBuffer> => buffer.arrayBuffer ? buffer.arrayBuffer : buffer.arrayBuffer = await request.clone().arrayBuffer(),
+			text: async (): Promise<string> => buffer.text ? buffer.text : buffer.text = await request.clone().text(),
+			json: async <T>(): Promise<T> => buffer.json ? buffer.json : buffer.json = await request.clone().json<T>(),
+			formData: async (): Promise<FormData> => buffer.formData ? buffer.formData : buffer.formData = await request.clone().formData(),
+			blob: async (): Promise<Blob> => buffer.blob ? buffer.blob : buffer.blob = await request.clone().blob(),
+			bearer: () => request.headers.get('Authorization')?.replace(/^[Bb]earer\s/, '').trim(),
+			basic: () => (atob(request.headers.get('Authorization')?.replace(/^[Bb]asic\s/, '').trim() ?? '') || undefined)?.split(':')
+		} as RouterRequest<ReqExt>
 
-            request.query = query
+		if (this.corsEnabled && req.method === 'OPTIONS') {
+			return new Response(null, {
+				headers: this.setCorsHeaders(),
+				status: this.corsConfig.optionsSuccessStatus
+			})
+		}
 
-            return true
-        }) || this.routes.find(r => r.url === '*' && [request.method, '*'].includes(r.method))
-    }
+		const route = this.getRoute(req)
+		let response: Response | undefined
 
-    /**
-     * Handle requests
-     *
-     * @param {TEnv} env
-     * @param {Request} request
-     * @param {any} [extend]
-     * @returns {Promise<Response>}
-     */
-    public async handle(env: TEnv, request: Request, extend: any = {}): Promise<Response> {
-        try {
-            const req: RouterRequest = {
-                ...extend,
-                method: request.method,
-                headers: request.headers,
-                url: request.url,
-                cf: request.cf,
-                params: {},
-                query: {},
-                body: ''
-            }
+		if (!route)
+			response = new Response(this.debugMode ? 'Route not found!' : null, { status: 404 })
 
-            const headers = new Headers()
-            const route = this.getRoute(req)
+		if (!response) {
+			const handlers = [
+				...this.globalHandlers,
+				...(route?.handlers ?? [])
+			]
 
-            if (this.corsEnabled) {
-                if (this.corsConfig.allowOrigin)
-                    headers.set('Access-Control-Allow-Origin', this.corsConfig.allowOrigin)
-                if (this.corsConfig.allowMethods)
-                    headers.set('Access-Control-Allow-Methods', this.corsConfig.allowMethods)
-                if (this.corsConfig.allowHeaders)
-                    headers.set('Access-Control-Allow-Headers', this.corsConfig.allowHeaders)
-                if (this.corsConfig.maxAge)
-                    headers.set('Access-Control-Max-Age', this.corsConfig.maxAge.toString())
+			for (const handler of handlers) {
+				const context = {
+					...(ctxExt ?? {}),
+					env,
+					req,
+					dbg: this.debugMode,
+					ctx
+				} as RouterContext<Env, CtxExt, ReqExt>
 
-                if (!route && req.method === 'OPTIONS') {
-                    return new Response(null, {
-                        headers,
-                        status: this.corsConfig.optionsSuccessStatus
-                    })
-                }
-            }
+				const res = await handler(context)
 
-            if (!route)
-                return new Response(this.debugMode ? 'Route not found!' : null, { status: 404 })
+				if (res) {
+					response = res
+					break
+				}
+			}
+		}
 
-            if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
-                if (req.headers.has('Content-Type') && req.headers.get('Content-Type')!.includes('json')) {
-                    try {
-                        req.body = await request.json()
-                    } catch {
-                        req.body = {}
-                    }
-                } else {
-                    try {
-                        req.body = await request.text()
-                    } catch {
-                        req.body = ''
-                    }
-                }
-            }
+		if (!response)
+			response = new Response(this.debugMode ? 'Handler did not return a Response!' : null, { status: 404 })
 
-            const res: RouterResponse = { headers }
-            const handlers = [...this.globalHandlers, ...route.handlers]
-            let prevIndex = -1
+		if (this.corsEnabled) {
+			response = new Response(response.body, response)
+			this.setCorsHeaders(response.headers)
+		}
 
-            const runner = async (index: number) => {
-                if (index === prevIndex)
-                    throw new Error('next() called multiple times')
-
-                prevIndex = index
-
-                if (typeof handlers[index] === 'function')
-                    await handlers[index]({ env, req, res, next: async () => await runner(index + 1) })
-            }
-
-            await runner(0)
-
-            if (typeof res.body === 'object') {
-                if (!res.headers.has('Content-Type'))
-                    res.headers.set('Content-Type', 'application/json')
-
-                res.body = JSON.stringify(res.body)
-            }
-
-            if (res.raw)
-                return res.raw
-
-            return new Response([101, 204, 205, 304].includes(res.status || (res.body ? 200 : 204)) ? null : res.body, { status: res.status, headers: res.headers, webSocket: res.webSocket || null })
-        } catch(err) {
-            console.error(err)
-            return new Response(this.debugMode && err instanceof Error ? err.stack : '', { status: 500 })
-        }
-    }
-}
+		return response
+	}
+}

tests/index.spec.ts

@@ -0,0 +1,381 @@
+import { describe, expect, test } from 'vitest'
+import { Router } from '../src/index'
+
+describe('Router', () => {
+	test('use', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.use(() => testResponse)).toBeInstanceOf(Router)
+
+		router.get('/', () => new Response('failed'))
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('delete', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'DELETE' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.delete('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('get', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'GET' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.get('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('head', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'HEAD' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.head('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('options', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'OPTIONS' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.options('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('patch', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'PATCH' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.patch('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('post', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'POST' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.post('/test', () => testResponse)).toBeInstanceOf(Router)
+		expect(router.post('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('put', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'PUT' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.put('/test', () => testResponse)).toBeInstanceOf(Router)
+		expect(router.put('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('any', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'POST' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.any('/test', () => testResponse)).toBeInstanceOf(Router)
+		expect(router.any('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('cors', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'GET' })
+		const testOptionsRequest = new Request('https://example.com/', { method: 'OPTIONS' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.cors()).toBeInstanceOf(Router)
+
+		router.get('/', () => testResponse)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*')
+		expect(response.headers.get('Access-Control-Allow-Methods')).toBe('*')
+		expect(response.headers.get('Access-Control-Allow-Headers')).toBe('*')
+		expect(response.headers.get('Access-Control-Allow-Credentials')).toBe(null)
+		expect(response.headers.get('vary')).toBe(null)
+		expect(response.headers.get('Access-Control-Max-Age')).toBe('86400')
+
+		const optionsRes = await router.handle(testOptionsRequest, {})
+
+		expect(optionsRes.status).toBe(204)
+		expect(optionsRes.headers.get('Access-Control-Allow-Origin')).toBe('*')
+		expect(optionsRes.headers.get('Access-Control-Allow-Methods')).toBe('*')
+		expect(optionsRes.headers.get('Access-Control-Allow-Headers')).toBe('*')
+		expect(optionsRes.headers.get('Access-Control-Allow-Credentials')).toBe(null)
+		expect(optionsRes.headers.get('vary')).toBe(null)
+		expect(optionsRes.headers.get('Access-Control-Max-Age')).toBe('86400')
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('params', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/bar/foo')
+
+		router.get('/:foo/:bar', ({ req }) => {
+			return Response.json(req.params)
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.json()).toMatchObject({ foo: 'bar', bar: 'foo' })
+	})
+
+	test('query', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/?foo=bar&bar=foo')
+
+		router.get('/', ({ req }) => {
+			return Response.json(req.query)
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.json()).toMatchObject({ foo: 'bar', bar: 'foo' })
+	})
+
+	test('404', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(404)
+	})
+
+	test('debug mode', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+
+		router.debug()
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(404)
+
+		expect(await response.text()).toBe('Route not found!')
+	})
+
+	test('handler no response', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+
+		router.debug()
+
+		router.get('/', () => {})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(404)
+
+		expect(await response.text()).toBe('Handler did not return a Response!')
+	})
+
+	test('wildcard', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/foo/bar')
+		const testResponse = new Response('success', { status: 200 })
+
+		router.get('*', () => testResponse)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('bearer', async () => {
+		const router = new Router()
+		const testToken = 'super-secret-token'
+		const testRequest = new Request('https://example.com/', { headers: { 'Authorization': `Bearer ${testToken}` }})
+
+		router.get('/', ({ req }) => new Response(req.bearer()))
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.text()).toBe(testToken)
+	})
+
+	test('basic', async () => {
+		const router = new Router()
+		const testCredentials = ['user', 'password']
+		const testBasicAuth = btoa(testCredentials.join(':'))
+		const testRequest = new Request('https://example.com/', { headers: { 'Authorization': `Basic ${testBasicAuth}` }})
+
+		router.get('/', ({ req }) => Response.json(req.basic()))
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.json()).toMatchObject(testCredentials)
+	})
+})
+
+describe('Middleware', () => {
+	const router = new Router()
+	const testHandlerSuccess = () => new Response('success', { status: 200 })
+	const testHandlerContinue = () => {}
+	const testHandlerFailed = () => new Response('failed', { status: 403 })
+
+	router.get('/success', testHandlerContinue, testHandlerSuccess)
+	router.get('/failed', testHandlerFailed, testHandlerSuccess)
+
+	test('continue', async () => {
+		const testRequest = new Request('https://example.com/success')
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('block', async () => {
+		const testRequest = new Request('https://example.com/failed')
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(403)
+
+		expect(await response.text()).toBe('failed')
+	})
+})
+
+describe('Body', () => {
+
+	test('text then text', async () => {
+		const router = new Router()
+		const testText = "lorem ipsum dolor sit amet"
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testText })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				text: await req.text(),
+				text2: await req.text()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ text: testText, text2: testText })
+	})
+
+	test('json then json', async () => {
+		const router = new Router()
+		const testObject = { text: 'cloudflare-worker-router', binary: true, amount: 17 }
+		const testJson = JSON.stringify(testObject)
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testJson })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				json: await req.json(),
+				json2: await req.json()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ json: testObject, json2: testObject })
+	})
+
+	test('text then json', async () => {
+		const router = new Router()
+		const testObject = { text: 'cloudflare-worker-router', binary: true, amount: 17 }
+		const testJson = JSON.stringify(testObject)
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testJson })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				text: await req.text(),
+				json: await req.json()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ text: testJson, json: testObject })
+	})
+
+	test('json then text', async () => {
+		const router = new Router()
+		const testObject = { text: 'cloudflare-worker-router', binary: true, amount: 17 }
+		const testJson = JSON.stringify(testObject)
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testJson })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				json: await req.json(),
+				text: await req.text()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ text: testJson, json: testObject })
+	})
+})

tsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "outDir": ".",
-        "module": "commonjs",
+        "module": "esnext",
         "target": "esnext",
         "lib": ["esnext"],
         "declaration": true,
@@ -15,7 +15,6 @@
         "alwaysStrict": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
-        "noImplicitReturns": true,
         "noFallthroughCasesInSwitch": true,
         "esModuleInterop": true,
         "preserveConstEnums": true,

vite.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+	test: {
+		environment: 'edge-runtime',
+		reporters: ['verbose'],
+		watch: false
+	}
+})