routup 2.0.0 → 3.0.0-alpha.1

package/dist/index.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
+var http = require('@ebec/http');
+var smob = require('smob');
 var buffer = require('buffer');
 var uncrypto = require('uncrypto');
-var smob = require('smob');
 var proxyAddr = require('proxy-addr');
 var mimeExplorer = require('mime-explorer');
 var Negotiator = require('negotiator');
@@ -11,119 +12,71 @@ var pathToRegexp = require('path-to-regexp');
 
 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';
+    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';
+    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(', '));
+class ErrorProxy extends http.HTTPError {
 }
 
-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 isError(input) {
+    return input instanceof ErrorProxy;
 }
 
-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()
-            ];
-        }
+/**
+ * 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 (Array.isArray(value)) {
-        header.push(...value);
-    } else {
-        header.push(`${value}`);
+    if (typeof input === 'string') {
+        return new ErrorProxy(input);
     }
-    header = [
-        ...new Set(header)
-    ];
-    res.setHeader(name, header.join('; '));
+    return new ErrorProxy({
+        cause: input
+    }, input);
 }
 
 /*
@@ -313,8 +266,11 @@ function buildTrustProxyFn(input) {
     return proxyAddr.compile(input || []);
 }
 
-function isInstance(input, name) {
-    return isObject(input) && input['@instanceof'] === Symbol.for(name);
+function isInstance(input, sym) {
+    if (!isObject(input)) {
+        return false;
+    }
+    return input['@instanceof'] === sym;
 }
 
 function getMimeType(type) {
@@ -395,7 +351,10 @@ function withLeadingSlash(input = '') {
     return hasLeadingSlash(input) ? input : `/${input}`;
 }
 function cleanDoubleSlashes(input = '') {
-    return input.split('://').map((str)=>str.replace(/\/{2,}/g, '/')).join('://');
+    if (input.indexOf('://') !== -1) {
+        return input.split('://').map((str)=>cleanDoubleSlashes(str)).join('://');
+    }
+    return input.replace(/\/+/g, '/');
 }
 
 function isWebBlob(input) {
@@ -405,67 +364,6 @@ function isWebResponse(input) {
     return typeof Response !== 'undefined' && input instanceof Response;
 }
 
-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 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);
-    }
-}
-
-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) {
     let body;
@@ -727,11 +625,35 @@ 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 setRequestRouterIds(req, ids) {
-    req[routerSymbol] = ids;
+function setRequestRouterPath(req, path) {
+    req[routerSymbol] = path;
 }
-function useRequestRouterIds(req) {
+function useRequestRouterPath(req) {
     if (routerSymbol in req) {
         return req[routerSymbol];
     }
@@ -744,7 +666,7 @@ function getRequestHostName(req, options) {
     if (typeof options.trustProxy !== 'undefined') {
         trustProxy = buildTrustProxyFn(options.trustProxy);
     } else {
-        trustProxy = findRouterOption('trustProxy', useRequestRouterIds(req));
+        trustProxy = findRouterOption('trustProxy', useRequestRouterPath(req));
     }
     let hostname = req.headers[exports.HeaderName.X_FORWARDED_HOST];
     if (!hostname || !req.socket.remoteAddress || !trustProxy(req.socket.remoteAddress, 0)) {
@@ -770,7 +692,7 @@ function getRequestIP(req, options) {
     if (typeof options.trustProxy !== 'undefined') {
         trustProxy = buildTrustProxyFn(options.trustProxy);
     } else {
-        trustProxy = findRouterOption('trustProxy', useRequestRouterIds(req));
+        trustProxy = findRouterOption('trustProxy', useRequestRouterPath(req));
     }
     const addrs = proxyAddr.all(req, trustProxy);
     return addrs[addrs.length - 1];
@@ -831,7 +753,7 @@ function getRequestProtocol(req, options) {
     if (typeof options.trustProxy !== 'undefined') {
         trustProxy = buildTrustProxyFn(options.trustProxy);
     } else {
-        trustProxy = findRouterOption('trustProxy', useRequestRouterIds(req));
+        trustProxy = findRouterOption('trustProxy', useRequestRouterPath(req));
     }
     let protocol = options.default;
     /* istanbul ignore next */ if (smob.hasOwnProperty(req.socket, 'encrypted') && !!req.socket.encrypted) {
@@ -899,100 +821,280 @@ function extendRequestQuery(req, key, value) {
     setRequestQuery(req, key, value);
 }
 
-async function send(res, chunk) {
-    switch(typeof chunk){
-        case 'string':
-            {
-                setResponseHeaderContentType(res, 'html', true);
-                break;
-            }
-        case 'boolean':
-        case 'number':
-        case 'object':
-            {
-                if (chunk === null) {
-                    chunk = '';
-                } else if (buffer.Buffer.isBuffer(chunk)) {
-                    setResponseHeaderContentType(res, 'bin', true);
-                } else {
-                    chunk = JSON.stringify(chunk);
-                    setResponseHeaderContentType(res, 'application/json', true);
-                }
-                break;
-            }
-    }
-    let encoding;
-    if (typeof chunk === 'string') {
-        res.setHeader(exports.HeaderName.CONTENT_ENCODING, 'utf-8');
-        appendResponseHeaderDirective(res, exports.HeaderName.CONTENT_TYPE, 'charset=utf-8');
-        encoding = 'utf-8';
-    }
-    // populate Content-Length
-    let len;
-    if (chunk !== undefined) {
-        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.Buffer.byteLength(chunk, encoding);
+function createRequest(context) {
+    let readable;
+    if (context.body) {
+        if (isWebStream(context.body)) {
+            readable = readableStream.Readable.fromWeb(context.body);
         } else {
-            // convert chunk to Buffer and calculate
-            chunk = buffer.Buffer.from(chunk, encoding);
-            encoding = undefined;
-            len = chunk.length;
+            readable = readableStream.Readable.from(context.body);
         }
-        res.setHeader(exports.HeaderName.CONTENT_LENGTH, `${len}`);
+    } else {
+        readable = new readableStream.Readable();
     }
-    if (typeof len !== 'undefined') {
-        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) {
-                res.statusCode = 304;
+    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);
         }
     }
-    // strip irrelevant headers
-    if (res.statusCode === 204 || res.statusCode === 304) {
-        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 Promise.resolve();
-    }
-    if (typeof encoding !== 'undefined') {
-        res.end(chunk, encoding);
-        return Promise.resolve();
+    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
+            ];
+        }
     }
