routup 1.0.2 → 2.0.0

package/dist/index.cjs

@@ -1,19 +1,233 @@
 'use strict';
 
-var continu = require('continu');
-var process = require('node:process');
-var zod = require('zod');
-var crypto = require('node:crypto');
-var node_fs = require('node:fs');
+var buffer = require('buffer');
+var uncrypto = require('uncrypto');
 var smob = require('smob');
 var proxyAddr = require('proxy-addr');
 var mimeExplorer = require('mime-explorer');
-var http = require('@ebec/http');
 var Negotiator = require('negotiator');
-var node_url = require('node:url');
-var path = require('node:path');
+var readableStream = require('readable-stream');
 var pathToRegexp = require('path-to-regexp');
-var node_http = require('node:http');
+
+exports.MethodName = void 0;
+(function(MethodName) {
+    MethodName["GET"] = 'get';
+    MethodName["POST"] = 'post';
+    MethodName["PUT"] = 'put';
+    MethodName["PATCH"] = 'patch';
+    MethodName["DELETE"] = 'delete';
+    MethodName["OPTIONS"] = 'options';
+    MethodName["HEAD"] = 'head';
+})(exports.MethodName || (exports.MethodName = {}));
+exports.HeaderName = void 0;
+(function(HeaderName) {
+    HeaderName["ACCEPT"] = 'accept';
+    HeaderName["ACCEPT_CHARSET"] = 'accept-charset';
+    HeaderName["ACCEPT_ENCODING"] = 'accept-encoding';
+    HeaderName["ACCEPT_LANGUAGE"] = 'accept-language';
+    HeaderName["ACCEPT_RANGES"] = 'accept-ranges';
+    HeaderName["ALLOW"] = 'allow';
+    HeaderName["CACHE_CONTROL"] = 'cache-control';
+    HeaderName["CONTENT_DISPOSITION"] = 'content-disposition';
+    HeaderName["CONTENT_ENCODING"] = 'content-encoding';
+    HeaderName["CONTENT_LENGTH"] = 'content-length';
+    HeaderName["CONTENT_RANGE"] = 'content-range';
+    HeaderName["CONTENT_TYPE"] = 'content-type';
+    HeaderName["COOKIE"] = 'cookie';
+    HeaderName["ETag"] = 'etag';
+    HeaderName["HOST"] = 'host';
+    HeaderName["IF_MODIFIED_SINCE"] = 'if-modified-since';
+    HeaderName["IF_NONE_MATCH"] = 'if-none-match';
+    HeaderName["LAST_MODIFIED"] = 'last-modified';
+    HeaderName["LOCATION"] = 'location';
+    HeaderName["RANGE"] = 'range';
+    HeaderName["RATE_LIMIT_LIMIT"] = 'ratelimit-limit';
+    HeaderName["RATE_LIMIT_REMAINING"] = 'ratelimit-remaining';
+    HeaderName["RATE_LIMIT_RESET"] = 'ratelimit-reset';
+    HeaderName["RETRY_AFTER"] = 'retry-after';
+    HeaderName["SET_COOKIE"] = 'set-cookie';
+    HeaderName["TRANSFER_ENCODING"] = 'transfer-encoding';
+    HeaderName["X_FORWARDED_HOST"] = 'x-forwarded-host';
+    HeaderName["X_FORWARDED_FOR"] = 'x-forwarded-for';
+    HeaderName["X_FORWARDED_PROTO"] = 'x-forwarded-proto';
+})(exports.HeaderName || (exports.HeaderName = {}));
+
+function setResponseCacheHeaders(res, options) {
+    options = options || {};
+    const cacheControls = [
+        'public'
+    ].concat(options.cacheControls || []);
+    if (options.maxAge !== undefined) {
+        cacheControls.push(`max-age=${+options.maxAge}`, `s-maxage=${+options.maxAge}`);
+    }
+    if (options.modifiedTime) {
+        const modifiedTime = typeof options.modifiedTime === 'string' ? new Date(options.modifiedTime) : options.modifiedTime;
+        res.setHeader('last-modified', modifiedTime.toUTCString());
+    }
+    res.setHeader('cache-control', cacheControls.join(', '));
+}
+
+const GoneSymbol = Symbol.for('ResGone');
+function isResponseGone(res) {
+    if (res.headersSent || res.writableEnded) {
+        return true;
+    }
+    if (GoneSymbol in res) {
+        return res[GoneSymbol];
+    }
+    return false;
+}
+
+function appendResponseHeader(res, name, value) {
+    let header = res.getHeader(name);
+    if (!header) {
+        res.setHeader(name, value);
+        return;
+    }
+    if (!Array.isArray(header)) {
+        header = [
+            header.toString()
+        ];
+    }
+    res.setHeader(name, [
+        ...header,
+        value
+    ]);
+}
+function appendResponseHeaderDirective(res, name, value) {
+    let header = res.getHeader(name);
+    if (!header) {
+        if (Array.isArray(value)) {
+            res.setHeader(name, value.join('; '));
+            return;
+        }
+        res.setHeader(name, value);
+        return;
+    }
+    if (!Array.isArray(header)) {
+        if (typeof header === 'string') {
+            // split header by directive(s)
+            header = header.split('; ');
+        }
+        if (typeof header === 'number') {
+            header = [
+                header.toString()
+            ];
+        }
+    }
+    if (Array.isArray(value)) {
+        header.push(...value);
+    } else {
+        header.push(`${value}`);
+    }
+    header = [
+        ...new Set(header)
+    ];
+    res.setHeader(name, header.join('; '));
+}
+
+/*
+  Set-Cookie header field-values are sometimes comma joined in one string. This splits them without choking on commas
+  that are within a single set-cookie field-value, such as in the Expires portion.
+
+  This is uncommon, but explicitly allowed - see https://tools.ietf.org/html/rfc2616#section-4.2
+  Node.js does this for every header *except* set-cookie - see https://github.com/nodejs/node/blob/d5e363b77ebaf1caf67cd7528224b651c86815c1/lib/_http_incoming.js#L128
+  React Native's fetch does this for *every* header, including set-cookie.
+
+  Based on: https://github.com/google/j2objc/commit/16820fdbc8f76ca0c33472810ce0cb03d20efe25
+  Credits to: https://github.com/tomball for original and https://github.com/chrusart for JavaScript implementation
+*/ function splitCookiesString(input) {
+    if (Array.isArray(input)) {
+        return input.flatMap((el)=>splitCookiesString(el));
+    }
+    if (typeof input !== 'string') {
+        return [];
+    }
+    const cookiesStrings = [];
+    let pos = 0;
+    let start;
+    let ch;
+    let lastComma;
+    let nextStart;
+    let cookiesSeparatorFound;
+    const skipWhitespace = ()=>{
+        while(pos < input.length && /\s/.test(input.charAt(pos))){
+            pos += 1;
+        }
+        return pos < input.length;
+    };
+    const notSpecialChar = ()=>{
+        ch = input.charAt(pos);
+        return ch !== '=' && ch !== ';' && ch !== ',';
+    };
+    while(pos < input.length){
+        start = pos;
+        cookiesSeparatorFound = false;
+        while(skipWhitespace()){
+            ch = input.charAt(pos);
+            if (ch === ',') {
+                // ',' is a cookie separator if we have later first '=', not ';' or ','
+                lastComma = pos;
+                pos += 1;
+                skipWhitespace();
+                nextStart = pos;
+                while(pos < input.length && notSpecialChar()){
+                    pos += 1;
+                }
+                // currently special character
+                if (pos < input.length && input.charAt(pos) === '=') {
+                    // we found cookies separator
+                    cookiesSeparatorFound = true;
+                    // pos is inside the next cookie, so back up and return it.
+                    pos = nextStart;
+                    cookiesStrings.push(input.substring(start, lastComma));
+                    start = pos;
+                } else {
+                    // in param ',' or param separator ';',
+                    // we continue from that comma
+                    pos = lastComma + 1;
+                }
+            } else {
+                pos += 1;
+            }
+        }
+        if (!cookiesSeparatorFound || pos >= input.length) {
+            cookiesStrings.push(input.substring(start, input.length));
+        }
+    }
+    return cookiesStrings;
+}
+
+function transformHeaderToTuples(key, value) {
+    const output = [];
+    if (Array.isArray(value)) {
+        for(let j = 0; j < value.length; j++){
+            output.push([
+                key,
+                value[j]
+            ]);
+        }
+    } else if (value !== undefined) {
+        output.push([
+            key,
+            String(value)
+        ]);
+    }
+    return output;
+}
+function transformHeadersToTuples(input) {
+    const output = [];
+    const keys = Object.keys(input);
+    for(let i = 0; i < keys.length; i++){
+        const key = keys[i].toLowerCase();
+        output.push(...transformHeaderToTuples(key, input[key]));
+    }
+    return output;
+}
+
+function isObject(item) {
+    return !!item && typeof item === 'object' && !Array.isArray(item);
+}
 
 /**
  * Determine if object is a Stats object.
@@ -22,15 +236,17 @@ var node_http = require('node:http');
  * @return {boolean}
  * @api private
  */ function isStatsObject(obj) {
-    /* istanbul ignore next */ if (typeof node_fs.Stats === 'function' && obj instanceof node_fs.Stats) {
-        return true;
-    }
     // quack quack
-    return !!obj && typeof obj === 'object' && 'ctime' in obj && Object.prototype.toString.call(obj.ctime) === '[object Date]' && 'mtime' in obj && Object.prototype.toString.call(obj.mtime) === '[object Date]' && 'ino' in obj && typeof obj.ino === 'number' && 'size' in obj && typeof obj.size === 'number';
+    return isObject(obj) && 'ctime' in obj && Object.prototype.toString.call(obj.ctime) === '[object Date]' && 'mtime' in obj && Object.prototype.toString.call(obj.mtime) === '[object Date]' && 'ino' in obj && typeof obj.ino === 'number' && 'size' in obj && typeof obj.size === 'number';
+}
+async function sha1(str) {
+    const enc = new TextEncoder();
+    const hash = await uncrypto.subtle.digest('SHA-1', enc.encode(str));
+    return btoa(String.fromCharCode(...new Uint8Array(hash)));
 }
 /**
  * Generate an ETag.
- */ function generateETag(input) {
+ */ async function generateETag(input) {
     if (isStatsObject(input)) {
         const mtime = input.mtime.getTime().toString(16);
         const size = input.size.toString(16);
@@ -40,32 +256,28 @@ var node_http = require('node:http');
         // fast-path empty
         return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
     }
-    const entity = Buffer.isBuffer(input) ? input.toString('utf-8') : input;
+    const entity = buffer.Buffer.isBuffer(input) ? input.toString('utf-8') : input;
     // compute hash of entity
-    const hash = crypto.createHash('sha1').update(entity, 'utf8').digest('base64').substring(0, 27);
-    return `"${entity.length.toString(16)}-${hash}"`;
+    const hash = await sha1(entity);
+    return `"${entity.length.toString(16)}-${hash.substring(0, 27)}"`;
 }
 /**
  * Create a simple ETag.
- */ function createEtag(input, options) {
+ */ async function createEtag(input, options) {
     options = options || {};
     const weak = typeof options.weak === 'boolean' ? options.weak : isStatsObject(input);
     // generate entity tag
-    const tag = generateETag(input);
+    const tag = await generateETag(input);
     return weak ? `W/${tag}` : tag;
 }
 
-function isObject(item) {
-    return !!item && typeof item === 'object' && !Array.isArray(item);
-}
-
 function buildEtagFn(input) {
     if (typeof input === 'function') {
         return input;
     }
     input = input ?? true;
     if (input === false) {
-        return ()=>undefined;
+        return ()=>Promise.resolve(undefined);
     }
     let options = {
         weak: true
@@ -73,10 +285,10 @@ function buildEtagFn(input) {
     if (isObject(input)) {
         options = smob.merge(input, options);
     }
-    return (body, encoding, size)=>{
-        const buff = Buffer.isBuffer(body) ? body : Buffer.from(body, encoding);
+    return async (body, encoding, size)=>{
+        const buff = buffer.Buffer.isBuffer(body) ? body : buffer.Buffer.from(body, encoding);
         if (typeof options.threshold !== 'undefined') {
-            size = size ?? Buffer.byteLength(buff);
+            size = size ?? buffer.Buffer.byteLength(buff);
             if (size <= options.threshold) {
                 return undefined;
             }
@@ -102,7 +314,7 @@ function buildTrustProxyFn(input) {
 }
 
 function isInstance(input, name) {
-    return typeof input === 'object' && input !== null && input['@instanceof'] === Symbol.for(name);
+    return isObject(input) && input['@instanceof'] === Symbol.for(name);
 }
 
 function getMimeType(type) {
@@ -122,8 +334,25 @@ function getCharsetForMimeType(type) {
     return undefined;
 }
 
-function isPath(input) {
-    return typeof input === 'string' || input instanceof RegExp;
+/**
+ * Based on https://github.com/unjs/pathe v1.1.1 (055f50a6f1131f4e5c56cf259dd8816168fba329)
+ */ function normalizeWindowsPath(input = '') {
+    if (!input || !input.includes('\\')) {
+        return input;
+    }
+    return input.replace(/\\/g, '/');
+}
+const EXTNAME_RE = /.(\.[^./]+)$/;
+function extname(input) {
+    const match = EXTNAME_RE.exec(normalizeWindowsPath(input));
+    return match && match[1] || '';
+}
+function basename(input, extension) {
+    const lastSegment = normalizeWindowsPath(input).split('/').pop();
+    if (!lastSegment) {
+        return input;
+    }
+    return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 }
 
 function isPromise(p) {
@@ -132,24 +361,14 @@ function isPromise(p) {
     typeof p.then === 'function');
 }
 
-/* istanbul ignore next */ function createRequestTimeout(res, timeout, done) {
-    const instance = setTimeout(()=>{
-        res.statusCode = http.GatewayTimeoutErrorOptions.statusCode;
-        res.statusMessage = http.GatewayTimeoutErrorOptions.message;
-        res.end();
-    }, timeout);
-    res.once('close', ()=>{
-        clearTimeout(instance);
-        /* istanbul ignore next */ if (typeof done === 'function') {
-            done();
-        }
-    });
-    /* istanbul ignore next */ res.once('error', (e)=>{
-        clearTimeout(instance);
-        if (typeof done === 'function') {
-            done(e);
-        }
-    });
+function isNodeStream(input) {
+    return isObject(input) && typeof input.pipe === 'function' && typeof input.read === 'function';
+}
+function isWebStream(input) {
+    return isObject(input) && typeof input.pipeTo === 'function';
+}
+function isStream(data) {
+    return isNodeStream(data) || isWebStream(data);
 }
 
 const TRAILING_SLASH_RE = /\/$|\/\?/;
@@ -169,22 +388,9 @@ function withoutTrailingSlash(input = '', queryParams = false) {
     const [s0, ...s] = input.split('?');
     return (s0.slice(0, -1) || '/') + (s.length ? `?${s.join('?')}` : '');
 }
-function withTrailingSlash(input = '', queryParams = false) {
-    if (!queryParams) {
-        return input.endsWith('/') ? input : `${input}/`;
-    }
-    if (hasTrailingSlash(input, true)) {
-        return input || '/';
-    }
-    const [s0, ...s] = input.split('?');
-    return `${s0}/${s.length ? `?${s.join('?')}` : ''}`;
-}
 function hasLeadingSlash(input = '') {
     return input.startsWith('/');
 }
-function withoutLeadingSlash(input = '') {
-    return (hasLeadingSlash(input) ? input.substr(1) : input) || '/';
-}
 function withLeadingSlash(input = '') {
     return hasLeadingSlash(input) ? input : `/${input}`;
 }
@@ -192,91 +398,73 @@ function cleanDoubleSlashes(input = '') {
     return input.split('://').map((str)=>str.replace(/\/{2,}/g, '/')).join('://');
 }
 
-let instance;
-function buildConfig() {
-    return new continu.Continu({
-        defaults: {
-            env: process.env.NODE_ENV || 'development',
-            trustProxy: ()=>false,
-            subdomainOffset: 2,
-            etag: buildEtagFn(),
-            proxyIpMax: 0
-        },
-        transformers: {
-            etag: (value)=>buildEtagFn(value),
-            trustProxy: (value)=>buildTrustProxyFn(value)
-        },
-        validators: {
-            env: (value)=>zod.string().safeParse(value),
-            trustProxy: (value)=>zod.any().safeParse(value),
-            subdomainOffset: (value)=>zod.number().nonnegative().safeParse(value),
-            etag: (value)=>zod.any().safeParse(value),
-            proxyIpMax: (value)=>zod.number().nonnegative().safeParse(value)
-        }
-    });
+function isWebBlob(input) {
+    return typeof Blob !== 'undefined' && input instanceof Blob;
 }
-function useConfig() {
-    if (typeof instance !== 'undefined') {
-        return instance;
-    }
-    instance = buildConfig();
-    return instance;
+function isWebResponse(input) {
+    return typeof Response !== 'undefined' && input instanceof Response;
 }
-function setConfig(config) {
-    instance = config;
+
+function setResponseContentTypeByFileName(res, fileName) {
+    const ext = extname(fileName);
+    if (ext) {
+        let type = getMimeType(ext.substring(1));
+        if (type) {
+            const charset = getCharsetForMimeType(type);
+            if (charset) {
+                type += `; charset=${charset}`;
+            }
+            res.setHeader(exports.HeaderName.CONTENT_TYPE, type);
+        }
+    }
 }
-function setConfigOption(key, value) {
-    const config = useConfig();
-    config.setRaw(key, value);
-    return config.get();
+
+function setResponseHeaderAttachment(res, filename) {
+    if (typeof filename === 'string') {
+        setResponseContentTypeByFileName(res, filename);
+    }
+    res.setHeader(exports.HeaderName.CONTENT_DISPOSITION, `attachment${filename ? `; filename="${filename}"` : ''}`);
 }
-function getConfigOption(key) {
-    const config = useConfig();
-    return config.get(key);
+
+function setResponseHeaderContentType(res, input, ifNotExists) {
+    if (ifNotExists) {
+        const header = res.getHeader(exports.HeaderName.CONTENT_TYPE);
+        if (header) {
+            return;
+        }
+    }
+    const contentType = getMimeType(input);
+    if (contentType) {
+        res.setHeader(exports.HeaderName.CONTENT_TYPE, contentType);
+    }
 }
 
-exports.MethodName = void 0;
-(function(MethodName) {
-    MethodName["GET"] = 'get';
-    MethodName["POST"] = 'post';
-    MethodName["PUT"] = 'put';
-    MethodName["PATCH"] = 'patch';
-    MethodName["DELETE"] = 'delete';
-    MethodName["OPTIONS"] = 'options';
-    MethodName["HEAD"] = 'head';
-})(exports.MethodName || (exports.MethodName = {}));
-exports.HeaderName = void 0;
-(function(HeaderName) {
-    HeaderName["ACCEPT"] = 'accept';
-    HeaderName["ACCEPT_CHARSET"] = 'accept-charset';
-    HeaderName["ACCEPT_ENCODING"] = 'accept-encoding';
-    HeaderName["ACCEPT_LANGUAGE"] = 'accept-language';
-    HeaderName["ACCEPT_RANGES"] = 'accept-ranges';
-    HeaderName["ALLOW"] = 'allow';
-    HeaderName["CACHE_CONTROL"] = 'cache-control';
-    HeaderName["CONTENT_DISPOSITION"] = 'content-disposition';
-    HeaderName["CONTENT_ENCODING"] = 'content-encoding';
-    HeaderName["CONTENT_LENGTH"] = 'content-length';
-    HeaderName["CONTENT_RANGE"] = 'content-range';
-    HeaderName["CONTENT_TYPE"] = 'content-type';
-    HeaderName["COOKIE"] = 'cookie';
-    HeaderName["ETag"] = 'etag';
-    HeaderName["HOST"] = 'host';
-    HeaderName["IF_MODIFIED_SINCE"] = 'if-modified-since';
-    HeaderName["IF_NONE_MATCH"] = 'if-none-match';
-    HeaderName["LAST_MODIFIED"] = 'last-modified';
-    HeaderName["LOCATION"] = 'location';
-    HeaderName["RANGE"] = 'range';
-    HeaderName["RATE_LIMIT_LIMIT"] = 'ratelimit-limit';
-    HeaderName["RATE_LIMIT_REMAINING"] = 'ratelimit-remaining';
-    HeaderName["RATE_LIMIT_RESET"] = 'ratelimit-reset';
-    HeaderName["RETRY_AFTER"] = 'retry-after';
-    HeaderName["SET_COOKIE"] = 'set-cookie';
-    HeaderName["TRANSFER_ENCODING"] = 'transfer-encoding';
-    HeaderName["X_FORWARDED_HOST"] = 'x-forwarded-host';
-    HeaderName["X_FORWARDED_FOR"] = 'x-forwarded-for';
-    HeaderName["X_FORWARDED_PROTO"] = 'x-forwarded-proto';
-})(exports.HeaderName || (exports.HeaderName = {}));
+const defaults = {
+    trustProxy: ()=>false,
+    subdomainOffset: 2,
+    etag: buildEtagFn(),
+    proxyIpMax: 0
+};
+const instances = {};
+function setRouterOptions(id, input) {
+    instances[id] = input;
+}
+function findRouterOption(key, id) {
+    if (!id) {
+        return defaults[key];
+    }
+    const ids = Array.isArray(id) ? id : [
+        id
+    ];
+    if (ids.length > 0) {
+        for(let i = ids.length; i >= 0; i--){
+            if (smob.hasOwnProperty(instances, ids[i]) && typeof instances[ids[i]][key] !== 'undefined') {
+                return instances[ids[i]][key];
+            }
+        }
+    }
+    return defaults[key];
+}
 
 const BodySymbol = Symbol.for('ReqBody');
 function useRequestBody(req, key) {
@@ -539,14 +727,24 @@ function matchRequestContentType(req, contentType) {
     return header.split('; ').shift() === getMimeType(contentType);
 }
 
+const routerSymbol = Symbol.for('ReqRouterID');
+function setRequestRouterIds(req, ids) {
+    req[routerSymbol] = ids;
+}
+function useRequestRouterIds(req) {
+    if (routerSymbol in req) {
+        return req[routerSymbol];
+    }
+    return undefined;
+}
+
 function getRequestHostName(req, options) {
     options = options || {};
     let trustProxy;
     if (typeof options.trustProxy !== 'undefined') {
         trustProxy = buildTrustProxyFn(options.trustProxy);
     } else {
-        const config = useConfig();
-        trustProxy = config.get('trustProxy');
+        trustProxy = findRouterOption('trustProxy', useRequestRouterIds(req));
     }
     let hostname = req.headers[exports.HeaderName.X_FORWARDED_HOST];
     if (!hostname || !req.socket.remoteAddress || !trustProxy(req.socket.remoteAddress, 0)) {
@@ -572,10 +770,10 @@ function getRequestIP(req, options) {
     if (typeof options.trustProxy !== 'undefined') {
         trustProxy = buildTrustProxyFn(options.trustProxy);
     } else {
-        const config = useConfig();
-        trustProxy = config.get('trustProxy');
+        trustProxy = findRouterOption('trustProxy', useRequestRouterIds(req));
     }
-    return proxyAddr(req, trustProxy);
+    const addrs = proxyAddr.all(req, trustProxy);
+    return addrs[addrs.length - 1];
 }
 
 const ReqMountPathSymbol = Symbol.for('ReqMountPath');
@@ -622,7 +820,7 @@ function useRequestPath(req) {
     if (typeof req.url === 'undefined') {
         return '/';
     }
-    const parsed = new node_url.URL(req.url, 'http://localhost/');
+    const parsed = new URL(req.url, 'http://localhost/');
     req[PathSymbol] = parsed.pathname;
     return req[PathSymbol];
 }
@@ -633,8 +831,7 @@ function getRequestProtocol(req, options) {
     if (typeof options.trustProxy !== 'undefined') {
         trustProxy = buildTrustProxyFn(options.trustProxy);
     } else {
-        const config = useConfig();
-        trustProxy = config.get('trustProxy');
+        trustProxy = findRouterOption('trustProxy', useRequestRouterIds(req));
     }
     let protocol = options.default;
     /* istanbul ignore next */ if (smob.hasOwnProperty(req.socket, 'encrypted') && !!req.socket.encrypted) {
@@ -702,121 +899,7 @@ function extendRequestQuery(req, key, value) {
     setRequestQuery(req, key, value);
 }
 
-function setResponseCacheHeaders(res, options) {
-    options = options || {};
-    const cacheControls = [
-        'public'
-    ].concat(options.cacheControls || []);
-    if (options.maxAge !== undefined) {
-        cacheControls.push(`max-age=${+options.maxAge}`, `s-maxage=${+options.maxAge}`);
-    }
-    if (options.modifiedTime) {
-        const modifiedTime = typeof options.modifiedTime === 'string' ? new Date(options.modifiedTime) : options.modifiedTime;
-        res.setHeader('last-modified', modifiedTime.toUTCString());
-    }
-    res.setHeader('cache-control', cacheControls.join(', '));
-}
-
-function appendResponseHeader(res, name, value) {
-    let header = res.getHeader(name);
-    if (!header) {
-        res.setHeader(name, value);
-        return;
-    }
-    if (!Array.isArray(header)) {
-        header = [
-            header.toString()
-        ];
-    }
-    res.setHeader(name, [
-        ...header,
-        value
-    ]);
-}
-function appendResponseHeaderDirective(res, name, value) {
-    let header = res.getHeader(name);
-    if (!header) {
-        if (Array.isArray(value)) {
-            res.setHeader(name, value.join('; '));
-            return;
-        }
-        res.setHeader(name, value);
-        return;
-    }
-    if (!Array.isArray(header)) {
-        if (typeof header === 'string') {
-            // split header by directive(s)
-            header = header.split('; ');
-        }
-        if (typeof header === 'number') {
-            header = [
-                header.toString()
-            ];
-        }
-    }
-    if (Array.isArray(value)) {
-        header.push(...value);
-    } else {
-        header.push(`${value}`);
-    }
-    header = [
-        ...new Set(header)
-    ];
-    res.setHeader(name, header.join('; '));
-}
-
-function setResponseContentTypeByFileName(res, fileName) {
-    const ext = path.extname(fileName);
-    if (ext) {
-        let type = getMimeType(ext.substring(1));
-        if (type) {
-            const charset = getCharsetForMimeType(type);
-            if (charset) {
-                type += `; charset=${charset}`;
-            }
-            res.setHeader(exports.HeaderName.CONTENT_TYPE, type);
-        }
-    }
-}
-/* istanbul ignore next */ function onResponseFinished(res, cb) {
-    let called;
-    const callCallback = (err)=>{
-        if (called) return;
-        called = true;
-        cb(err);
-    };
-    res.on('finish', ()=>{
-        callCallback();
-    });
-    res.on('close', ()=>{
-        callCallback();
-    });
-    res.on('error', (err)=>{
-        callCallback(err);
-    });
-}
-
-function setResponseHeaderAttachment(res, filename) {
-    if (typeof filename === 'string') {
-        setResponseContentTypeByFileName(res, filename);
-    }
-    res.setHeader(exports.HeaderName.CONTENT_DISPOSITION, `attachment${filename ? `; filename="${filename}"` : ''}`);
-}
-
-function setResponseHeaderContentType(res, input, ifNotExists) {
-    if (ifNotExists) {
-        const header = res.getHeader(exports.HeaderName.CONTENT_TYPE);
-        if (header) {
-            return;
-        }
-    }
-    const contentType = getMimeType(input);
-    if (contentType) {
-        res.setHeader(exports.HeaderName.CONTENT_TYPE, contentType);
-    }
-}
-
-function send(res, chunk) {
+async function send(res, chunk) {
     switch(typeof chunk){
         case 'string':
             {
@@ -829,7 +912,7 @@ function send(res, chunk) {
             {
                 if (chunk === null) {
                     chunk = '';
-                } else if (Buffer.isBuffer(chunk)) {
+                } else if (buffer.Buffer.isBuffer(chunk)) {
                     setResponseHeaderContentType(res, 'bin', true);
                 } else {
                     chunk = JSON.stringify(chunk);
@@ -847,24 +930,26 @@ function send(res, chunk) {
     // populate Content-Length
     let len;
     if (chunk !== undefined) {
-        if (Buffer.isBuffer(chunk)) {
+        if (buffer.Buffer.isBuffer(chunk)) {
             // get length of Buffer
             len = chunk.length;
         } else if (chunk.length < 1000) {
             // just calculate length when no ETag + small chunk
-            len = Buffer.byteLength(chunk, encoding);
+            len = buffer.Buffer.byteLength(chunk, encoding);
         } else {
             // convert chunk to Buffer and calculate
-            chunk = Buffer.from(chunk, encoding);
+            chunk = buffer.Buffer.from(chunk, encoding);
             encoding = undefined;
             len = chunk.length;
         }
         res.setHeader(exports.HeaderName.CONTENT_LENGTH, `${len}`);
     }
-    const config = useConfig();
-    const etagFn = config.get('etag');
     if (typeof len !== 'undefined') {
-        const chunkHash = etagFn(chunk, encoding, len);
+        const etagFn = findRouterOption('etag', useRequestRouterIds(res.req));
+        const chunkHash = await etagFn(chunk, encoding, len);
+        if (isResponseGone(res)) {
+            return Promise.resolve();
+        }
         if (typeof chunkHash === 'string') {
             res.setHeader(exports.HeaderName.ETag, chunkHash);
             if (res.req.headers[exports.HeaderName.IF_NONE_MATCH] === chunkHash) {
@@ -885,16 +970,20 @@ function send(res, chunk) {
         res.removeHeader(exports.HeaderName.TRANSFER_ENCODING);
         chunk = '';
     }
+    if (isResponseGone(res)) {
+        return Promise.resolve();
+    }
     if (res.req.method === 'HEAD') {
         // skip body for HEAD
         res.end();
-        return;
+        return Promise.resolve();
     }
     if (typeof encoding !== 'undefined') {
         res.end(chunk, encoding);
-        return;
+        return Promise.resolve();
     }
     res.end(chunk);
+    return Promise.resolve();
 }
 
 function sendAccepted(res, chunk) {
@@ -909,87 +998,116 @@ function sendCreated(res, chunk) {
     return send(res, chunk);
 }
 
-function sendStream(res, stream, fn) {
-    stream.on('open', ()=>{
-        stream.pipe(res);
-    });
-    /* istanbul ignore next */ stream.on('error', (err)=>{
-        if (typeof fn === 'function') {
-            fn(err);
-        } else {
-            res.statusCode = 400;
+async function sendStream(res, stream, next) {
+    if (isWebStream(stream)) {
+        return stream.pipeTo(new WritableStream({
+            write (chunk) {
+                res.write(chunk);
+            }
+        })).then(()=>{
+            if (next) {
+                return next();
+            }
             res.end();
-        }
-    });
-    stream.on('close', ()=>{
-        if (typeof fn === 'function') {
-            fn();
-        } else {
+            return Promise.resolve();
+        }).catch((err)=>{
+            if (next) {
+                return next(err);
+            }
+            return Promise.reject(err);
+        });
+    }
+    return new Promise((resolve, reject)=>{
+        stream.on('open', ()=>{
+            stream.pipe(res);
+        });
+        /* istanbul ignore next */ stream.on('error', (err)=>{
+            if (next) {
+                Promise.resolve().then(()=>next(err)).then(()=>resolve()).catch((e)=>reject(e));
+                return;
+            }
             res.end();
-        }
+            reject(err);
+        });
+        stream.on('close', ()=>{
+            if (next) {
+                Promise.resolve().then(()=>next()).then(()=>resolve()).catch((e)=>reject(e));
+                return;
+            }
+            res.end();
+            resolve();
+        });
     });
 }
 
-function resolveStats(options, cb) {
-    if (options.stats) {
-        cb(null, options.stats);
-        return;
-    }
-    node_fs.stat(options.filePath, (err, stats)=>cb(err, stats));
-}
-function sendFile(res, filePath, fn) {
-    let options;
-    if (typeof filePath === 'string') {
-        options = {
-            filePath
-        };
-    } else {
-        options = filePath;
-    }
-    const fileName = path.basename(options.filePath);
-    if (options.attachment) {
-        const dispositionHeader = res.getHeader(exports.HeaderName.CONTENT_DISPOSITION);
-        if (!dispositionHeader) {
-            setResponseHeaderAttachment(res, fileName);
+async function sendFile(res, options, next) {
+    let stats;
+    try {
+        stats = await options.stats();
+    } catch (e) {
+        if (next) {
+            return next(e);
         }
-    } else {
-        setResponseContentTypeByFileName(res, fileName);
-    }
-    resolveStats(options, (err, stats)=>{
-        /* istanbul ignore next */ if (err) {
-            if (typeof fn === 'function') {
-                fn(err);
-            } else {
-                res.statusCode = 404;
-                res.end();
+        if (isResponseGone(res)) {
+            return Promise.resolve();
+        }
+        return Promise.reject(e);
+    }
+    const name = options.name || stats.name;
+    if (name) {
+        const fileName = basename(name);
+        if (options.attachment) {
+            const dispositionHeader = res.getHeader(exports.HeaderName.CONTENT_DISPOSITION);
+            if (!dispositionHeader) {
+                setResponseHeaderAttachment(res, fileName);
             }
-            return;
+        } else {
+            setResponseContentTypeByFileName(res, fileName);
         }
-        const streamOptions = {};
+    }
+    const contentOptions = {};
+    if (stats.size) {
         const rangeHeader = res.req.headers[exports.HeaderName.RANGE];
         if (rangeHeader) {
             const [x, y] = rangeHeader.replace('bytes=', '').split('-');
-            streamOptions.end = Math.min(parseInt(y, 10) || stats.size - 1, stats.size - 1);
-            streamOptions.start = parseInt(x, 10) || 0;
-            if (streamOptions.end >= stats.size) {
-                streamOptions.end = stats.size - 1;
+            contentOptions.end = Math.min(parseInt(y, 10) || stats.size - 1, stats.size - 1);
+            contentOptions.start = parseInt(x, 10) || 0;
+            if (contentOptions.end >= stats.size) {
+                contentOptions.end = stats.size - 1;
             }
-            if (streamOptions.start >= stats.size) {
+            if (contentOptions.start >= stats.size) {
                 res.setHeader(exports.HeaderName.CONTENT_RANGE, `bytes */${stats.size}`);
                 res.statusCode = 416;
                 res.end();
-                return;
+                return Promise.resolve();
             }
-            res.setHeader(exports.HeaderName.CONTENT_RANGE, `bytes ${streamOptions.start}-${streamOptions.end}/${stats.size}`);
-            res.setHeader(exports.HeaderName.CONTENT_LENGTH, streamOptions.end - streamOptions.start + 1);
+            res.setHeader(exports.HeaderName.CONTENT_RANGE, `bytes ${contentOptions.start}-${contentOptions.end}/${stats.size}`);
+            res.setHeader(exports.HeaderName.CONTENT_LENGTH, contentOptions.end - contentOptions.start + 1);
         } else {
             res.setHeader(exports.HeaderName.CONTENT_LENGTH, stats.size);
         }
         res.setHeader(exports.HeaderName.ACCEPT_RANGES, 'bytes');
-        res.setHeader(exports.HeaderName.LAST_MODIFIED, stats.mtime.toUTCString());
-        res.setHeader(exports.HeaderName.ETag, `W/"${stats.size}-${stats.mtime.getTime()}"`);
-        sendStream(res, node_fs.createReadStream(options.filePath, streamOptions), fn);
-    });
+        if (stats.mtime) {
+            const mtime = new Date(stats.mtime);
+            res.setHeader(exports.HeaderName.LAST_MODIFIED, mtime.toUTCString());
+            res.setHeader(exports.HeaderName.ETag, `W/"${stats.size}-${mtime.getTime()}"`);
+        }
+    }
+    try {
+        const content = await options.content(contentOptions);
+        if (isStream(content)) {
+            return await sendStream(res, content, next);
+        }
+        return await send(res, content);
+    } catch (e) {
+        if (next) {
+            return next(e);
+        }
+        if (isResponseGone(res)) {
+            return Promise.resolve();
+        }
+        return Promise.reject(e);
+    }
 }
 
 function sendFormat(res, input) {
@@ -1011,19 +1129,406 @@ function sendRedirect(res, location, statusCode = 302) {
     return send(res, html);
 }
 
-function processHandlerExecutionOutput(res, next, output) {
-    if (isPromise(output)) {
-        output.then((r)=>{
-            if (typeof r !== 'undefined') {
-                send(res, r);
+function sendWebResponse(res, webResponse) {
+    if (webResponse.redirected) {
+        res.setHeader(exports.HeaderName.LOCATION, webResponse.url);
+    }
+    if (webResponse.status) {
+        res.statusCode = webResponse.status;
+    }
+    if (webResponse.statusText) {
+        res.statusMessage = webResponse.statusText;
+    }
+    webResponse.headers.forEach((value, key)=>{
+        if (key === exports.HeaderName.SET_COOKIE) {
+            res.appendHeader(key, splitCookiesString(value));
+        } else {
+            res.setHeader(key, value);
+        }
+    });
+    if (webResponse.body) {
+        return sendStream(res, webResponse.body);
+    }
+    res.end();
+    return Promise.resolve();
+}
+
+function sendWebBlob(res, blob) {
+    setResponseHeaderContentType(res, blob.type);
+    return sendStream(res, blob.stream());
+}
+
+function createResponse(request) {
+    let output;
+    let encoding;
+    const write = (chunk, chunkEncoding, callback)=>{
+        if (typeof chunk !== 'undefined') {
+            const chunkEncoded = typeof chunk === 'string' ? buffer.Buffer.from(chunk, chunkEncoding || encoding || 'utf8') : chunk;
+            if (typeof output !== 'undefined') {
+                output = buffer.Buffer.concat([
+                    output,
+                    chunkEncoded
+                ]);
+            } else {
+                output = chunkEncoded;
             }
-            return r;
-        }).catch(next);
-        return;
+        }
+        encoding = chunkEncoding;
+        if (callback) {
+            callback();
+        }
+    };
+    const writable = new readableStream.Writable({
+        decodeStrings: false,
+        write (chunk, arg2, arg3) {
+            const chunkEncoding = typeof arg2 === 'string' ? encoding : 'utf-8';
+            let cb;
+            if (typeof arg2 === 'function') {
+                cb = arg2;
+            } else if (typeof arg3 === 'function') {
+                cb = arg3;
+            }
+            write(chunk, chunkEncoding, cb);
+            return true;
+        }
+    });
+    Object.defineProperty(writable, 'body', {
+        get () {
+            if (output) {
+                const arrayBuffer = new ArrayBuffer(output.length);
+                const view = new Uint8Array(arrayBuffer);
+                for(let i = 0; i < output.length; ++i){
+                    view[i] = output[i];
+                }
+                return arrayBuffer;
+            }
+            return new ArrayBuffer(0);
+        }
+    });
+    const headers = {};
+    Object.assign(writable, {
+        req: request,
+        chunkedEncoding: false,
+        connection: null,
+        headersSent: false,
+        sendDate: false,
+        shouldKeepAlive: false,
+        socket: null,
+        statusCode: 200,
+        statusMessage: '',
+        strictContentLength: false,
+        useChunkedEncodingByDefault: false,
+        finished: false,
+        addTrailers (_headers) {},
+        appendHeader (name, value) {
+            if (name === exports.HeaderName.SET_COOKIE) {
+                value = splitCookiesString(value);
+            }
+            name = name.toLowerCase();
+            const current = headers[name];
+            const all = [
+                ...Array.isArray(current) ? current : [
+                    current
+                ],
+                ...Array.isArray(value) ? value : [
+                    value
+                ]
+            ].filter(Boolean);
+            headers[name] = all.length > 1 ? all : all[0];
+            return this;
+        },
+        assignSocket (_socket) {},
+        detachSocket (_socket) {},
+        flushHeaders () {},
+        getHeader (name) {
+            return headers[name.toLowerCase()];
+        },
+        getHeaderNames () {
+            return Object.keys(headers);
+        },
+        getHeaders () {
+            return headers;
+        },
+        hasHeader (name) {
+            return smob.hasOwnProperty(headers, name.toLowerCase());
+        },
+        removeHeader (name) {
+            delete headers[name.toLowerCase()];
+        },
+        setHeader (name, value) {
+            if (name === exports.HeaderName.SET_COOKIE && typeof value !== 'number') {
+                value = splitCookiesString(value);
+            }
+            headers[name.toLowerCase()] = value;
+            return this;
+        },
+        setTimeout (_msecs, _callback) {
+            return this;
+        },
+        writeContinue (_callback) {},
+        writeEarlyHints (_hints, callback) {
+            if (typeof callback !== 'undefined') {
+                callback();
+            }
+        },
+        writeProcessing () {},
+        writeHead (statusCode, arg1, arg2) {
+            this.statusCode = statusCode;
+            if (typeof arg1 === 'string') {
+                this.statusMessage = arg1;
+                arg1 = undefined;
+            }
+            const headers = arg2 || arg1;
+            if (headers) {
+                if (Array.isArray(headers)) {
+                    for(let i = 0; i < headers.length; i++){
+                        const keys = Object.keys(headers[i]);
+                        for(let j = 0; j < keys.length; j++){
+                            this.setHeader(keys[i], headers[i][keys[j]]);
+                        }
+                    }
+                } else {
+                    const keys = Object.keys(headers);
+                    for(let i = 0; i < keys.length; i++){
+                        this.setHeader(keys[i], headers[keys[i]]);
+                    }
+                }
+            }
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this.headersSent = true;
+            return this;
+        }
+    });
+    return writable;
+}
+
+async function dispatchNodeRequest(router, req, res) {
+    try {
+        const dispatched = await router.dispatch({
+            req,
+            res
+        });
+        if (dispatched) {
+            return;
+        }
+        if (!isResponseGone(res)) {
+            res.statusCode = 404;
+            res.end();
+        }
+    } catch (e) {
+        if (!isResponseGone(res)) {
+            res.statusCode = 500;
+            res.end();
+        }
+    }
+}
+function createNodeDispatcher(router) {
+    return (req, res)=>{
+        // eslint-disable-next-line no-void
+        void dispatchNodeRequest(router, req, res);
+    };
+}
+
+function createRequest(context) {
+    let readable;
+    if (context.body) {
+        if (isWebStream(context.body)) {
+            readable = readableStream.Readable.fromWeb(context.body);
+        } else {
+            readable = readableStream.Readable.from(context.body);
+        }
+    } else {
+        readable = new readableStream.Readable();
+    }
+    const headers = context.headers || {};
+    const rawHeaders = [];
+    let keys = Object.keys(headers);
+    for(let i = 0; i < keys.length; i++){
+        const header = headers[keys[i]];
+        if (Array.isArray(header)) {
+            for(let j = 0; j < header.length; j++){
+                rawHeaders.push(keys[i], header[j]);
+            }
+        } else if (typeof header === 'string') {
+            rawHeaders.push(keys[i], header);
+        }
+    }
+    const headersDistinct = {};
+    keys = Object.keys(headers);
+    for(let i = 0; i < keys.length; i++){
+        const header = headers[keys[i]];
+        if (Array.isArray(header)) {
+            headersDistinct[keys[i]] = header;
+        }
+        if (typeof header === 'string') {
+            headersDistinct[keys[i]] = [
+                header
+            ];
+        }
+    }
+    Object.defineProperty(readable, 'connection', {
+        get () {
+            return {};
+        }
+    });
+    Object.defineProperty(readable, 'socket', {
+        get () {
+            return {};
+        }
+    });
+    Object.assign(readable, {
+        aborted: false,
+        complete: true,
+        headers,
+        headersDistinct,
+        httpVersion: '1.1',
+        httpVersionMajor: 1,
+        httpVersionMinor: 1,
+        method: context.method || 'GET',
+        rawHeaders,
+        rawTrailers: [],
+        trailers: {},
+        trailersDistinct: {},
+        url: context.url || '/',
+        setTimeout (_msecs, _callback) {
+            return this;
+        }
+    });
+    return readable;
+}
+
+async function dispatchRawRequest(router, request, options = {}) {
+    const req = createRequest({
+        url: request.path,
+        method: request.method,
+        body: request.body,
+        headers: request.headers
+    });
+    const res = createResponse(req);
+    const getHeaders = ()=>{
+        const output = {};
+        const headers = res.getHeaders();
+        const keys = Object.keys(headers);
+        for(let i = 0; i < keys.length; i++){
+            const header = headers[keys[i]];
+            if (typeof header === 'number') {
+                output[keys[i]] = `${header}`;
+            } else if (header) {
+                output[keys[i]] = header;
+            }
+        }
+        return output;
+    };
+    try {
+        const dispatched = await router.dispatch({
+            req,
+            res
+        });
+        if (dispatched) {
+            return {
+                status: res.statusCode,
+                statusMessage: res.statusMessage,
+                headers: getHeaders(),
+                body: res.body
+            };
+        }
+        return {
+            status: 404,
+            headers: getHeaders(),
+            body: res.body
+        };
+    } catch (e) {
+        if (options.throwOnError) {
+            throw e;
+        }
+        return {
+            status: 500,
+            headers: getHeaders(),
+            body: res.body
+        };
     }
-    if (typeof output !== 'undefined') {
-        send(res, output);
+}
+function createRawDispatcher(router) {
+    return async (request)=>dispatchRawRequest(router, request);
+}
+
+async function dispatchWebRequest(router, request, options = {}) {
+    const url = new URL(request.url);
+    const headers = {};
+    request.headers.forEach((value, key)=>{
+        headers[key] = value;
+    });
+    const res = await dispatchRawRequest(router, {
+        method: request.method,
+        path: url.pathname + url.search,
+        headers,
+        body: request.body
+    }, options);
+    let body;
+    if (request.method === exports.MethodName.HEAD || res.status === 304 || res.status === 101 || res.status === 204 || res.status === 205) {
+        body = null;
+    } else {
+        body = res.body;
     }
+    return new Response(body, {
+        headers: transformHeadersToTuples(res.headers),
+        status: res.status,
+        statusText: res.statusMessage
+    });
+}
+function createWebDispatcher(router) {
+    return async (request)=>dispatchWebRequest(router, request);
+}
+
+function cloneDispatcherMeta(input) {
+    if (!input) {
+        return {};
+    }
+    return {
+        path: input.path,
+        mountPath: input.mountPath,
+        error: input.error,
+        routerIds: [
+            ...input.routerIds || []
+        ],
+        params: cloneDispatcherMetaParams(input.params)
+    };
+}
+function cloneDispatcherMetaParams(input) {
+    if (typeof input === 'undefined') {
+        return {};
+    }
+    const keys = Object.keys(input);
+    const output = {};
+    for(let i = 0; i < keys.length; i++){
+        output[keys[i]] = input[keys[i]];
+    }
+    return output;
+}
+function mergeDispatcherMetaParams(t1, t2) {
+    if (!t1 && !t2) {
+        return {};
+    }
+    if (!t1 || !t2) {
+        return t1 || t2;
+    }
+    const keys = Object.keys(t2);
+    for(let i = 0; i < keys.length; i++){
+        t1[keys[i]] = t2[keys[i]];
+    }
+    return t1;
+}
+
+function createError(input) {
+    if (input instanceof Error) {
+        return input;
+    }
+    const error = new Error();
+    if (typeof input.message === 'string') {
+        error.message = input.message;
+    }
+    return error;
 }
 
 function decodeParam(val) {
@@ -1087,48 +1592,98 @@ class PathMatcher {
     }
 }
 
+function isPath(input) {
+    return typeof input === 'string' || input instanceof RegExp;
+}
+
 class Layer {
     // --------------------------------------------------
     isError() {
         return this.fn.length === 4;
     }
-    dispatch(req, res, meta, next, err) {
-        setRequestParams(req, meta.params || {});
-        setRequestMountPath(req, meta.mountPath || '/');
-        if (typeof err !== 'undefined') {
-            if (this.fn.length === 4) {
-                try {
-                    this.fn(err, req, res, next);
-                } catch (e) {
-                    /* istanbul ignore next */ /* istanbul ignore next */ if (e instanceof Error) {
-                        next(e);
-                    } else {
-                        next(new http.BadRequestError({
-                            message: 'The request could not be processed by the error handler.'
-                        }));
+    // --------------------------------------------------
+    dispatch(event, meta) {
+        setRequestParams(event.req, meta.params || {});
+        setRequestMountPath(event.req, meta.mountPath || '/');
+        setRequestRouterIds(event.req, meta.routerIds || []);
+        if (this.fn.length !== 4 && meta.error || this.fn.length === 4 && !meta.error) {
+            return Promise.reject(meta.error);
+        }
+        const timeout = findRouterOption('timeout', meta.routerIds);
+        return new Promise((resolve, reject)=>{
+            let timeoutInstance;
+            let handled = false;
+            const unsubscribe = ()=>{
+                if (timeoutInstance) {
+                    clearTimeout(timeoutInstance);
+                }
+                event.res.off('close', onFinished);
+                event.res.off('error', onFinished);
+            };
+            const shutdown = (dispatched, err)=>{
+                if (handled) {
+                    return;
+                }
+                handled = true;
+                unsubscribe();
+                if (err) {
+                    reject(createError(err));
+                } else {
+                    resolve(dispatched);
+                }
+            };
+            const onFinished = (err)=>shutdown(true, err);
+            const onNext = (err)=>shutdown(false, err);
+            event.res.once('close', onFinished);
+            event.res.once('error', onFinished);
+            if (timeout) {
+                timeoutInstance = setTimeout(()=>{
+                    handled = true;
+                    unsubscribe();
+                    event.res.statusCode = 504;
+                    event.res.statusMessage = 'Gateway Timeout';
+                    event.res.end();
+                }, timeout);
+            }
+            try {
+                let output;
+                if (meta.error) {
+                    output = this.fn(meta.error, event.req, event.res, onNext);
+                } else {
+                    output = this.fn(event.req, event.res, onNext);
+                }
+                const handle = (data)=>{
+                    if (typeof data === 'undefined' || handled) {
+                        return Promise.resolve();
                     }
+                    handled = true;
+                    unsubscribe();
+                    return this.sendOutput(event.res, data).then(()=>resolve(true)).catch((e)=>reject(createError(e)));
+                };
+                if (isPromise(output)) {
+                    output.then((r)=>handle(r)).catch((e)=>reject(createError(e)));
+                    return;
                 }
-                return;
+                Promise.resolve().then(()=>handle(output)).catch((e)=>reject(createError(e)));
+            } catch (error) {
+                onNext(error);
             }
-            /* istanbul ignore next */ next(err);
-            /* istanbul ignore next */ return;
+        });
+    }
+    sendOutput(res, input) {
+        if (input instanceof Error) {
+            return Promise.reject(input);
         }
-        /* istanbul ignore next */ if (this.fn.length > 3) {
-            next();
-            return;
+        if (isStream(input)) {
+            return sendStream(res, input);
         }
-        try {
-            const output = this.fn(req, res, next);
-            processHandlerExecutionOutput(res, next, output);
-        } catch (e) {
-            /* istanbul ignore next */ if (e instanceof Error) {
-                next(e);
-            } else {
-                next(new http.BadRequestError({
-                    message: 'The request could not be processed by the handler.'
-                }));
-            }
+        if (isWebBlob(input)) {
+            return sendWebBlob(res, input);
+        }
+        if (isWebResponse(input)) {
+            return sendWebResponse(res, input);
         }
+        return send(res, input);
     }
     // --------------------------------------------------
     matchPath(path) {
@@ -1146,6 +1701,9 @@ class Layer {
 }
 
 function isLayerInstance(input) {
+    if (input instanceof Layer) {
+        return true;
+    }
     return isInstance(input, 'Layer');
 }
 
@@ -1170,44 +1728,46 @@ class Route {
         return keys;
     }
     // --------------------------------------------------
-    dispatch(req, res, meta, done) {
-        /* istanbul ignore next */ if (!req.method) {
-            done();
-            return;
+    async dispatch(event, meta) {
+        /* istanbul ignore next */ if (!event.req.method) {
+            return false;
         }
-        let name = req.method.toLowerCase();
+        let name = event.req.method.toLowerCase();
         if (name === exports.MethodName.HEAD && !smob.hasOwnProperty(this.layers, name)) {
             name = exports.MethodName.GET;
         }
         const layers = this.layers[name];
         /* istanbul ignore next */ if (typeof layers === 'undefined' || layers.length === 0 || typeof meta.path === 'undefined') {
-            done();
-            return;
+            return false;
         }
-        const layerMeta = {
-            ...meta
-        };
+        const layerMeta = cloneDispatcherMeta(meta);
         const output = this.pathMatcher.exec(meta.path);
         if (output) {
-            layerMeta.params = smob.merge({}, meta.params || {}, output.params);
+            layerMeta.params = mergeDispatcherMetaParams(layerMeta.params, output.params);
         }
-        let index = -1;
-        const next = (err)=>{
-            index++;
-            if (index >= layers.length) {
-                setImmediate(done, err);
-                return;
-            }
-            const layer = layers[index];
+        let err;
+        for(let i = 0; i < layers.length; i++){
+            const layer = layers[i];
             if (err && !layer.isError()) {
-                next(err);
-                return;
+                continue;
             }
-            layer.dispatch(req, res, {
-                ...layerMeta
-            }, next);
-        };
-        next();
+            try {
+                const dispatched = await layer.dispatch(event, {
+                    ...layerMeta
+                });
+                if (dispatched) {
+                    return true;
+                }
+            } catch (e) {
+                if (e instanceof Error) {
+                    err = e;
+                }
+            }
+        }
+        if (err) {
+            throw err;
+        }
+        return false;
     }
     // --------------------------------------------------
     register(method, ...handlers) {
@@ -1260,42 +1820,50 @@ class Route {
 }
 
 function isRouteInstance(input) {
+    if (input instanceof Route) {
+        return true;
+    }
     return isInstance(input, 'Route');
 }
 
+function transformRouterOptions(input) {
+    if (typeof input.etag !== 'undefined') {
+        input.etag = buildEtagFn(input.etag);
+    }
+    if (typeof input.trustProxy !== 'undefined') {
+        input.trustProxy = buildTrustProxyFn(input.trustProxy);
+    }
+    return input;
+}
+
+let nextId = 0;
+function generateRouterID() {
+    return ++nextId;
+}
+
 function isRouterInstance(input) {
+    if (input instanceof Router) {
+        return true;
+    }
     return isInstance(input, 'Router');
 }
 class Router {
     // --------------------------------------------------
-    setPathMatcherOptions(input) {
-        this.pathMatcherOptions = input;
-        if (this.pathMatcher) {
-            this.pathMatcher.regexpOptions = this.pathMatcherOptions;
-        }
-    }
     setPath(value) {
         if (value === '/' || !isPath(value)) {
-            this.path = '/';
             return;
         }
+        let path;
         if (typeof value === 'string') {
-            this.path = withLeadingSlash(withoutTrailingSlash(`${value}`));
+            path = withLeadingSlash(withoutTrailingSlash(`${value}`));
         } else {
-            this.path = value;
+            path = value;
         }
-        this.pathMatcher = new PathMatcher(this.path, this.pathMatcherOptions);
-    }
-    // --------------------------------------------------
-    createListener() {
-        this.isRoot = true;
-        return (req, res)=>{
-            this.dispatch(req, res);
-        };
-    }
-    /* istanbul ignore next */ listen(port) {
-        const server = node_http.createServer(this.createListener());
-        return server.listen(port);
+        this.pathMatcher = new PathMatcher(path, {
+            end: false,
+            sensitive: false,
+            ...this.pathMatcherOptions ? this.pathMatcherOptions : {}
+        });
     }
     // --------------------------------------------------
     matchPath(path) {
@@ -1305,35 +1873,9 @@ class Router {
         return true;
     }
     // --------------------------------------------------
-    dispatch(req, res, meta, done) {
-        let index = -1;
-        meta = meta || {};
-        let allowedMethods = [];
-        if (this.isRoot && typeof this.timeout === 'number') {
-            createRequestTimeout(res, this.timeout, done);
-        }
-        const fn = (err)=>{
-            /* istanbul ignore if */ if (!this.isRoot) {
-                if (typeof done !== 'undefined') {
-                    setImmediate(()=>done(err));
-                }
-                return;
-            }
-            if (typeof err !== 'undefined') {
-                res.statusCode = 400;
-                res.end();
-                return;
-            }
-            if (req.method && req.method.toLowerCase() === exports.MethodName.OPTIONS) {
-                const options = allowedMethods.map((key)=>key.toUpperCase()).join(',');
-                res.setHeader(exports.HeaderName.ALLOW, options);
-                send(res, options);
-                return;
-            }
-            res.statusCode = 404;
-            res.end();
-        };
-        let path = meta.path || useRequestPath(req);
+    async dispatch(event, meta = {}) {
+        const allowedMethods = [];
+        let path = meta.path || useRequestPath(event.req);
         if (this.pathMatcher) {
             const output = this.pathMatcher.exec(path);
             if (typeof output !== 'undefined') {
@@ -1347,74 +1889,78 @@ class Router {
             }
         }
         meta.path = path;
+        if (meta.routerIds) {
+            meta.routerIds.push(this.id);
+        } else {
+            meta.routerIds = [
+                this.id
+            ];
+        }
         if (!meta.mountPath) {
             meta.mountPath = '/';
         }
-        const next = (err)=>{
-            if (index >= this.stack.length) {
-                setImmediate(fn, err);
-                return;
-            }
-            let layer;
-            let match = false;
-            while(!match && index < this.stack.length){
-                index++;
-                layer = this.stack[index];
-                if (isLayerInstance(layer)) {
-                    if (!layer.isError() && err) {
-                        continue;
-                    }
-                    match = layer.matchPath(path);
+        let err;
+        let layer;
+        let match = false;
+        for(let i = 0; i < this.stack.length; i++){
+            layer = this.stack[i];
+            if (layer instanceof Layer) {
+                if (!layer.isError() && err) {
+                    continue;
                 }
-                if (isRouterInstance(layer)) {
-                    match = layer.matchPath(path);
-                }
-                if (isRouteInstance(layer)) {
-                    match = layer.matchPath(path);
-                    if (req.method && !layer.matchMethod(req.method)) {
-                        match = false;
-                        if (req.method.toLowerCase() === exports.MethodName.OPTIONS) {
-                            allowedMethods = smob.distinctArray(smob.merge(allowedMethods, layer.getMethods()));
-                        }
+                match = layer.matchPath(path);
+            }
+            if (isRouterInstance(layer)) {
+                match = layer.matchPath(path);
+            }
+            if (isRouteInstance(layer)) {
+                match = layer.matchPath(path);
+                if (event.req.method && !layer.matchMethod(event.req.method)) {
+                    match = false;
+                    if (event.req.method.toLowerCase() === exports.MethodName.OPTIONS) {
+                        allowedMethods.push(...layer.getMethods());
                     }
                 }
             }
-            if (!match || !layer) {
-                setImmediate(fn, err);
-                return;
+            if (!match) {
+                continue;
             }
-            const layerMeta = {
-                ...meta
-            };
+            const layerMeta = cloneDispatcherMeta(meta);
             if (isLayerInstance(layer)) {
                 const output = layer.exec(path);
                 if (output) {
-                    layerMeta.params = smob.merge(output.params, layerMeta.params || {});
+                    layerMeta.params = mergeDispatcherMetaParams(layerMeta.params, output.params);
                     layerMeta.mountPath = cleanDoubleSlashes(`${layerMeta.mountPath || ''}/${output.path}`);
                 }
-            }
-            if (err) {
-                if (isLayerInstance(layer) && layer.isError()) {
-                    layer.dispatch(req, res, layerMeta, next, err);
-                    return;
+                if (err) {
+                    layerMeta.error = err;
                 }
-                /* istanbul ignore next */ setImmediate(next, err);
-                return;
+            } else if (err) {
+                continue;
             }
-            layer.dispatch(req, res, layerMeta, next);
-        };
-        next();
-    }
-    /* istanbul ignore next */ dispatchAsync(req, res) {
-        return new Promise((resolve, reject)=>{
-            this.dispatch(req, res, {}, (err)=>{
-                if (err) {
-                    reject(err);
-                    return;
+            try {
+                const dispatched = await layer.dispatch(event, layerMeta);
+                if (dispatched) {
+                    return true;
                 }
-                resolve();
-            });
-        });
+            } catch (e) {
+                if (e instanceof Error) {
+                    err = e;
+                }
+            }
+        }
+        if (err) {
+            throw err;
+        }
+        if (event.req.method && event.req.method.toLowerCase() === exports.MethodName.OPTIONS) {
+            const options = smob.distinctArray(allowedMethods).map((key)=>key.toUpperCase()).join(',');
+            if (!isResponseGone(event.res)) {
+                event.res.setHeader(exports.HeaderName.ALLOW, options);
+                await send(event.res, options);
+            }
+            return true;
+        }
+        return false;
     }
     // --------------------------------------------------
     route(path) {
@@ -1428,7 +1974,9 @@ class Router {
         const route = new Route({
             path,
             pathMatcher: {
-                sensitive: this.pathMatcherOptions.sensitive
+                ...this.pathMatcherOptions ? {
+                    sensitive: this.pathMatcherOptions.sensitive
+                } : {}
             }
         });
         this.stack.push(route);
@@ -1483,7 +2031,6 @@ class Router {
                 if (path) {
                     item.setPath(path);
                 }
-                item.setPathMatcherOptions(this.pathMatcherOptions);
                 this.stack.push(item);
                 continue;
             }
@@ -1493,7 +2040,9 @@ class Router {
                     pathMatcher: {
                         strict: false,
                         end: false,
-                        sensitive: this.pathMatcherOptions.sensitive
+                        ...this.pathMatcherOptions ? {
+                            sensitive: this.pathMatcherOptions.sensitive
+                        } : {}
                     }
                 }, item));
             }
@@ -1501,21 +2050,17 @@ class Router {
         return this;
     }
     // --------------------------------------------------
-    constructor(ctx){
+    constructor(options = {}){
         this['@instanceof'] = Symbol.for('Router');
         /**
      * Array of mounted layers, routes & routers.
      *
      * @protected
      */ this.stack = [];
-        ctx = ctx || {};
-        this.pathMatcherOptions = {
-            end: false,
-            sensitive: true,
-            ...ctx.pathMatcher || {}
-        };
-        this.timeout = ctx.timeout;
-        this.setPath(ctx.path || '/');
+        this.id = generateRouterID();
+        this.pathMatcherOptions = options.pathMatcher;
+        this.setPath(options.path);
+        setRouterOptions(this.id, transformRouterOptions(options));
     }
 }
 
@@ -1525,19 +2070,19 @@ exports.Route = Route;
 exports.Router = Router;
 exports.appendResponseHeader = appendResponseHeader;
 exports.appendResponseHeaderDirective = appendResponseHeaderDirective;
-exports.buildConfig = buildConfig;
-exports.buildEtagFn = buildEtagFn;
-exports.buildTrustProxyFn = buildTrustProxyFn;
-exports.cleanDoubleSlashes = cleanDoubleSlashes;
-exports.createEtag = createEtag;
-exports.createRequestTimeout = createRequestTimeout;
+exports.cloneDispatcherMeta = cloneDispatcherMeta;
+exports.cloneDispatcherMetaParams = cloneDispatcherMetaParams;
+exports.createNodeDispatcher = createNodeDispatcher;
+exports.createRawDispatcher = createRawDispatcher;
+exports.createRequest = createRequest;
+exports.createResponse = createResponse;
+exports.createWebDispatcher = createWebDispatcher;
+exports.dispatchNodeRequest = dispatchNodeRequest;
+exports.dispatchRawRequest = dispatchRawRequest;
+exports.dispatchWebRequest = dispatchWebRequest;
 exports.extendRequestBody = extendRequestBody;
 exports.extendRequestCookies = extendRequestCookies;
 exports.extendRequestQuery = extendRequestQuery;
-exports.generateETag = generateETag;
-exports.getCharsetForMimeType = getCharsetForMimeType;
-exports.getConfigOption = getConfigOption;
-exports.getMimeType = getMimeType;
 exports.getRequestAcceptableCharset = getRequestAcceptableCharset;
 exports.getRequestAcceptableCharsets = getRequestAcceptableCharsets;
 exports.getRequestAcceptableContentType = getRequestAcceptableContentType;
@@ -1550,22 +2095,17 @@ exports.getRequestHeader = getRequestHeader;
 exports.getRequestHostName = getRequestHostName;
 exports.getRequestIP = getRequestIP;
 exports.getRequestProtocol = getRequestProtocol;
-exports.hasLeadingSlash = hasLeadingSlash;
 exports.hasRequestBody = hasRequestBody;
 exports.hasRequestCookies = hasRequestCookies;
 exports.hasRequestQuery = hasRequestQuery;
-exports.hasTrailingSlash = hasTrailingSlash;
-exports.isInstance = isInstance;
 exports.isLayerInstance = isLayerInstance;
-exports.isObject = isObject;
 exports.isPath = isPath;
-exports.isPromise = isPromise;
 exports.isRequestCacheable = isRequestCacheable;
+exports.isResponseGone = isResponseGone;
 exports.isRouteInstance = isRouteInstance;
 exports.isRouterInstance = isRouterInstance;
 exports.matchRequestContentType = matchRequestContentType;
-exports.onResponseFinished = onResponseFinished;
-exports.processHandlerExecutionOutput = processHandlerExecutionOutput;
+exports.mergeDispatcherMetaParams = mergeDispatcherMetaParams;
 exports.send = send;
 exports.sendAccepted = sendAccepted;
 exports.sendCreated = sendCreated;
@@ -1573,8 +2113,8 @@ exports.sendFile = sendFile;
 exports.sendFormat = sendFormat;
 exports.sendRedirect = sendRedirect;
 exports.sendStream = sendStream;
-exports.setConfig = setConfig;
-exports.setConfigOption = setConfigOption;
+exports.sendWebBlob = sendWebBlob;
+exports.sendWebResponse = sendWebResponse;
 exports.setRequestBody = setRequestBody;
 exports.setRequestCookies = setRequestCookies;
 exports.setRequestEnv = setRequestEnv;
@@ -1583,12 +2123,12 @@ exports.setRequestMountPath = setRequestMountPath;
 exports.setRequestParam = setRequestParam;
 exports.setRequestParams = setRequestParams;
 exports.setRequestQuery = setRequestQuery;
+exports.setRequestRouterIds = setRequestRouterIds;
 exports.setResponseCacheHeaders = setResponseCacheHeaders;
 exports.setResponseContentTypeByFileName = setResponseContentTypeByFileName;
 exports.setResponseHeaderAttachment = setResponseHeaderAttachment;
 exports.setResponseHeaderContentType = setResponseHeaderContentType;
 exports.unsetRequestEnv = unsetRequestEnv;
-exports.useConfig = useConfig;
 exports.useRequestBody = useRequestBody;
 exports.useRequestCookie = useRequestCookie;
 exports.useRequestCookies = useRequestCookies;
@@ -1599,8 +2139,5 @@ exports.useRequestParam = useRequestParam;
 exports.useRequestParams = useRequestParams;
 exports.useRequestPath = useRequestPath;
 exports.useRequestQuery = useRequestQuery;
-exports.withLeadingSlash = withLeadingSlash;
-exports.withTrailingSlash = withTrailingSlash;
-exports.withoutLeadingSlash = withoutLeadingSlash;
-exports.withoutTrailingSlash = withoutTrailingSlash;
+exports.useRequestRouterIds = useRequestRouterIds;
 //# sourceMappingURL=index.cjs.map