routup 0.11.0 → 0.13.0

package/README.md

@@ -62,16 +62,17 @@ router.listen(3000);
 According to the fact that routup is a minimalistic framework, it depends on plugins to cover some 
 typically http framework functions, which are not integrated in the main package.
 
-| Name                                                           | Description                                                            |
-|----------------------------------------------------------------|------------------------------------------------------------------------|
-| [body](https://www.npmjs.com/package/@routup/body)             | Read and parse the request body.                                       |
-| [cookie](https://www.npmjs.com/package/@routup/cookie)         | Read and parse request cookies and serialize cookies for the response. |
-| [decorators](https://www.npmjs.com/package/@routup/decorators) | Create request handlers with class-, method- & parameter-decorators.   |
-| [prometheus](https://www.npmjs.com/package/@routup/prometheus) | Collect and serve metrics for prometheus.                              |
-| [query](https://www.npmjs.com/package/@routup/query)           | Read and parse the query string of the request url.                    |
-| [rate-limit](https://www.npmjs.com/package/@routup/rate-limit) | Rate limit incoming requests.                                          |
-| [static](https://www.npmjs.com/package/@routup/static)         | Serve static files from a directory.                                   |
-| [swagger](https://www.npmjs.com/package/@routup/swagger)       | Serve generated docs from URL or based on a JSON file.                 |
+| Name                                                                       | Description                                                            |
+|----------------------------------------------------------------------------|------------------------------------------------------------------------|
+| [body](https://www.npmjs.com/package/@routup/body)                         | Read and parse the request body.                                       |
+| [cookie](https://www.npmjs.com/package/@routup/cookie)                     | Read and parse request cookies and serialize cookies for the response. |
+| [decorators](https://www.npmjs.com/package/@routup/decorators)             | Create request handlers with class-, method- & parameter-decorators.   |
+| [prometheus](https://www.npmjs.com/package/@routup/prometheus)             | Collect and serve metrics for prometheus.                              |
+| [query](https://www.npmjs.com/package/@routup/query)                       | Read and parse the query string of the request url.                    |
+| [rate-limit](https://www.npmjs.com/package/@routup/rate-limit)             | Rate limit incoming requests.                                          |
+| [rate-limit-redis](https://www.npmjs.com/package/@routup/rate-limit-redis) | Redis adapter for the rate-limit plugin.                               |
+| [static](https://www.npmjs.com/package/@routup/static)                     | Serve static files from a directory.                                   |
+| [swagger](https://www.npmjs.com/package/@routup/swagger)                   | Serve generated docs from URL or based on a JSON file.                 |
 
 ## License
 

package/dist/handler/index.d.ts

@@ -1,2 +1,2 @@
-export * from './utils';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/handler/utils.d.ts

@@ -1,3 +1,3 @@
-import { Next, Response } from '@routup/core';
-export declare function processHandlerExecutionOutput(res: Response, next: Next, output?: unknown): void;
+import { Next, Response } from '@routup/core';
+export declare function processHandlerExecutionOutput(res: Response, next: Next, output?: unknown): void;
 //# sourceMappingURL=utils.d.ts.map

package/dist/index.cjs

@@ -1,2 +1,580 @@
-"use strict";var a=require("@routup/core"),f=require("smob"),l=require("@ebec/http"),k=require("path-to-regexp"),D=require("http");function g(r,t){return typeof r=="object"&&r!==null&&r["@instanceof"]===Symbol.for(t)}function b(r){return typeof r=="string"||r instanceof RegExp}function v(r){return f.isObject(r)&&(r instanceof Promise||typeof r.then=="function")}function T(r,t,e){const s=setTimeout(()=>{r.statusCode=l.GatewayTimeoutErrorOptions.statusCode,r.statusMessage=l.GatewayTimeoutErrorOptions.message,r.end()},t);r.once("close",()=>{clearTimeout(s),typeof e=="function"&&e()}),r.once("error",h=>{clearTimeout(s),typeof e=="function"&&e(h)})}function I(r,t,e){if(v(e)){e.then(s=>(typeof s<"u"&&a.send(r,s),s)).catch(t);return}typeof e<"u"&&a.send(r,e)}function S(r){return typeof r!="string"||r.length===0?r:decodeURIComponent(r)}class M{constructor(t,e){this.regexpKeys=[],this.path=t,this.regexpOptions=e||{},t instanceof RegExp?this.regexp=t:this.regexp=k.pathToRegexp(t,this.regexpKeys,e)}test(t){return this.path==="/"&&this.regexpOptions.end===!1?!0:this.regexp.test(t)}exec(t){let e=null;if(this.path==="/"&&this.regexpOptions.end===!1)return{path:"/",params:{}};if(e=this.regexp.exec(t),!e)return;if(this.path instanceof RegExp)return{path:t,params:{0:S(e[0])}};const s={};for(let h=1;h<e.length;h++){const p=this.regexpKeys[h-1].name,i=S(e[h]);typeof i<"u"&&(s[p]=i)}return{path:e[0],params:s}}}class E{constructor(t,e){this["@instanceof"]=Symbol.for("Layer"),this.pathMatcher=new M(t.path,t.pathMatcher),this.fn=e}isError(){return this.fn.length===4}dispatch(t,e,s,h,p){if(a.setRequestParams(t,s.params||{}),a.setRequestMountPath(t,s.mountPath||"/"),typeof p<"u"){if(this.fn.length===4){try{this.fn(p,t,e,h)}catch(i){i instanceof Error?h(i):h(new l.BadRequestError({message:"The request could not be processed by the error handler."}))}return}h(p);return}if(this.fn.length>3){h();return}try{const i=this.fn(t,e,h);I(e,h,i)}catch(i){i instanceof Error?h(i):h(new l.BadRequestError({message:"The request could not be processed by the handler."}))}}matchPath(t){return this.pathMatcher.test(t)}exec(t){return this.pathMatcher.exec(t)}}function O(r){return g(r,"Layer")}var $=Object.defineProperty,L=Object.getOwnPropertySymbols,G=Object.prototype.hasOwnProperty,N=Object.prototype.propertyIsEnumerable,q=(r,t,e)=>t in r?$(r,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):r[t]=e,w=(r,t)=>{for(var e in t||(t={}))G.call(t,e)&&q(r,e,t[e]);if(L)for(var e of L(t))N.call(t,e)&&q(r,e,t[e]);return r};class j{constructor(t){this["@instanceof"]=Symbol.for("Route"),this.layers={},this.path=t.path,this.pathMatcherOptions=w({end:!0,strict:this.isStrictPath()},t.pathMatcher),this.pathMatcher=new M(this.path,this.pathMatcherOptions)}matchPath(t){return this.pathMatcher.test(t)}matchMethod(t){let e=t.toLowerCase();return e===a.Method.HEAD&&!f.hasOwnProperty(this.layers,e)&&(e=a.Method.GET),Object.prototype.hasOwnProperty.call(this.layers,e)}getMethods(){const t=Object.keys(this.layers);return f.hasOwnProperty(this.layers,a.Method.GET)&&!f.hasOwnProperty(this.layers,a.Method.HEAD)&&t.push(a.Method.HEAD),t}dispatch(t,e,s,h){if(!t.method){h();return}let p=t.method.toLowerCase();p===a.Method.HEAD&&!f.hasOwnProperty(this.layers,p)&&(p=a.Method.GET);const i=this.layers[p];if(typeof i>"u"||i.length===0||typeof s.path>"u"){h();return}const y=w({},s),c=this.pathMatcher.exec(s.path);c&&(y.params=f.merge({},s.params||{},c.params));let d=-1;const o=n=>{if(d++,d>=i.length){setImmediate(h,n);return}const u=i[d];if(n&&!u.isError()){o(n);return}u.dispatch(t,e,w({},y),o)};o()}register(t,...e){this.layers[t]=[];for(let s=0;s<e.length;s++){const h=new E({path:this.path,pathMatcher:this.pathMatcherOptions},e[s]);this.layers[t].push(h)}}get(...t){return this.register(a.Method.GET,...t)}post(...t){return this.register(a.Method.POST,...t)}put(...t){return this.register(a.Method.PUT,...t)}patch(...t){return this.register(a.Method.PATCH,...t)}delete(...t){return this.register(a.Method.DELETE,...t)}head(...t){return this.register(a.Method.HEAD,...t)}options(...t){return this.register(a.Method.OPTIONS,...t)}isStrictPath(){return typeof this.path!="string"||this.path!=="/"&&this.path.length!==0}}function R(r){return g(r,"Route")}var B=Object.defineProperty,C=Object.getOwnPropertySymbols,K=Object.prototype.hasOwnProperty,U=Object.prototype.propertyIsEnumerable,H=(r,t,e)=>t in r?B(r,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):r[t]=e,A=(r,t)=>{for(var e in t||(t={}))K.call(t,e)&&H(r,e,t[e]);if(C)for(var e of C(t))U.call(t,e)&&H(r,e,t[e]);return r};function x(r){return g(r,"Router")}class F{constructor(t){this["@instanceof"]=Symbol.for("Router"),this.stack=[],t=t||{},this.pathMatcherOptions=A({end:!1,sensitive:!0},t.pathMatcher||{}),this.timeout=t.timeout,this.setPath(t.path||"/")}setPathMatcherOptions(t){this.pathMatcherOptions=t,this.pathMatcher&&(this.pathMatcher.regexpOptions=this.pathMatcherOptions)}setPath(t){if(t==="/"||!b(t)){this.path="/";return}typeof t=="string"?this.path=a.withLeadingSlash(a.withoutTrailingSlash(`${t}`)):this.path=t,this.pathMatcher=new M(this.path,this.pathMatcherOptions)}createListener(){return this.isRoot=!0,(t,e)=>{this.dispatch(t,e)}}listen(t){return D.createServer(this.createListener()).listen(t)}matchPath(t){return this.pathMatcher?this.pathMatcher.test(t):!0}dispatch(t,e,s,h){let p=-1;s=s||{};let i=[];this.isRoot&&typeof this.timeout=="number"&&T(e,this.timeout,h);const y=o=>{if(!this.isRoot){typeof h<"u"&&setImmediate(()=>h(o));return}if(typeof o<"u"){e.statusCode=l.BadRequestErrorOptions.statusCode,e.statusMessage=l.BadRequestErrorOptions.message,e.end();return}if(t.method&&t.method.toLowerCase()===a.Method.OPTIONS){const n=i.map(u=>u.toUpperCase()).join(",");e.setHeader(a.HeaderName.ALLOW,n),a.send(e,n);return}e.statusCode=l.NotFoundErrorOptions.statusCode,e.end()};let c=s.path||a.useRequestPath(t);if(this.pathMatcher){const o=this.pathMatcher.exec(c);typeof o<"u"&&(s.mountPath=a.cleanDoubleSlashes(`${s.mountPath||""}/${o.path}`),c===o.path?c="/":c=a.withLeadingSlash(c.substring(o.path.length)),s.params=f.merge(s.params||{},o.params))}s.path=c,s.mountPath||(s.mountPath="/");const d=o=>{if(p>=this.stack.length){setImmediate(y,o);return}let n,u=!1;for(;!u&&p<this.stack.length;){if(p++,n=this.stack[p],O(n)){if(!n.isError()&&o)continue;u=n.matchPath(c)}x(n)&&(u=n.matchPath(c)),R(n)&&(u=n.matchPath(c),t.method&&!n.matchMethod(t.method)&&(u=!1,t.method.toLowerCase()===a.Method.OPTIONS&&(i=f.mergeArrays(i,n.getMethods(),!0))))}if(!u||!n){setImmediate(y,o);return}const m=A({},s);if(O(n)){const P=n.exec(c);P&&(m.params=f.merge(P.params,m.params||{}),m.mountPath=a.cleanDoubleSlashes(`${m.mountPath||""}/${P.path}`))}if(o){if(O(n)&&n.isError()){n.dispatch(t,e,m,d,o);return}setImmediate(d,o);return}n.dispatch(t,e,m,d)};d()}dispatchAsync(t,e){return new Promise((s,h)=>{this.dispatch(t,e,{},p=>{if(p){h(p);return}s()})})}route(t){typeof t=="string"&&t.length>0&&(t=a.withLeadingSlash(t));const e=this.stack.findIndex(h=>R(h)&&h.path===t);if(e!==-1)return this.stack[e];const s=new j({path:t,pathMatcher:{sensitive:this.pathMatcherOptions.sensitive}});return this.stack.push(s),s}delete(t,...e){return this.route(t).delete(...e),this}get(t,...e){return this.route(t).get(...e),this}post(t,...e){return this.route(t).post(...e),this}put(t,...e){return this.route(t).put(...e),this}patch(t,...e){return this.route(t).patch(...e),this}head(t,...e){return this.route(t).head(...e),this}options(t,...e){return this.route(t).options(...e),this}use(...t){if(t.length===0)return this;let e;b(t[0])&&(e=t.shift());for(let s=0;s<t.length;s++){const h=t[s];if(x(h)){e&&h.setPath(e),h.setPathMatcherOptions(this.pathMatcherOptions),this.stack.push(h);continue}typeof h=="function"&&this.stack.push(new E({path:e||"/",pathMatcher:{strict:!1,end:!1,sensitive:this.pathMatcherOptions.sensitive}},h))}return this}}exports.Layer=E,exports.PathMatcher=M,exports.Route=j,exports.Router=F,exports.createRequestTimeout=T,exports.isInstance=g,exports.isLayerInstance=O,exports.isPath=b,exports.isPromise=v,exports.isRouteInstance=R,exports.isRouterInstance=x,exports.processHandlerExecutionOutput=I,Object.keys(a).forEach(function(r){r!=="default"&&!exports.hasOwnProperty(r)&&Object.defineProperty(exports,r,{enumerable:!0,get:function(){return a[r]}})});
+'use strict';
+
+var core = require('@routup/core');
+var smob = require('smob');
+var http = require('@ebec/http');
+var pathToRegexp = require('path-to-regexp');
+var node_http = require('node:http');
+
+/*
+ * Copyright (c) 2022-2022.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function isInstance(input, name) {
+    return typeof input === 'object' && input !== null && input['@instanceof'] === Symbol.for(name);
+}
+
+/*
+ * Copyright (c) 2022.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function isPath(input) {
+    return typeof input === 'string' || input instanceof RegExp;
+}
+
+function isPromise(p) {
+    return smob.isObject(p) && (p instanceof Promise || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    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);
+        if (typeof done === 'function') {
+            done();
+        }
+    });
+    res.once('error', (e)=>{
+        clearTimeout(instance);
+        if (typeof done === 'function') {
+            done(e);
+        }
+    });
+}
+
+function processHandlerExecutionOutput(res, next, output) {
+    if (isPromise(output)) {
+        output.then((r)=>{
+            if (typeof r !== 'undefined') {
+                core.send(res, r);
+            }
+            return r;
+        }).catch(next);
+        return;
+    }
+    if (typeof output !== 'undefined') {
+        core.send(res, output);
+    }
+}
+
+function decodeParam(val) {
+    /* istanbul ignore next */ if (typeof val !== 'string' || val.length === 0) {
+        return val;
+    }
+    return decodeURIComponent(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) {
+            return {
+                path: '/',
+                params: {}
+            };
+        }
+        match = this.regexp.exec(path);
+        if (!match) {
+            return undefined;
+        }
+        if (this.path instanceof RegExp) {
+            return {
+                path,
+                params: {
+                    0: decodeParam(match[0])
+                }
+            };
+        }
+        const output = {};
+        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;
+            }
+        }
+        return {
+            path: match[0],
+            params: output
+        };
+    }
+    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);
+        }
+    }
+}
+
+class Layer {
+    // --------------------------------------------------
+    isError() {
+        return this.fn.length === 4;
+    }
+    dispatch(req, res, meta, next, err) {
+        core.setRequestParams(req, meta.params || {});
+        core.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.'
+                        }));
+                    }
+                }
+                return;
+            }
+            /* istanbul ignore next */ next(err);
+            /* istanbul ignore next */ return;
+        }
+        /* istanbul ignore next */ if (this.fn.length > 3) {
+            next();
+            return;
+        }
+        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.'
+                }));
+            }
+        }
+    }
+    // --------------------------------------------------
+    matchPath(path) {
+        return this.pathMatcher.test(path);
+    }
+    exec(path) {
+        return this.pathMatcher.exec(path);
+    }
+    // --------------------------------------------------
+    constructor(options, fn){
+        this['@instanceof'] = Symbol.for('Layer');
+        this.pathMatcher = new PathMatcher(options.path, options.pathMatcher);
+        this.fn = fn;
+    }
+}
+
+function isLayerInstance(input) {
+    return isInstance(input, 'Layer');
+}
+
+class Route {
+    // --------------------------------------------------
+    matchPath(path) {
+        return this.pathMatcher.test(path);
+    }
+    matchMethod(method) {
+        let name = method.toLowerCase();
+        if (name === core.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
+            name = core.Method.GET;
+        }
+        return Object.prototype.hasOwnProperty.call(this.layers, name);
+    }
+    // --------------------------------------------------
+    getMethods() {
+        const keys = Object.keys(this.layers);
+        if (smob.hasOwnProperty(this.layers, core.Method.GET) && !smob.hasOwnProperty(this.layers, core.Method.HEAD)) {
+            keys.push(core.Method.HEAD);
+        }
+        return keys;
+    }
+    // --------------------------------------------------
+    dispatch(req, res, meta, done) {
+        /* istanbul ignore next */ if (!req.method) {
+            done();
+            return;
+        }
+        let name = req.method.toLowerCase();
+        if (name === core.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
+            name = core.Method.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(core.Method.GET, ...handlers);
+    }
+    post(...handlers) {
+        return this.register(core.Method.POST, ...handlers);
+    }
+    put(...handlers) {
+        return this.register(core.Method.PUT, ...handlers);
+    }
+    patch(...handlers) {
+        return this.register(core.Method.PATCH, ...handlers);
+    }
+    delete(...handlers) {
+        return this.register(core.Method.DELETE, ...handlers);
+    }
+    head(...handlers) {
+        return this.register(core.Method.HEAD, ...handlers);
+    }
+    options(...handlers) {
+        return this.register(core.Method.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) {
+    return isInstance(input, 'Route');
+}
+
+function isRouterInstance(input) {
+    return isInstance(input, 'Router');
+}
+class Router {
+    // --------------------------------------------------
+    setPathMatcherOptions(input) {
+        this.pathMatcherOptions = input;
+        if (this.pathMatcher) {
+            this.pathMatcher.regexpOptions = this.pathMatcherOptions;
+        }
+    }
+    setPath(value) {
+        if (value === '/' || !isPath(value)) {
+            this.path = '/';
+            return;
+        }
+        if (typeof value === 'string') {
+            this.path = core.withLeadingSlash(core.withoutTrailingSlash(`${value}`));
+        } else {
+            this.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);
+    }
+    // --------------------------------------------------
+    matchPath(path) {
+        if (this.pathMatcher) {
+            return this.pathMatcher.test(path);
+        }
+        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 = http.BadRequestErrorOptions.statusCode;
+                res.statusMessage = http.BadRequestErrorOptions.message;
+                res.end();
+                return;
+            }
+            if (req.method && req.method.toLowerCase() === core.Method.OPTIONS) {
+                const options = allowedMethods.map((key)=>key.toUpperCase()).join(',');
+                res.setHeader(core.HeaderName.ALLOW, options);
+                core.send(res, options);
+                return;
+            }
+            res.statusCode = http.NotFoundErrorOptions.statusCode;
+            res.end();
+        };
+        let path = meta.path || core.useRequestPath(req);
+        if (this.pathMatcher) {
+            const output = this.pathMatcher.exec(path);
+            if (typeof output !== 'undefined') {
+                meta.mountPath = core.cleanDoubleSlashes(`${meta.mountPath || ''}/${output.path}`);
+                if (path === output.path) {
+                    path = '/';
+                } else {
+                    path = core.withLeadingSlash(path.substring(output.path.length));
+                }
+                meta.params = smob.merge(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);
+                }
+                if (isRouterInstance(layer)) {
+                    match = layer.matchPath(path);
+                }
+                if (isRouteInstance(layer)) {
+                    match = layer.matchPath(path);
+                    if (req.method && !layer.matchMethod(req.method)) {
+                        match = false;
+                        if (req.method.toLowerCase() === core.Method.OPTIONS) {
+                            allowedMethods = smob.mergeArrays(allowedMethods, layer.getMethods(), true);
+                        }
+                    }
+                }
+            }
+            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 = core.cleanDoubleSlashes(`${layerMeta.mountPath || ''}/${output.path}`);
+                }
+            }
+            if (err) {
+                if (isLayerInstance(layer) && layer.isError()) {
+                    layer.dispatch(req, res, layerMeta, next, err);
+                    return;
+                }
+                /* istanbul ignore next */ setImmediate(next, err);
+                return;
+            }
+            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;
+                }
+                resolve();
+            });
+        });
+    }
+    // --------------------------------------------------
+    route(path) {
+        if (typeof path === 'string' && path.length > 0) {
+            path = core.withLeadingSlash(path);
+        }
+        const index = this.stack.findIndex((item)=>isRouteInstance(item) && item.path === path);
+        if (index !== -1) {
+            return this.stack[index];
+        }
+        const route = new Route({
+            path,
+            pathMatcher: {
+                sensitive: this.pathMatcherOptions.sensitive
+            }
+        });
+        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);
+        return this;
+    }
+    post(path, ...handlers) {
+        const route = this.route(path);
+        route.post(...handlers);
+        return this;
+    }
+    put(path, ...handlers) {
+        const route = this.route(path);
+        route.put(...handlers);
+        return this;
+    }
+    patch(path, ...handlers) {
+        const route = this.route(path);
+        route.patch(...handlers);
+        return this;
+    }
+    head(path, ...handlers) {
+        const route = this.route(path);
+        route.head(...handlers);
+        return this;
+    }
+    options(path, ...handlers) {
+        const route = this.route(path);
+        route.options(...handlers);
+        return this;
+    }
+    use(...input) {
+        /* istanbul ignore next */ if (input.length === 0) {
+            return this;
+        }
+        let path;
+        if (isPath(input[0])) {
+            path = input.shift();
+        }
+        for(let i = 0; i < input.length; i++){
+            const item = input[i];
+            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));
+            }
+        }
+        return this;
+    }
+    // --------------------------------------------------
+    constructor(ctx){
+        this['@instanceof'] = Symbol.for('Router');
+        /**
+     * Array of mounted layers, routes & routers.
+     *
+     * @protected
+     */ this.stack = [];
+        ctx = ctx || {};
+        this.pathMatcherOptions = {
+            end: false,
+            sensitive: true,
+            ...ctx.pathMatcher || {}
+        };
+        this.timeout = ctx.timeout;
+        this.setPath(ctx.path || '/');
+    }
+}
+
+exports.Layer = Layer;
+exports.PathMatcher = PathMatcher;
+exports.Route = Route;
+exports.Router = Router;
+exports.createRequestTimeout = createRequestTimeout;
+exports.isInstance = isInstance;
+exports.isLayerInstance = isLayerInstance;
+exports.isPath = isPath;
+exports.isPromise = isPromise;
+exports.isRouteInstance = isRouteInstance;
+exports.isRouterInstance = isRouterInstance;
+exports.processHandlerExecutionOutput = processHandlerExecutionOutput;
+Object.keys(core).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return core[k]; }
+    });
+});
 //# sourceMappingURL=index.cjs.map