-    res.end(chunk);
-    return Promise.resolve();
-}
-
-function sendAccepted(res, chunk) {
-    res.statusCode = 202;
-    res.statusMessage = 'Accepted';
-    return send(res, chunk);
-}
-
-function sendCreated(res, chunk) {
+    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 = [
+        '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('; '));
+}
+
+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 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);
+    }
+}
+
+async function send(res, chunk) {
+    switch(typeof chunk){
+        case 'string':
+            {
+                setResponseHeaderContentType(res, 'html', true);
+                break;
+            }
+        case 'boolean':
+        case 'number':
+        case 'object':
+            {
+                if (buffer.Buffer.isBuffer(chunk)) {
+                    setResponseHeaderContentType(res, 'bin', true);
+                } else if (chunk !== null) {
+                    chunk = JSON.stringify(chunk);
+                    setResponseHeaderContentType(res, 'application/json', true);
+                }
+                break;
+            }
+    }
+    let encoding;
+    if (typeof chunk === 'string') {
+        res.setHeader(exports.HeaderName.CONTENT_ENCODING, 'utf-8');
+        appendResponseHeaderDirective(res, exports.HeaderName.CONTENT_TYPE, 'charset=utf-8');
+        encoding = 'utf-8';
+    }
+    // populate Content-Length
+    let len;
+    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.Buffer.byteLength(chunk, encoding);
+        } else {
+            // convert chunk to Buffer and calculate
+            chunk = buffer.Buffer.from(chunk, encoding);
+            encoding = undefined;
+            len = chunk.length;
+        }
+        res.setHeader(exports.HeaderName.CONTENT_LENGTH, `${len}`);
+    }
+    if (typeof len !== 'undefined') {
+        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) {
+                res.statusCode = 304;
+            }
+        }
+    }
+    // strip irrelevant headers
+    if (res.statusCode === 204 || res.statusCode === 304) {
+        res.removeHeader(exports.HeaderName.CONTENT_TYPE);
+        res.removeHeader(exports.HeaderName.CONTENT_LENGTH);
+        res.removeHeader(exports.HeaderName.TRANSFER_ENCODING);
+    }
+    // alter headers for 205
+    if (res.statusCode === 205) {
+        res.setHeader(exports.HeaderName.CONTENT_LENGTH, 0);
+        res.removeHeader(exports.HeaderName.TRANSFER_ENCODING);
+    }
+    if (isResponseGone(res)) {
+        return Promise.resolve();
+    }
+    if (res.req.method === 'HEAD') {
+        // skip body for HEAD
+        res.end();
+        return Promise.resolve();
+    }
+    if (typeof chunk === 'undefined' || chunk === null) {
+        res.end();
+        return Promise.resolve();
+    }
+    if (typeof encoding !== 'undefined') {
+        res.end(chunk, encoding);
+        return Promise.resolve();
+    }
+    res.end(chunk);
+    return Promise.resolve();
+}
+
+function sendAccepted(res, chunk) {
+    res.statusCode = 202;
+    res.statusMessage = 'Accepted';
+    return send(res, chunk);
+}
+
+function sendCreated(res, chunk) {
     res.statusCode = 201;
     res.statusMessage = 'Created';
     return send(res, chunk);
@@ -1303,99 +1405,90 @@ function createResponse(request) {
     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 buildDispatcherMeta(input) {
+    return {
+        mountPath: input.mountPath || '/',
+        params: input.params || {},
+        path: input.path || '/',
+        routerPath: []
     };
 }
-
-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();
+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 headers = context.headers || {};
-    const rawHeaders = [];
-    let keys = Object.keys(headers);
+    const keys = Object.keys(input);
+    if (keys.length === 0) {
+        return {};
+    }
+    const output = {};
     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);
-        }
+        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);
+    if (keys.length === 0) {
+        return t1;
     }
