routup 1.0.3 → 3.0.0-alpha.1

package/dist/index.cjs

@@ -1,19 +1,186 @@
 '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 http = require('@ebec/http');
 var smob = require('smob');
+var buffer = require('buffer');
+var uncrypto = require('uncrypto');
 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 = {}));
+
+class ErrorProxy extends http.HTTPError {
+}
+
+function isError(input) {
+    return input instanceof ErrorProxy;
+}
+
+/**
+ * Create an error proxy by
+ * - an existing error (accessible via cause property)
+ * - options
+ * - message
+ *
+ * @param input
+ */ function createError(input) {
+    if (isError(input)) {
+        return input;
+    }
+    if (typeof input === 'string') {
+        return new ErrorProxy(input);
+    }
+    return new ErrorProxy({
+        cause: input
+    }, input);
+}
+
+/*
+  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 +189,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 +209,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 +238,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;
             }
@@ -101,8 +266,11 @@ function buildTrustProxyFn(input) {
     return proxyAddr.compile(input || []);
 }
 
-function isInstance(input, name) {
-    return typeof input === 'object' && input !== null && input['@instanceof'] === Symbol.for(name);
+function isInstance(input, sym) {
+    if (!isObject(input)) {
+        return false;
+    }
+    return input['@instanceof'] === sym;
 }
 
 function getMimeType(type) {
@@ -122,8 +290,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 +317,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,115 +344,26 @@ 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}`;
 }
 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 useConfig() {
-    if (typeof instance !== 'undefined') {
-        return instance;
+    if (input.indexOf('://') !== -1) {
+        return input.split('://').map((str)=>cleanDoubleSlashes(str)).join('://');
     }
-    instance = buildConfig();
-    return instance;
+    return input.replace(/\/+/g, '/');
 }
-function setConfig(config) {
-    instance = config;
-}
-function setConfigOption(key, value) {
-    const config = useConfig();
-    config.setRaw(key, value);
-    return config.get();
+
+function isWebBlob(input) {
+    return typeof Blob !== 'undefined' && input instanceof Blob;
 }
-function getConfigOption(key) {
-    const config = useConfig();
-    return config.get(key);
+function isWebResponse(input) {
+    return typeof Response !== 'undefined' && input instanceof Response;
 }
 
-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 BodySymbol = Symbol.for('ReqBody');
 function useRequestBody(req, key) {
     let body;
@@ -539,14 +625,48 @@ function matchRequestContentType(req, contentType) {
     return header.split('; ').shift() === getMimeType(contentType);
 }
 
+const defaults = {
+    trustProxy: ()=>false,
+    subdomainOffset: 2,
+    etag: buildEtagFn(),
+    proxyIpMax: 0
+};
+const instances = {};
+function setRouterOptions(id, input) {
+    instances[id] = input;
+}
+function findRouterOption(key, path) {
+    if (!path || path.length === 0) {
+        return defaults[key];
+    }
+    if (path.length > 0) {
+        for(let i = path.length; i >= 0; i--){
+            if (smob.hasOwnProperty(instances, path[i]) && typeof instances[path[i]][key] !== 'undefined') {
+                return instances[path[i]][key];
+            }
+        }
+    }
+    return defaults[key];
+}
+
+const routerSymbol = Symbol.for('ReqRouterID');
+function setRequestRouterPath(req, path) {
+    req[routerSymbol] = path;
+}
+function useRequestRouterPath(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', useRequestRouterPath(req));
     }
     let hostname = req.headers[exports.HeaderName.X_FORWARDED_HOST];
     if (!hostname || !req.socket.remoteAddress || !trustProxy(req.socket.remoteAddress, 0)) {
@@ -572,8 +692,7 @@ function getRequestIP(req, options) {
     if (typeof options.trustProxy !== 'undefined') {
         trustProxy = buildTrustProxyFn(options.trustProxy);
     } else {
-        const config = useConfig();
-        trustProxy = config.get('trustProxy');
+        trustProxy = findRouterOption('trustProxy', useRequestRouterPath(req));
     }
     const addrs = proxyAddr.all(req, trustProxy);
     return addrs[addrs.length - 1];
@@ -623,7 +742,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];
 }
@@ -634,8 +753,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', useRequestRouterPath(req));
     }
     let protocol = options.default;
     /* istanbul ignore next */ if (smob.hasOwnProperty(req.socket, 'encrypted') && !!req.socket.encrypted) {
@@ -703,6 +821,78 @@ function extendRequestQuery(req, key, value) {
     setRequestQuery(req, key, value);
 }
 
+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 {
+                remoteAddress: '127.0.0.1'
+            };
+        }
+    });
+    Object.defineProperty(readable, 'socket', {
+        get () {
+            return {
+                remoteAddress: '127.0.0.1'
+            };
+        }
+    });
+    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;
+}
+
 function setResponseCacheHeaders(res, options) {
     options = options || {};
     const cacheControls = [
@@ -718,6 +908,17 @@ function setResponseCacheHeaders(res, options) {
     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) {
@@ -767,7 +968,7 @@ function appendResponseHeaderDirective(res, name, value) {
 }
 
 function setResponseContentTypeByFileName(res, fileName) {
-    const ext = path.extname(fileName);
+    const ext = extname(fileName);
     if (ext) {
         let type = getMimeType(ext.substring(1));
         if (type) {
@@ -779,23 +980,6 @@ function setResponseContentTypeByFileName(res, fileName) {
         }
     }
 }
-/* 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') {
@@ -817,7 +1001,7 @@ function setResponseHeaderContentType(res, input, ifNotExists) {
     }
 }
 
-function send(res, chunk) {
+async function send(res, chunk) {
     switch(typeof chunk){
         case 'string':
             {
@@ -828,11 +1012,9 @@ function send(res, chunk) {
         case 'number':
         case 'object':
             {
-                if (chunk === null) {
-                    chunk = '';
-                } else if (Buffer.isBuffer(chunk)) {
+                if (buffer.Buffer.isBuffer(chunk)) {
                     setResponseHeaderContentType(res, 'bin', true);
-                } else {
+                } else if (chunk !== null) {
                     chunk = JSON.stringify(chunk);
                     setResponseHeaderContentType(res, 'application/json', true);
                 }
@@ -847,25 +1029,27 @@ function send(res, chunk) {
     }
     // populate Content-Length
     let len;
-    if (chunk !== undefined) {
-        if (Buffer.isBuffer(chunk)) {
+    if (chunk !== undefined && chunk !== null) {
+        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', useRequestRouterPath(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) {
@@ -878,24 +1062,30 @@ function send(res, chunk) {
         res.removeHeader(exports.HeaderName.CONTENT_TYPE);
         res.removeHeader(exports.HeaderName.CONTENT_LENGTH);
         res.removeHeader(exports.HeaderName.TRANSFER_ENCODING);
-        chunk = '';
     }
     // alter headers for 205
     if (res.statusCode === 205) {
         res.setHeader(exports.HeaderName.CONTENT_LENGTH, 0);
         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 chunk === 'undefined' || chunk === null) {
+        res.end();
+        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) {
@@ -910,87 +1100,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) {
@@ -1012,20 +1231,389 @@ 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;
+}
+
+function buildDispatcherMeta(input) {
+    return {
+        mountPath: input.mountPath || '/',
+        params: input.params || {},
+        path: input.path || '/',
+        routerPath: []
+    };
+}
+function cloneDispatcherMeta(input) {
+    return {
+        path: input.path,
+        mountPath: input.mountPath,
+        error: input.error,
+        routerPath: [
+            ...input.routerPath
+        ],
+        params: cloneDispatcherMetaParams(input.params)
+    };
+}
+function cloneDispatcherMetaParams(input) {
+    if (typeof input === 'undefined') {
+        return {};
+    }
+    const keys = Object.keys(input);
+    if (keys.length === 0) {
+        return {};
+    }
+    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;
     }
-    if (typeof output !== 'undefined') {
-        send(res, output);
+    const keys = Object.keys(t2);
+    if (keys.length === 0) {
+        return t1;
+    }
+    for(let i = 0; i < keys.length; i++){
+        t1[keys[i]] = t2[keys[i]];
+    }
+    return t1;
+}
+
+async function dispatchNodeRequest(router, req, res) {
+    try {
+        const dispatched = await router.dispatch({
+            req,
+            res
+        }, buildDispatcherMeta({
+            path: useRequestPath(req)
+        }));
+        if (dispatched) {
+            return;
+        }
+        if (!isResponseGone(res)) {
+            res.statusCode = 404;
+            res.end();
+        }
+    } catch (e) {
+        if (!isResponseGone(res)) {
+            if (isError(e)) {
+                res.statusCode = e.statusCode;
+                if (e.statusMessage) {
+                    res.statusMessage = e.statusMessage;
+                }
+            } else {
+                res.statusCode = 500;
+            }
+            res.end();
+        }
+    }
+}
+function createNodeDispatcher(router) {
+    return (req, res)=>{
+        // eslint-disable-next-line no-void
+        void dispatchNodeRequest(router, req, res);
+    };
+}
+
+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;
+    };
+    const createRawResponse = (input = {})=>({
+            status: input.status || res.statusCode,
+            statusMessage: input.statusMessage || res.statusMessage,
+            headers: getHeaders(),
+            body: res.body
+        });
+    try {
+        const dispatched = await router.dispatch({
+            req,
+            res
+        }, buildDispatcherMeta({
+            path: useRequestPath(req)
+        }));
+        if (dispatched) {
+            return createRawResponse();
+        }
+        return createRawResponse({
+            status: 404
+        });
+    } catch (e) {
+        if (options.throwOnError) {
+            throw e;
+        }
+        if (isError(e)) {
+            return createRawResponse({
+                status: e.statusCode,
+                statusMessage: e.statusMessage
+            });
+        }
+        return createRawResponse({
+            status: 500
+        });
     }
 }
+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);
+}
+
+exports.HandlerType = void 0;
+(function(HandlerType) {
+    HandlerType["CORE"] = "core";
+    HandlerType["ERROR"] = "error";
+})(exports.HandlerType || (exports.HandlerType = {}));
+
+function coreHandler(input) {
+    if (typeof input === 'function') {
+        return {
+            type: exports.HandlerType.CORE,
+            fn: input
+        };
+    }
+    return {
+        type: exports.HandlerType.CORE,
+        ...input
+    };
+}
+
+function errorHandler(input) {
+    if (typeof input === 'function') {
+        return {
+            type: exports.HandlerType.ERROR,
+            fn: input
+        };
+    }
+    return {
+        type: exports.HandlerType.ERROR,
+        ...input
+    };
+}
+
+function isHandler(input) {
+    return isObject(input) && typeof input.fn === 'function' && typeof input.type === 'string';
+}
 
 function decodeParam(val) {
     /* istanbul ignore next */ if (typeof val !== 'string' || val.length === 0) {
@@ -1035,268 +1623,219 @@ function decodeParam(val) {
 }
 class PathMatcher {
     test(path) {
-        const fastSlash = this.path === '/' && this.regexpOptions.end === false;
-        if (fastSlash) {
-            return true;
-        }
         return this.regexp.test(path);
     }
     exec(path) {
-        let match = null;
-        const fastSlash = this.path === '/' && this.regexpOptions.end === false;
-        if (fastSlash) {
+        if (this.path === '/' && this.regexpOptions.end === false) {
             return {
                 path: '/',
                 params: {}
             };
         }
-        match = this.regexp.exec(path);
-        if (!match) {
-            return undefined;
-        }
-        if (this.path instanceof RegExp) {
+        if (this.path === '*') {
             return {
                 path,
                 params: {
-                    0: decodeParam(match[0])
+                    0: decodeParam(path)
                 }
             };
         }
-        const output = {};
+        const match = this.regexp.exec(path);
+        if (!match) {
+            return undefined;
+        }
+        const params = {};
         for(let i = 1; i < match.length; i++){
             const key = this.regexpKeys[i - 1];
             const prop = key.name;
             const val = decodeParam(match[i]);
             if (typeof val !== 'undefined') {
-                output[prop] = val;
+                params[prop] = val;
             }
         }
         return {
             path: match[0],
-            params: output
+            params
         };
     }
     constructor(path, options){
         this.regexpKeys = [];
         this.path = path;
         this.regexpOptions = options || {};
-        if (path instanceof RegExp) {
-            this.regexp = path;
-        } else {
-            this.regexp = pathToRegexp.pathToRegexp(path, this.regexpKeys, options);
-        }
+        this.regexp = pathToRegexp.pathToRegexp(path, this.regexpKeys, options);
     }
 }
 
+function isPath(input) {
+    return typeof input === 'string' || input instanceof RegExp;
+}
+
+const LayerSymbol = Symbol.for('Layer');
+
 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.'
-                        }));
+    get type() {
+        return this.handler.type;
+    }
+    get path() {
+        return this.handler.path;
+    }
+    get method() {
+        return this.handler.method ? this.handler.method.toLowerCase() : undefined;
+    }
+    // --------------------------------------------------
+    dispatch(event, meta) {
+        if (this.pathMatcher) {
+            const pathMatch = this.pathMatcher.exec(meta.path);
+            if (pathMatch) {
+                meta.params = mergeDispatcherMetaParams(meta.params, pathMatch.params);
+            }
+        }
+        setRequestParams(event.req, meta.params);
+        setRequestMountPath(event.req, meta.mountPath);
+        setRequestRouterPath(event.req, meta.routerPath);
+        return new Promise((resolve, reject)=>{
+            let handled = false;
+            const unsubscribe = ()=>{
+                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);
+            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)));
+            };
+            try {
+                let output;
+                if (this.handler.type === exports.HandlerType.ERROR) {
+                    if (meta.error) {
+                        output = this.handler.fn(meta.error, event.req, event.res, onNext);
                     }
+                } else {
+                    output = this.handler.fn(event.req, event.res, onNext);
                 }
-                return;
+                if (isPromise(output)) {
+                    output.then((r)=>handle(r)).catch((e)=>reject(createError(e)));
+                    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(createError(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) {
+        if (!this.pathMatcher) {
+            return true;
+        }
         return this.pathMatcher.test(path);
     }
-    exec(path) {
-        return this.pathMatcher.exec(path);
+    matchMethod(method) {
+        if (!this.method) {
+            return true;
+        }
+        const name = method.toLowerCase();
+        if (name === this.method) {
+            return true;
+        }
+        return name === exports.MethodName.HEAD && this.method === exports.MethodName.GET;
     }
     // --------------------------------------------------
-    constructor(options, fn){
-        this['@instanceof'] = Symbol.for('Layer');
-        this.pathMatcher = new PathMatcher(options.path, options.pathMatcher);
-        this.fn = fn;
+    constructor(handler){
+        this['@instanceof'] = LayerSymbol;
+        this.handler = handler;
+        if (handler.path) {
+            this.pathMatcher = new PathMatcher(handler.path, {
+                end: !!handler.method
+            });
+        }
     }
 }
 
 function isLayerInstance(input) {
-    return isInstance(input, 'Layer');
+    return isInstance(input, LayerSymbol);
 }
 
-class Route {
-    // --------------------------------------------------
-    matchPath(path) {
-        return this.pathMatcher.test(path);
-    }
-    matchMethod(method) {
-        let name = method.toLowerCase();
-        if (name === exports.MethodName.HEAD && !smob.hasOwnProperty(this.layers, name)) {
-            name = exports.MethodName.GET;
-        }
-        return Object.prototype.hasOwnProperty.call(this.layers, name);
-    }
-    // --------------------------------------------------
-    getMethods() {
-        const keys = Object.keys(this.layers);
-        if (smob.hasOwnProperty(this.layers, exports.MethodName.GET) && !smob.hasOwnProperty(this.layers, exports.MethodName.HEAD)) {
-            keys.push(exports.MethodName.HEAD);
-        }
-        return keys;
-    }
-    // --------------------------------------------------
-    dispatch(req, res, meta, done) {
-        /* istanbul ignore next */ if (!req.method) {
-            done();
-            return;
-        }
-        let name = 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;
-        }
-        const layerMeta = {
-            ...meta
-        };
-        const output = this.pathMatcher.exec(meta.path);
-        if (output) {
-            layerMeta.params = smob.merge({}, meta.params || {}, output.params);
-        }
-        let index = -1;
-        const next = (err)=>{
-            index++;
-            if (index >= layers.length) {
-                setImmediate(done, err);
-                return;
-            }
-            const layer = layers[index];
-            if (err && !layer.isError()) {
-                next(err);
-                return;
-            }
-            layer.dispatch(req, res, {
-                ...layerMeta
-            }, next);
-        };
-        next();
-    }
-    // --------------------------------------------------
-    register(method, ...handlers) {
-        this.layers[method] = [];
-        for(let i = 0; i < handlers.length; i++){
-            const layer = new Layer({
-                path: this.path,
-                pathMatcher: this.pathMatcherOptions
-            }, handlers[i]);
-            this.layers[method].push(layer);
-        }
-    }
-    get(...handlers) {
-        return this.register(exports.MethodName.GET, ...handlers);
-    }
-    post(...handlers) {
-        return this.register(exports.MethodName.POST, ...handlers);
-    }
-    put(...handlers) {
-        return this.register(exports.MethodName.PUT, ...handlers);
-    }
-    patch(...handlers) {
-        return this.register(exports.MethodName.PATCH, ...handlers);
-    }
-    delete(...handlers) {
-        return this.register(exports.MethodName.DELETE, ...handlers);
-    }
-    head(...handlers) {
-        return this.register(exports.MethodName.HEAD, ...handlers);
+function isPluginInstallContext(input) {
+    if (!isObject(input) || !isObject(input.options)) {
+        return false;
     }
-    options(...handlers) {
-        return this.register(exports.MethodName.OPTIONS, ...handlers);
+    if (typeof input.name !== 'undefined' && typeof input.name !== 'string') {
+        return false;
     }
-    // --------------------------------------------------
-    isStrictPath() {
-        return typeof this.path !== 'string' || this.path !== '/' && this.path.length !== 0;
+    return typeof input.path === 'undefined' || isPath(input.path);
+}
+
+function transformRouterOptions(input) {
+    if (typeof input.etag !== 'undefined') {
+        input.etag = buildEtagFn(input.etag);
     }
-    // --------------------------------------------------
-    constructor(options){
-        this['@instanceof'] = Symbol.for('Route');
-        this.layers = {};
-        this.path = options.path;
-        this.pathMatcherOptions = {
-            end: true,
-            strict: this.isStrictPath(),
-            ...options.pathMatcher
-        };
-        this.pathMatcher = new PathMatcher(this.path, this.pathMatcherOptions);
+    if (typeof input.trustProxy !== 'undefined') {
+        input.trustProxy = buildTrustProxyFn(input.trustProxy);
     }
+    return input;
 }
 
-function isRouteInstance(input) {
-    return isInstance(input, 'Route');
-}
+const RouterSymbol = Symbol.for('Router');
 
+let nextId = 0;
+function generateRouterID() {
+    return ++nextId;
+}
 function isRouterInstance(input) {
-    return isInstance(input, 'Router');
+    return isInstance(input, RouterSymbol);
 }
+
 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
+        });
     }
     // --------------------------------------------------
     matchPath(path) {
@@ -1306,239 +1845,279 @@ 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 = [];
         if (this.pathMatcher) {
-            const output = this.pathMatcher.exec(path);
+            const output = this.pathMatcher.exec(meta.path);
             if (typeof output !== 'undefined') {
-                meta.mountPath = cleanDoubleSlashes(`${meta.mountPath || ''}/${output.path}`);
-                if (path === output.path) {
-                    path = '/';
+                meta.mountPath = cleanDoubleSlashes(`${meta.mountPath}/${output.path}`);
+                if (meta.path === output.path) {
+                    meta.path = '/';
                 } else {
-                    path = withLeadingSlash(path.substring(output.path.length));
+                    meta.path = withLeadingSlash(meta.path.substring(output.path.length));
                 }
-                meta.params = smob.merge(meta.params || {}, output.params);
+                meta.params = {
+                    ...meta.params,
+                    ...output.params
+                };
             }
         }
-        meta.path = path;
-        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);
+        meta.routerPath.push(this.id);
+        let err;
+        let item;
+        let itemMeta;
+        let match = false;
+        for(let i = 0; i < this.stack.length; i++){
+            item = this.stack[i];
+            if (isLayerInstance(item)) {
+                if (item.type !== exports.HandlerType.ERROR && err) {
+                    continue;
                 }
-                if (isRouterInstance(layer)) {
-                    match = layer.matchPath(path);
-                }
-                if (isRouteInstance(layer)) {
-                    match = layer.matchPath(path);
-                    if (req.method && !layer.matchMethod(req.method)) {
+                match = item.matchPath(meta.path);
+                if (match && event.req.method) {
+                    if (!item.matchMethod(event.req.method)) {
                         match = false;
-                        if (req.method.toLowerCase() === exports.MethodName.OPTIONS) {
-                            allowedMethods = smob.distinctArray(smob.merge(allowedMethods, layer.getMethods()));
-                        }
+                    }
+                    if (item.method) {
+                        allowedMethods.push(item.method);
                     }
                 }
+            } else if (isRouterInstance(item)) {
+                match = item.matchPath(meta.path);
             }
-            if (!match || !layer) {
-                setImmediate(fn, err);
-                return;
-            }
-            const layerMeta = {
-                ...meta
-            };
-            if (isLayerInstance(layer)) {
-                const output = layer.exec(path);
-                if (output) {
-                    layerMeta.params = smob.merge(output.params, layerMeta.params || {});
-                    layerMeta.mountPath = cleanDoubleSlashes(`${layerMeta.mountPath || ''}/${output.path}`);
-                }
+            if (!match) {
+                continue;
             }
+            itemMeta = cloneDispatcherMeta(meta);
             if (err) {
-                if (isLayerInstance(layer) && layer.isError()) {
-                    layer.dispatch(req, res, layerMeta, next, err);
-                    return;
-                }
-                /* istanbul ignore next */ setImmediate(next, err);
-                return;
+                itemMeta.error = err;
             }
-            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 item.dispatch(event, itemMeta);
+                if (dispatched) {
+                    return true;
                 }
-                resolve();
-            });
-        });
-    }
-    // --------------------------------------------------
-    route(path) {
-        if (typeof path === 'string' && path.length > 0) {
-            path = withLeadingSlash(path);
+            } catch (e) {
+                if (isError(e)) {
+                    err = e;
+                }
+            }
         }
-        const index = this.stack.findIndex((item)=>isRouteInstance(item) && item.path === path);
-        if (index !== -1) {
-            return this.stack[index];
+        if (err) {
+            throw err;
         }
-        const route = new Route({
-            path,
-            pathMatcher: {
-                sensitive: this.pathMatcherOptions.sensitive
+        if (event.req.method && event.req.method.toLowerCase() === exports.MethodName.OPTIONS) {
+            if (allowedMethods.indexOf(exports.MethodName.GET) !== -1) {
+                allowedMethods.push(exports.MethodName.HEAD);
             }
-        });
-        this.stack.push(route);
-        return route;
+            smob.distinctArray(allowedMethods);
+            const options = 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;
     }
-    delete(path, ...handlers) {
-        const route = this.route(path);
-        route.delete(...handlers);
+    delete(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.DELETE,
+                path
+            });
+            return this;
+        }
+        this.use({
+            ...path,
+            method: exports.MethodName.DELETE
+        });
         return this;
     }
-    get(path, ...handlers) {
-        const route = this.route(path);
-        route.get(...handlers);
+    get(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.GET,
+                path
+            });
+            return this;
+        }
+        this.use({
+            ...path,
+            method: exports.MethodName.GET
+        });
         return this;
     }
-    post(path, ...handlers) {
-        const route = this.route(path);
-        route.post(...handlers);
+    post(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.POST,
+                path
+            });
+            return this;
+        }
+        this.use({
+            ...path,
+            method: exports.MethodName.POST
+        });
         return this;
     }
-    put(path, ...handlers) {
-        const route = this.route(path);
-        route.put(...handlers);
+    put(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.PUT,
+                path
+            });
+            return this;
+        }
+        this.use({
+            ...path,
+            method: exports.MethodName.PUT
+        });
         return this;
     }
-    patch(path, ...handlers) {
-        const route = this.route(path);
-        route.patch(...handlers);
+    patch(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.PATCH,
+                path
+            });
+            return this;
+        }
+        this.use({
+            ...path,
+            method: exports.MethodName.PATCH
+        });
         return this;
     }