-    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
-            ];
-        }
+        t1[keys[i]] = t2[keys[i]];
     }
-    Object.defineProperty(readable, 'connection', {
-        get () {
-            return {};
+    return t1;
+}
+
+async function dispatchNodeRequest(router, req, res) {
+    try {
+        const dispatched = await router.dispatch({
+            req,
+            res
+        }, buildDispatcherMeta({
+            path: useRequestPath(req)
+        }));
+        if (dispatched) {
+            return;
         }
-    });
-    Object.defineProperty(readable, 'socket', {
-        get () {
-            return {};
+        if (!isResponseGone(res)) {
+            res.statusCode = 404;
+            res.end();
         }
-    });
-    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;
+    } 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();
         }
-    });
-    return readable;
+    }
+}
+function createNodeDispatcher(router) {
+    return (req, res)=>{
+        // eslint-disable-next-line no-void
+        void dispatchNodeRequest(router, req, res);
+    };
 }
 
 async function dispatchRawRequest(router, request, options = {}) {
@@ -1420,33 +1513,38 @@ async function dispatchRawRequest(router, request, options = {}) {
         }
         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 {
-                status: res.statusCode,
-                statusMessage: res.statusMessage,
-                headers: getHeaders(),
-                body: res.body
-            };
+            return createRawResponse();
         }
-        return {
-            status: 404,
-            headers: getHeaders(),
-            body: res.body
-        };
+        return createRawResponse({
+            status: 404
+        });
     } catch (e) {
         if (options.throwOnError) {
             throw e;
         }
-        return {
-            status: 500,
-            headers: getHeaders(),
-            body: res.body
-        };
+        if (isError(e)) {
+            return createRawResponse({
+                status: e.statusCode,
+                statusMessage: e.statusMessage
+            });
+        }
+        return createRawResponse({
+            status: 500
+        });
     }
 }
 function createRawDispatcher(router) {
@@ -1481,54 +1579,40 @@ function createWebDispatcher(router) {
     return async (request)=>dispatchWebRequest(router, request);
 }
 
-function cloneDispatcherMeta(input) {
-    if (!input) {
-        return {};
+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 {
-        path: input.path,
-        mountPath: input.mountPath,
-        error: input.error,
-        routerIds: [
-            ...input.routerIds || []
-        ],
-        params: cloneDispatcherMetaParams(input.params)
+        type: exports.HandlerType.CORE,
+        ...input
     };
 }
-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]];
+
+function errorHandler(input) {
+    if (typeof input === 'function') {
+        return {
+            type: exports.HandlerType.ERROR,
+            fn: input
+        };
     }
-    return t1;
+    return {
+        type: exports.HandlerType.ERROR,
+        ...input
+    };
 }
 
-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 isHandler(input) {
+    return isObject(input) && typeof input.fn === 'function' && typeof input.type === 'string';
 }
 
 function decodeParam(val) {
@@ -1539,56 +1623,46 @@ 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);
     }
 }
 
@@ -1596,27 +1670,33 @@ function isPath(input) {
     return typeof input === 'string' || input instanceof RegExp;
 }
 
+const LayerSymbol = Symbol.for('Layer');
+
 class Layer {
     // --------------------------------------------------
-    isError() {
-        return this.fn.length === 4;
+    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) {
-        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);
+        if (this.pathMatcher) {
+            const pathMatch = this.pathMatcher.exec(meta.path);
+            if (pathMatch) {
+                meta.params = mergeDispatcherMetaParams(meta.params, pathMatch.params);
+            }
         }
-        const timeout = findRouterOption('timeout', meta.routerIds);
+        setRequestParams(event.req, meta.params);
+        setRequestMountPath(event.req, meta.mountPath);
+        setRequestRouterPath(event.req, meta.routerPath);
         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);
             };
@@ -1636,30 +1716,23 @@ class Layer {
             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);
-            }
+            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 (meta.error) {
-                    output = this.fn(meta.error, event.req, event.res, onNext);
+                if (this.handler.type === exports.HandlerType.ERROR) {
+                    if (meta.error) {
+                        output = this.handler.fn(meta.error, event.req, event.res, onNext);
+                    }
                 } else {
-                    output = this.fn(event.req, event.res, onNext);
+                    output = this.handler.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;
@@ -1672,7 +1745,7 @@ class Layer {
     }
     sendOutput(res, input) {
         if (input instanceof Error) {
-            return Promise.reject(input);
+            return Promise.reject(createError(input));
         }
         if (isStream(input)) {
             return sendStream(res, input);
@@ -1687,143 +1760,45 @@ class Layer {
     }
     // --------------------------------------------------
     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) {
-    if (input instanceof Layer) {
-        return true;
-    }
-    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;
-    }
-    // --------------------------------------------------
-    async dispatch(event, meta) {
-        /* istanbul ignore next */ if (!event.req.method) {
-            return false;
-        }
-        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') {
-            return false;
-        }
-        const layerMeta = cloneDispatcherMeta(meta);
-        const output = this.pathMatcher.exec(meta.path);
-        if (output) {
-            layerMeta.params = mergeDispatcherMetaParams(layerMeta.params, output.params);
-        }
-        let err;
-        for(let i = 0; i < layers.length; i++){
-            const layer = layers[i];
-            if (err && !layer.isError()) {
-                continue;
-            }
-            try {
-                const dispatched = await layer.dispatch(event, {
-                    ...layerMeta
-                });
-                if (dispatched) {
-                    return true;
-                }
-            } catch (e) {
-                if (e instanceof Error) {
-                    err = e;
-                }
-            }
-        }
-        if (err) {
-            throw err;
-        }
+function isPluginInstallContext(input) {
+    if (!isObject(input) || !isObject(input.options)) {
         return false;
     }
-    // --------------------------------------------------
-    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);
-    }
-    options(...handlers) {
-        return this.register(exports.MethodName.OPTIONS, ...handlers);
-    }
-    // --------------------------------------------------
-    isStrictPath() {
-        return typeof this.path !== 'string' || this.path !== '/' && this.path.length !== 0;
-    }
-    // --------------------------------------------------
-    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);
-    }
-}
-
-function isRouteInstance(input) {
-    if (input instanceof Route) {
-        return true;
+    if (typeof input.name !== 'undefined' && typeof input.name !== 'string') {
+        return false;
     }
-    return isInstance(input, 'Route');
+    return typeof input.path === 'undefined' || isPath(input.path);
 }
 
 function transformRouterOptions(input) {
@@ -1836,17 +1811,16 @@ function transformRouterOptions(input) {
     return input;
 }
 
+const RouterSymbol = Symbol.for('Router');
+
 let nextId = 0;
 function generateRouterID() {
     return ++nextId;
 }
-
 function isRouterInstance(input) {
-    if (input instanceof Router) {
-        return true;
-    }
-    return isInstance(input, 'Router');
+    return isInstance(input, RouterSymbol);
 }
+
 class Router {
     // --------------------------------------------------
     setPath(value) {
@@ -1860,9 +1834,7 @@ class Router {
             path = value;
         }
         this.pathMatcher = new PathMatcher(path, {
-            end: false,
-            sensitive: false,
-            ...this.pathMatcherOptions ? this.pathMatcherOptions : {}
+            end: false
         });
     }
     // --------------------------------------------------
@@ -1873,78 +1845,60 @@ class Router {
         return true;
     }
     // --------------------------------------------------
-    async dispatch(event, meta = {}) {
+    async dispatch(event, meta) {
         const allowedMethods = [];
-        let path = meta.path || useRequestPath(event.req);
         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.routerIds) {
-            meta.routerIds.push(this.id);
-        } else {
-            meta.routerIds = [
-                this.id
-            ];
-        }
-        if (!meta.mountPath) {
-            meta.mountPath = '/';
-        }
+        meta.routerPath.push(this.id);
         let err;
-        let layer;
+        let item;
+        let itemMeta;
         let match = false;
         for(let i = 0; i < this.stack.length; i++){
-            layer = this.stack[i];
-            if (layer instanceof Layer) {
-                if (!layer.isError() && err) {
+            item = this.stack[i];
+            if (isLayerInstance(item)) {
+                if (item.type !== exports.HandlerType.ERROR && err) {
                     continue;
                 }
-                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());
+                match = item.matchPath(meta.path);
+                if (match && event.req.method) {
+                    if (!item.matchMethod(event.req.method)) {
+                        match = false;
+                    }
+                    if (item.method) {
+                        allowedMethods.push(item.method);
                     }
                 }
+            } else if (isRouterInstance(item)) {
+                match = item.matchPath(meta.path);
             }
             if (!match) {
                 continue;
             }
-            const layerMeta = cloneDispatcherMeta(meta);
-            if (isLayerInstance(layer)) {
-                const output = layer.exec(path);
-                if (output) {
-                    layerMeta.params = mergeDispatcherMetaParams(layerMeta.params, output.params);
-                    layerMeta.mountPath = cleanDoubleSlashes(`${layerMeta.mountPath || ''}/${output.path}`);
-                }
-                if (err) {
-                    layerMeta.error = err;
-                }
-            } else if (err) {
-                continue;
+            itemMeta = cloneDispatcherMeta(meta);
+            if (err) {
+                itemMeta.error = err;
             }
             try {
-                const dispatched = await layer.dispatch(event, layerMeta);
+                const dispatched = await item.dispatch(event, itemMeta);
                 if (dispatched) {
                     return true;
                 }
             } catch (e) {
-                if (e instanceof Error) {
+                if (isError(e)) {
                     err = e;
                 }
             }
@@ -1953,7 +1907,11 @@ class Router {
             throw err;
         }
         if (event.req.method && event.req.method.toLowerCase() === exports.MethodName.OPTIONS) {
-            const options = smob.distinctArray(allowedMethods).map((key)=>key.toUpperCase()).join(',');
+            if (allowedMethods.indexOf(exports.MethodName.GET) !== -1) {
+                allowedMethods.push(exports.MethodName.HEAD);
+            }
+            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);
@@ -1962,71 +1920,128 @@ class Router {
         }
         return false;
     }
-    // --------------------------------------------------
-    route(path) {
-        if (typeof path === 'string' && path.length > 0) {
-            path = withLeadingSlash(path);
+    delete(path, handler) {
+        if (isPath(path)) {
+            this.use({
+                ...handler,
+                method: exports.MethodName.DELETE,
+                path
+            });
+            return this;
         }
-        const index = this.stack.findIndex((item)=>isRouteInstance(item) && item.path === path);
-        if (index !== -1) {
-            return this.stack[index];
-        }
-        const route = new Route({
-            path,
-            pathMatcher: {
-                ...this.pathMatcherOptions ? {
-                    sensitive: this.pathMatcherOptions.sensitive
-                } : {}
-            }
+        this.use({
+            ...path,
+            method: exports.MethodName.DELETE
         });
-        this.stack.push(route);
-        return route;
-    }
-    delete(path, ...handlers) {
-        const route = this.route(path);
-        route.delete(...handlers);
         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);
@@ -2034,44 +2049,63 @@ class Router {
                 this.stack.push(item);
                 continue;
             }
-            if (typeof item === 'function') {
-                this.stack.push(new Layer({
-                    path: path || '/',
-                    pathMatcher: {
-                        strict: false,
-                        end: false,
-                        ...this.pathMatcherOptions ? {
-                            sensitive: this.pathMatcherOptions.sensitive
-                        } : {}
-                    }
-                }, item));
+            if (isHandler(item)) {
+                item.path = path || modifyPath(item.path);
+                this.stack.push(new Layer(item));
             }
         }
         return this;
     }
     // --------------------------------------------------
+    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'] = Symbol.for('Router');
+        this['@instanceof'] = RouterSymbol;
         /**
      * Array of mounted layers, routes & routers.
      *
      * @protected
      */ this.stack = [];
         this.id = generateRouterID();
-        this.pathMatcherOptions = options.pathMatcher;
+        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.buildDispatcherMeta = buildDispatcherMeta;
 exports.cloneDispatcherMeta = cloneDispatcherMeta;
 exports.cloneDispatcherMetaParams = cloneDispatcherMetaParams;
+exports.coreHandler = coreHandler;
+exports.createError = createError;
 exports.createNodeDispatcher = createNodeDispatcher;
 exports.createRawDispatcher = createRawDispatcher;
 exports.createRequest = createRequest;
@@ -2080,6 +2114,7 @@ exports.createWebDispatcher = createWebDispatcher;
 exports.dispatchNodeRequest = dispatchNodeRequest;
 exports.dispatchRawRequest = dispatchRawRequest;
 exports.dispatchWebRequest = dispatchWebRequest;
+exports.errorHandler = errorHandler;
 exports.extendRequestBody = extendRequestBody;
 exports.extendRequestCookies = extendRequestCookies;
 exports.extendRequestQuery = extendRequestQuery;
@@ -2098,11 +2133,13 @@ exports.getRequestProtocol = getRequestProtocol;
 exports.hasRequestBody = hasRequestBody;
 exports.hasRequestCookies = hasRequestCookies;
 exports.hasRequestQuery = hasRequestQuery;
+exports.isError = isError;
+exports.isHandler = isHandler;
 exports.isLayerInstance = isLayerInstance;
 exports.isPath = isPath;
+exports.isPluginInstallContext = isPluginInstallContext;
 exports.isRequestCacheable = isRequestCacheable;
 exports.isResponseGone = isResponseGone;
-exports.isRouteInstance = isRouteInstance;
 exports.isRouterInstance = isRouterInstance;
 exports.matchRequestContentType = matchRequestContentType;
 exports.mergeDispatcherMetaParams = mergeDispatcherMetaParams;
@@ -2123,7 +2160,7 @@ exports.setRequestMountPath = setRequestMountPath;
 exports.setRequestParam = setRequestParam;
 exports.setRequestParams = setRequestParams;
 exports.setRequestQuery = setRequestQuery;
-exports.setRequestRouterIds = setRequestRouterIds;
+exports.setRequestRouterPath = setRequestRouterPath;
 exports.setResponseCacheHeaders = setResponseCacheHeaders;
 exports.setResponseContentTypeByFileName = setResponseContentTypeByFileName;
 exports.setResponseHeaderAttachment = setResponseHeaderAttachment;
@@ -2139,5 +2176,5 @@ exports.useRequestParam = useRequestParam;
 exports.useRequestParams = useRequestParams;
 exports.useRequestPath = useRequestPath;
 exports.useRequestQuery = useRequestQuery;
-exports.useRequestRouterIds = useRequestRouterIds;
+exports.useRequestRouterPath = useRequestRouterPath;
 //# sourceMappingURL=index.cjs.map