-    head(path, ...handlers) {
-        const route = this.route(path);
-        route.head(...handlers);
+    head(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.HEAD,
+                path
+            });
+            return this;
+        }
+        this.use({
+            ...path,
+            method: exports.MethodName.HEAD
+        });
         return this;
     }
-    options(path, ...handlers) {
-        const route = this.route(path);
-        route.options(...handlers);
+    options(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.OPTIONS,
+                path
+            });
+            return this;
+        }
+        this.use({
+            ...path,
+            method: exports.MethodName.OPTIONS
+        });
         return this;
     }
     use(...input) {
         /* istanbul ignore next */ if (input.length === 0) {
             return this;
         }
+        const modifyPath = (input)=>{
+            if (typeof input === 'string') {
+                return withLeadingSlash(input);
+            }
+            return input;
+        };
         let path;
-        if (isPath(input[0])) {
-            path = input.shift();
-        }
         for(let i = 0; i < input.length; i++){
             const item = input[i];
+            if (isPath(item)) {
+                path = modifyPath(item);
+                continue;
+            }
             if (isRouterInstance(item)) {
                 if (path) {
                     item.setPath(path);
                 }
-                item.setPathMatcherOptions(this.pathMatcherOptions);
                 this.stack.push(item);
                 continue;
             }
-            if (typeof item === 'function') {
-                this.stack.push(new Layer({
-                    path: path || '/',
-                    pathMatcher: {
-                        strict: false,
-                        end: false,
-                        sensitive: this.pathMatcherOptions.sensitive
-                    }
-                }, item));
+            if (isHandler(item)) {
+                item.path = path || modifyPath(item.path);
+                this.stack.push(new Layer(item));
             }
         }
         return this;
     }
     // --------------------------------------------------
-    constructor(ctx){
-        this['@instanceof'] = Symbol.for('Router');
+    install(plugin, context) {
+        if (isPluginInstallContext(context)) {
+            const name = context.name || plugin.name;
+            if (context.path) {
+                const router = new Router({
+                    name
+                });
+                plugin.install(router, context.options);
+                this.use(context.path, router);
+                return this;
+            }
+            plugin.install(this, context.options);
+            return this;
+        }
+        plugin.install(this, context);
+        return this;
+    }
+    uninstall(name) {
+        const index = this.stack.findIndex((el)=>isRouterInstance(el) && el.name === name);
+        if (index !== -1) {
+            this.stack.splice(index, 1);
+        }
+    }
+    // --------------------------------------------------
+    constructor(options = {}){
+        this['@instanceof'] = RouterSymbol;
         /**
      * 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.name = options.name;
+        this.setPath(options.path);
+        setRouterOptions(this.id, transformRouterOptions(options));
     }
 }
 
+exports.ErrorProxy = ErrorProxy;
 exports.Layer = Layer;
 exports.PathMatcher = PathMatcher;
-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.buildDispatcherMeta = buildDispatcherMeta;
+exports.cloneDispatcherMeta = cloneDispatcherMeta;
+exports.cloneDispatcherMetaParams = cloneDispatcherMetaParams;
+exports.coreHandler = coreHandler;
+exports.createError = createError;
+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.errorHandler = errorHandler;
 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;
@@ -1551,22 +2130,19 @@ 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.isError = isError;
+exports.isHandler = isHandler;
 exports.isLayerInstance = isLayerInstance;
-exports.isObject = isObject;
 exports.isPath = isPath;
-exports.isPromise = isPromise;
+exports.isPluginInstallContext = isPluginInstallContext;
 exports.isRequestCacheable = isRequestCacheable;
-exports.isRouteInstance = isRouteInstance;
+exports.isResponseGone = isResponseGone;
 exports.isRouterInstance = isRouterInstance;
 exports.matchRequestContentType = matchRequestContentType;
-exports.onResponseFinished = onResponseFinished;
-exports.processHandlerExecutionOutput = processHandlerExecutionOutput;
+exports.mergeDispatcherMetaParams = mergeDispatcherMetaParams;
 exports.send = send;
 exports.sendAccepted = sendAccepted;
 exports.sendCreated = sendCreated;
@@ -1574,8 +2150,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;
@@ -1584,12 +2160,12 @@ exports.setRequestMountPath = setRequestMountPath;
 exports.setRequestParam = setRequestParam;
 exports.setRequestParams = setRequestParams;
 exports.setRequestQuery = setRequestQuery;
+exports.setRequestRouterPath = setRequestRouterPath;
 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;
@@ -1600,8 +2176,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.useRequestRouterPath = useRequestRouterPath;
 //# sourceMappingURL=index.cjs.map