routup 0.14.2 → 1.0.0-alpha.2

package/dist/index.cjs

@@ -1,11 +1,112 @@
 'use strict';
 
-var core = require('@routup/core');
+var continu = require('continu');
+var process = require('node:process');
+var zod = require('zod');
 var smob = require('smob');
+var crypto = require('node:crypto');
+var node_fs = require('node:fs');
+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 pathToRegexp = require('path-to-regexp');
 var node_http = require('node:http');
 
+/*
+ * Copyright (c) 2022-2023.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function isObject(item) {
+    return !!item && typeof item === 'object' && !Array.isArray(item);
+}
+
+/**
+ * Determine if object is a Stats object.
+ *
+ * @param {object} obj
+ * @return {boolean}
+ * @api private
+ */ function isStatsObject(obj) {
+    // genuine fs.Stats
+    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';
+}
+/**
+ * Generate an ETag.
+ */ function generateETag(input) {
+    if (isStatsObject(input)) {
+        const mtime = input.mtime.getTime().toString(16);
+        const size = input.size.toString(16);
+        return `"${size}-${mtime}"`;
+    }
+    if (input.length === 0) {
+        // fast-path empty
+        return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
+    }
+    const entity = 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}"`;
+}
+/**
+ * Create a simple ETag.
+ */ function createEtag(input, options) {
+    options = options || {};
+    const weak = typeof options.weak === 'boolean' ? options.weak : isStatsObject(input);
+    // generate entity tag
+    const tag = generateETag(input);
+    return weak ? `W/${tag}` : tag;
+}
+
+function buildEtagFn(input) {
+    if (typeof input === 'function') {
+        return input;
+    }
+    input = input ?? true;
+    if (input === false) {
+        return ()=>undefined;
+    }
+    let options = {
+        weak: true
+    };
+    if (isObject(input)) {
+        options = smob.merge(input, options);
+    }
+    return (body, encoding, size)=>{
+        const buff = Buffer.isBuffer(body) ? body : Buffer.from(body, encoding);
+        if (typeof options.threshold !== 'undefined') {
+            size = size ?? Buffer.byteLength(buff);
+            if (size <= options.threshold) {
+                return undefined;
+            }
+        }
+        return createEtag(buff, options);
+    };
+}
+
+function buildTrustProxyFn(input) {
+    if (typeof input === 'function') {
+        return input;
+    }
+    if (input === true) {
+        return ()=>true;
+    }
+    if (typeof input === 'number') {
+        return (_address, hop)=>hop < input;
+    }
+    if (typeof input === 'string') {
+        input = input.split(',').map((value)=>value.trim());
+    }
+    return proxyAddr.compile(input || []);
+}
+
 /*
  * Copyright (c) 2022-2022.
  * Author Peter Placzek (tada5hi)
@@ -15,6 +116,23 @@ var node_http = require('node:http');
     return typeof input === 'object' && input !== null && input['@instanceof'] === Symbol.for(name);
 }
 
+function getMimeType(type) {
+    if (type.indexOf('/') !== -1) {
+        return type;
+    }
+    return mimeExplorer.getType(type);
+}
+function getCharsetForMimeType(type) {
+    if (/^text\/|^application\/(javascript|json)/.test(type)) {
+        return 'utf-8';
+    }
+    const meta = mimeExplorer.get(type);
+    if (meta && meta.charset) {
+        return meta.charset.toLowerCase();
+    }
+    return undefined;
+}
+
 /*
  * Copyright (c) 2022.
  * Author Peter Placzek (tada5hi)
@@ -25,7 +143,7 @@ var node_http = require('node:http');
 }
 
 function isPromise(p) {
-    return smob.isObject(p) && (p instanceof Promise || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    return isObject(p) && (p instanceof Promise || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     typeof p.then === 'function');
 }
@@ -50,18 +168,888 @@ function isPromise(p) {
     });
 }
 
+/*
+ * Copyright (c) 2022-2023.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ const TRAILING_SLASH_RE = /\/$|\/\?/;
+function hasTrailingSlash(input = '', queryParams = false) {
+    if (!queryParams) {
+        return input.endsWith('/');
+    }
+    return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = '', queryParams = false) {
+    if (!queryParams) {
+        return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || '/';
+    }
+    if (!hasTrailingSlash(input, true)) {
+        return input || '/';
+    }
+    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;
+    }
+    instance = buildConfig();
+    return instance;
+}
+function setConfig(config) {
+    instance = config;
+}
+function setConfigOption(key, value) {
+    const config = useConfig();
+    config.setRaw(key, value);
+    return config.get();
+}
+function getConfigOption(key) {
+    const config = useConfig();
+    return config.get(key);
+}
+
+/*
+ * Copyright (c) 2022-2023.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ exports.Method = void 0;
+(function(Method) {
+    Method["GET"] = 'get';
+    Method["POST"] = 'post';
+    Method["PUT"] = 'put';
+    Method["PATCH"] = 'patch';
+    Method["DELETE"] = 'delete';
+    Method["OPTIONS"] = 'options';
+    Method["HEAD"] = 'head';
+})(exports.Method || (exports.Method = {}));
+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_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;
+    /* istanbul ignore next */ if ('body' in req) {
+        body = req.body;
+    }
+    if (BodySymbol in req) {
+        if (body) {
+            body = smob.merge({}, req[BodySymbol], body);
+        } else {
+            body = req[BodySymbol];
+        }
+    }
+    if (body) {
+        if (typeof key === 'string') {
+            return body[key];
+        }
+        return body;
+    }
+    return typeof key === 'string' ? undefined : {};
+}
+function setRequestBody(req, key, value) {
+    if (BodySymbol in req) {
+        if (typeof key === 'object') {
+            if (value) {
+                req[BodySymbol] = smob.merge(req[BodySymbol], key);
+            } else {
+                req[BodySymbol] = key;
+            }
+        } else {
+            req[BodySymbol][key] = value;
+        }
+        return;
+    }
+    if (typeof key === 'object') {
+        req[BodySymbol] = key;
+        return;
+    }
+    req[BodySymbol] = {
+        [key]: value
+    };
+}
+
+/*
+ * 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 isRequestCacheable(req, modifiedTime) {
+    const modifiedSince = req.headers['if-modified-since'];
+    if (!modifiedSince) {
+        return false;
+    }
+    modifiedTime = typeof modifiedTime === 'string' ? new Date(modifiedTime) : modifiedTime;
+    return new Date(modifiedSince) >= modifiedTime;
+}
+
+const CookieSymbol = Symbol.for('ReqCookie');
+let requestFn$1;
+function setRequestCookieFn(fn) {
+    requestFn$1 = fn;
+}
+function useRequestCookies(req) {
+    if (!(CookieSymbol in req) && typeof requestFn$1 !== 'undefined') {
+        req[CookieSymbol] = requestFn$1(req);
+    }
+    if (CookieSymbol in req) {
+        return req[CookieSymbol];
+    }
+    return {};
+}
+function hasRequestCookies(req) {
+    return CookieSymbol in req && isObject(req[CookieSymbol]);
+}
+function useRequestCookie(req, name) {
+    return useRequestCookies(req)[name];
+}
+function setRequestCookies(req, record, mergeIt) {
+    if (CookieSymbol in req) {
+        if (mergeIt) {
+            req[CookieSymbol] = smob.merge(req[CookieSymbol], record);
+        }
+        return;
+    }
+    req[CookieSymbol] = record;
+}
+
+const envSymbol = Symbol.for('ReqEnv');
+function setRequestEnv(req, key, value) {
+    if (envSymbol in req) {
+        if (typeof key === 'object') {
+            if (value) {
+                req[envSymbol] = smob.merge(req[envSymbol], key);
+            } else {
+                req[envSymbol] = key;
+            }
+        } else {
+            req[envSymbol][key] = value;
+        }
+        return;
+    }
+    if (typeof key === 'object') {
+        req[envSymbol] = key;
+        return;
+    }
+    req[envSymbol] = {
+        [key]: value
+    };
+}
+function useRequestEnv(req, key) {
+    if (envSymbol in req) {
+        if (typeof key === 'string') {
+            return req[envSymbol][key];
+        }
+        return req[envSymbol];
+    }
+    if (typeof key === 'string') {
+        return undefined;
+    }
+    return {};
+}
+function unsetRequestEnv(req, key) {
+    if (envSymbol in req) {
+        if (smob.hasOwnProperty(req[envSymbol], key)) {
+            delete req[envSymbol][key];
+        }
+    }
+}
+
+/*
+ * 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 getRequestHeader(req, name) {
+    return req.headers[name];
+}
+function setRequestHeader(req, name, value) {
+    req.headers[name] = value;
+}
+
+const NegotiatorSymbol = Symbol.for('ReqNegotiator');
+function useRequestNegotiator(req) {
+    if (NegotiatorSymbol in req) {
+        return req[NegotiatorSymbol];
+    }
+    return new Negotiator(req);
+}
+
+function getRequestAcceptableContentTypes(req) {
+    const negotiator = useRequestNegotiator(req);
+    return negotiator.mediaTypes();
+}
+function getRequestAcceptableContentType(req, input) {
+    input = input || [];
+    const items = Array.isArray(input) ? input : [
+        input
+    ];
+    if (items.length === 0) {
+        return getRequestAcceptableContentTypes(req).shift();
+    }
+    const header = getRequestHeader(req, exports.HeaderName.ACCEPT);
+    if (!header) {
+        return items[0];
+    }
+    let polluted = false;
+    const mimeTypes = [];
+    for(let i = 0; i < items.length; i++){
+        const mimeType = getMimeType(items[i]);
+        if (mimeType) {
+            mimeTypes.push(mimeType);
+        } else {
+            polluted = true;
+        }
+    }
+    const negotiator = useRequestNegotiator(req);
+    const matches = negotiator.mediaTypes(mimeTypes);
+    if (matches.length > 0) {
+        if (polluted) {
+            return items[0];
+        }
+        return items[mimeTypes.indexOf(matches[0])];
+    }
+    return undefined;
+}
+
+function getRequestAcceptableCharsets(req) {
+    const negotiator = useRequestNegotiator(req);
+    return negotiator.charsets();
+}
+function getRequestAcceptableCharset(req, input) {
+    input = input || [];
+    const items = Array.isArray(input) ? input : [
+        input
+    ];
+    if (items.length === 0) {
+        return getRequestAcceptableCharsets(req).shift();
+    }
+    const negotiator = useRequestNegotiator(req);
+    return negotiator.charsets(items).shift() || undefined;
+}
+
+function getRequestAcceptableEncodings(req) {
+    const negotiator = useRequestNegotiator(req);
+    return negotiator.encodings();
+}
+function getRequestAcceptableEncoding(req, input) {
+    input = input || [];
+    const items = Array.isArray(input) ? input : [
+        input
+    ];
+    if (items.length === 0) {
+        return getRequestAcceptableEncodings(req).shift();
+    }
+    const negotiator = useRequestNegotiator(req);
+    return negotiator.encodings(items).shift() || undefined;
+}
+
+function getRequestAcceptableLanguages(req) {
+    const negotiator = useRequestNegotiator(req);
+    return negotiator.languages();
+}
+function getRequestAcceptableLanguage(req, input) {
+    input = input || [];
+    const items = Array.isArray(input) ? input : [
+        input
+    ];
+    if (items.length === 0) {
+        return getRequestAcceptableLanguages(req).shift();
+    }
+    const negotiator = useRequestNegotiator(req);
+    return negotiator.languages(items).shift() || undefined;
+}
+
+function matchRequestContentType(req, contentType) {
+    const header = getRequestHeader(req, exports.HeaderName.CONTENT_TYPE);
+    if (!header) {
+        return true;
+    }
+    /* istanbul ignore next */ if (Array.isArray(header)) {
+        if (header.length === 0) {
+            return true;
+        }
+        return header[0] === getMimeType(contentType);
+    }
+    return header.split('; ').shift() === getMimeType(contentType);
+}
+
+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');
+    }
+    let hostname = req.headers[exports.HeaderName.X_FORWARDED_HOST];
+    if (!hostname || !req.socket.remoteAddress || !trustProxy(req.socket.remoteAddress, 0)) {
+        hostname = req.headers[exports.HeaderName.HOST];
+    } else {
+        hostname = Array.isArray(hostname) ? hostname.pop() : hostname;
+        if (hostname && hostname.indexOf(',') !== -1) {
+            hostname = hostname.substring(0, hostname.indexOf(',')).trimEnd();
+        }
+    }
+    if (!hostname) {
+        return undefined;
+    }
+    // IPv6 literal support
+    const offset = hostname[0] === '[' ? hostname.indexOf(']') + 1 : 0;
+    const index = hostname.indexOf(':', offset);
+    return index !== -1 ? hostname.substring(0, index) : hostname;
+}
+
+function getRequestIP(req, options) {
+    options = options || {};
+    let trustProxy;
+    if (typeof options.trustProxy !== 'undefined') {
+        trustProxy = buildTrustProxyFn(options.trustProxy);
+    } else {
+        const config = useConfig();
+        trustProxy = config.get('trustProxy');
+    }
+    return proxyAddr(req, trustProxy);
+}
+
+/*
+ * 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.
+ */ const ReqMountPathSymbol = Symbol.for('ReqMountPath');
+function useRequestMountPath(req) {
+    if (ReqMountPathSymbol in req) {
+        return req[ReqMountPathSymbol];
+    }
+    return '/';
+}
+function setRequestMountPath(req, basePath) {
+    req[ReqMountPathSymbol] = basePath;
+}
+
+/*
+ * 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.
+ */ const ParamsSymbol = Symbol.for('ReqParams');
+function useRequestParams(req) {
+    if ('params' in req) {
+        return req.params;
+    }
+    if (ParamsSymbol in req) {
+        return req[ParamsSymbol];
+    }
+    return {};
+}
+function useRequestParam(req, key) {
+    return useRequestParams(req)[key];
+}
+function setRequestParams(req, data) {
+    req[ParamsSymbol] = data;
+}
+function setRequestParam(req, key, value) {
+    const params = useRequestParams(req);
+    params[key] = value;
+    setRequestParams(req, params);
+}
+
+function useRequestPath(req) {
+    if ('path' in req) {
+        return req.path;
+    }
+    if (typeof req.url === 'undefined') {
+        return '/';
+    }
+    const parsed = new node_url.URL(req.url, 'http://localhost/');
+    return parsed.pathname;
+}
+
+function getRequestProtocol(req, options) {
+    options = options || {};
+    let trustProxy;
+    if (typeof options.trustProxy !== 'undefined') {
+        trustProxy = buildTrustProxyFn(options.trustProxy);
+    } else {
+        const config = useConfig();
+        trustProxy = config.get('trustProxy');
+    }
+    let protocol = options.default;
+    /* istanbul ignore next */ if (smob.hasOwnProperty(req.socket, 'encrypted') && !!req.socket.encrypted) {
+        protocol = 'https';
+    } else if (!protocol) {
+        protocol = 'http';
+    }
+    if (!req.socket.remoteAddress || !trustProxy(req.socket.remoteAddress, 0)) {
+        return protocol;
+    }
+    let header = req.headers[exports.HeaderName.X_FORWARDED_PROTO];
+    /* istanbul ignore next */ if (Array.isArray(header)) {
+        header = header.pop();
+    }
+    if (!header) {
+        return protocol;
+    }
+    const index = header.indexOf(',');
+    return index !== -1 ? header.substring(0, index).trim() : header.trim();
+}
+
+const QuerySymbol = Symbol.for('ReqQuery');
+let requestFn;
+function setRequestQueryFn(fn) {
+    requestFn = fn;
+}
+function useRequestQuery(req, key) {
+    /* istanbul ignore if  */ if ('query' in req) {
+        if (typeof key === 'string') {
+            return req.query[key];
+        }
+        return req.query;
+    }
+    if (!(QuerySymbol in req) && typeof requestFn !== 'undefined') {
+        req[QuerySymbol] = requestFn(req);
+    }
+    if (QuerySymbol in req) {
+        if (typeof key === 'string') {
+            return req[QuerySymbol][key];
+        }
+        return req[QuerySymbol];
+    }
+    return {};
+}
+function hasRequestQuery(req) {
+    return QuerySymbol in req && isObject(req[QuerySymbol]);
+}
+function setRequestQuery(req, key, value) {
+    if (QuerySymbol in req) {
+        if (typeof key === 'object') {
+            if (value) {
+                req[QuerySymbol] = smob.merge(req[QuerySymbol], key);
+            } else {
+                req[QuerySymbol] = key;
+            }
+        } else {
+            req[QuerySymbol][key] = value;
+        }
+        return;
+    }
+    if (typeof key === 'object') {
+        req[QuerySymbol] = key;
+        return;
+    }
+    req[QuerySymbol] = {
+        [key]: value
+    };
+}
+
+/*
+ * 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 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(', '));
+}
+
+/*
+ * 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 appendResponseHeader(res, name, value) {
+    let header = res.getHeader(name);
+    if (!header) {
+        res.setHeader(name, value);
+        return;
+    }
+    if (!Array.isArray(header)) {
+        header = [
+            header.toString()
+        ];
+    }
+    res.setHeader(name, [
+        ...header,
+        value
+    ]);
+}
+function appendResponseHeaderDirective(res, name, value) {
+    let header = res.getHeader(name);
+    if (!header) {
+        if (Array.isArray(value)) {
+            res.setHeader(name, value.join('; '));
+            return;
+        }
+        res.setHeader(name, value);
+        return;
+    }
+    if (!Array.isArray(header)) {
+        if (typeof header === 'string') {
+            // split header by directive(s)
+            header = header.split('; ');
+        }
+        if (typeof header === 'number') {
+            header = [
+                header.toString()
+            ];
+        }
+    }
+    if (Array.isArray(value)) {
+        header.push(...value);
+    } else {
+        header.push(`${value}`);
+    }
+    header = [
+        ...new Set(header)
+    ];
+    res.setHeader(name, header.join('; '));
+}
+
+function setResponseContentTypeByFileName(res, fileName) {
+    const ext = path.extname(fileName);
+    if (ext) {
+        let type = getMimeType(ext.substring(1));
+        if (type) {
+            const charset = getCharsetForMimeType(type);
+            if (charset) {
+                type += `; charset=${charset}`;
+            }
+            res.setHeader(exports.HeaderName.CONTENT_TYPE, type);
+        }
+    }
+}
+function onResponseFinished(res, cb) {
+    let called;
+    const callCallback = (err)=>{
+        if (called) return;
+        called = true;
+        cb(err);
+    };
+    res.on('finish', async ()=>{
+        callCallback();
+    });
+    res.on('close', async ()=>{
+        callCallback();
+    });
+    res.on('error', async (err)=>{
+        callCallback(err);
+    });
+}
+
+function setResponseHeaderAttachment(res, filename) {
+    if (typeof filename === 'string') {
+        setResponseContentTypeByFileName(res, filename);
+    }
+    res.setHeader(exports.HeaderName.CONTENT_DISPOSITION, `attachment${filename ? `; filename="${filename}"` : ''}`);
+}
+
+function setResponseHeaderContentType(res, input, ifNotExists) {
+    if (ifNotExists) {
+        const header = res.getHeader(exports.HeaderName.CONTENT_TYPE);
+        if (header) {
+            return;
+        }
+    }
+    const contentType = getMimeType(input);
+    if (contentType) {
+        res.setHeader(exports.HeaderName.CONTENT_TYPE, contentType);
+    }
+}
+
+function send(res, chunk) {
+    switch(typeof chunk){
+        case 'string':
+            {
+                setResponseHeaderContentType(res, 'html', true);
+                break;
+            }
+        case 'boolean':
+        case 'number':
+        case 'object':
+            {
+                if (chunk === null) {
+                    chunk = '';
+                } else if (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.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);
+        } else {
+            // convert chunk to Buffer and calculate
+            chunk = 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);
+        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);
+        chunk = '';
+    }
+    // alter headers for 205
+    if (res.statusCode === 205) {
+        res.setHeader(exports.HeaderName.CONTENT_LENGTH, 0);
+        res.removeHeader(exports.HeaderName.TRANSFER_ENCODING);
+        chunk = '';
+    }
+    if (res.req.method === 'HEAD') {
+        // skip body for HEAD
+        res.end();
+        return;
+    }
+    if (typeof encoding !== 'undefined') {
+        res.end(chunk, encoding);
+        return;
+    }
+    res.end(chunk);
+}
+
+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);
+}
+
+/*
+ * 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 sendStream(res, stream, fn) {
+    stream.on('open', ()=>{
+        stream.pipe(res);
+    });
+    stream.on('error', (err)=>{
+        if (typeof fn === 'function') {
+            fn(err);
+        } else {
+            res.statusCode = 400;
+            res.end();
+        }
+    });
+    stream.on('close', ()=>{
+        if (typeof fn === 'function') {
+            fn();
+        } else {
+            res.end();
+        }
+    });
+}
+
+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);
+        }
+    } else {
+        setResponseContentTypeByFileName(res, fileName);
+    }
+    resolveStats(options, (err, stats)=>{
+        if (err) {
+            if (typeof fn === 'function') {
+                fn(err);
+            } else {
+                res.statusCode = 404;
+                res.end();
+            }
+            return;
+        }
+        const streamOptions = {};
+        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.start >= stats.size || streamOptions.end >= stats.size) {
+                res.setHeader(exports.HeaderName.CONTENT_RANGE, `bytes */${stats.size}`);
+                res.statusCode = 416;
+                res.end();
+                return;
+            }
+            res.setHeader(exports.HeaderName.CONTENT_RANGE, `bytes ${streamOptions.start}-${streamOptions.end}/${stats.size}`);
+            res.setHeader(exports.HeaderName.CONTENT_LENGTH, streamOptions.end - streamOptions.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);
+    });
+}
+
+/*
+ * 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 sendFormat(_res, _format) {}
+
+function sendRedirect(res, location, statusCode = 302) {
+    res.statusCode = statusCode;
+    res.setHeader('location', location);
+    const encodedLoc = location.replace(/"/g, '%22');
+    const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`;
+    return send(res, html);
+}
+
 function processHandlerExecutionOutput(res, next, output) {
     if (isPromise(output)) {
         output.then((r)=>{
             if (typeof r !== 'undefined') {
-                core.send(res, r);
+                send(res, r);
             }
             return r;
         }).catch(next);
         return;
     }
     if (typeof output !== 'undefined') {
-        core.send(res, output);
+        send(res, output);
     }
 }
 
@@ -132,8 +1120,8 @@ class Layer {
         return this.fn.length === 4;
     }
     dispatch(req, res, meta, next, err) {
-        core.setRequestParams(req, meta.params || {});
-        core.setRequestMountPath(req, meta.mountPath || '/');
+        setRequestParams(req, meta.params || {});
+        setRequestMountPath(req, meta.mountPath || '/');
         if (typeof err !== 'undefined') {
             if (this.fn.length === 4) {
                 try {
@@ -195,16 +1183,16 @@ class Route {
     }
     matchMethod(method) {
         let name = method.toLowerCase();
-        if (name === core.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
-            name = core.Method.GET;
+        if (name === exports.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
+            name = exports.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);
+        if (smob.hasOwnProperty(this.layers, exports.Method.GET) && !smob.hasOwnProperty(this.layers, exports.Method.HEAD)) {
+            keys.push(exports.Method.HEAD);
         }
         return keys;
     }
@@ -215,8 +1203,8 @@ class Route {
             return;
         }
         let name = req.method.toLowerCase();
-        if (name === core.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
-            name = core.Method.GET;
+        if (name === exports.Method.HEAD && !smob.hasOwnProperty(this.layers, name)) {
+            name = exports.Method.GET;
         }
         const layers = this.layers[name];
         /* istanbul ignore next */ if (typeof layers === 'undefined' || layers.length === 0 || typeof meta.path === 'undefined') {
@@ -260,25 +1248,25 @@ class Route {
         }
     }
     get(...handlers) {
-        return this.register(core.Method.GET, ...handlers);
+        return this.register(exports.Method.GET, ...handlers);
     }
     post(...handlers) {
-        return this.register(core.Method.POST, ...handlers);
+        return this.register(exports.Method.POST, ...handlers);
     }
     put(...handlers) {
-        return this.register(core.Method.PUT, ...handlers);
+        return this.register(exports.Method.PUT, ...handlers);
     }
     patch(...handlers) {
-        return this.register(core.Method.PATCH, ...handlers);
+        return this.register(exports.Method.PATCH, ...handlers);
     }
     delete(...handlers) {
-        return this.register(core.Method.DELETE, ...handlers);
+        return this.register(exports.Method.DELETE, ...handlers);
     }
     head(...handlers) {
-        return this.register(core.Method.HEAD, ...handlers);
+        return this.register(exports.Method.HEAD, ...handlers);
     }
     options(...handlers) {
-        return this.register(core.Method.OPTIONS, ...handlers);
+        return this.register(exports.Method.OPTIONS, ...handlers);
     }
     // --------------------------------------------------
     isStrictPath() {
@@ -319,7 +1307,7 @@ class Router {
             return;
         }
         if (typeof value === 'string') {
-            this.path = core.withLeadingSlash(core.withoutTrailingSlash(`${value}`));
+            this.path = withLeadingSlash(withoutTrailingSlash(`${value}`));
         } else {
             this.path = value;
         }
@@ -363,24 +1351,24 @@ class Router {
                 res.end();
                 return;
             }
-            if (req.method && req.method.toLowerCase() === core.Method.OPTIONS) {
+            if (req.method && req.method.toLowerCase() === exports.Method.OPTIONS) {
                 const options = allowedMethods.map((key)=>key.toUpperCase()).join(',');
-                res.setHeader(core.HeaderName.ALLOW, options);
-                core.send(res, options);
+                res.setHeader(exports.HeaderName.ALLOW, options);
+                send(res, options);
                 return;
             }
             res.statusCode = 404;
             res.end();
         };
-        let path = meta.path || core.useRequestPath(req);
+        let path = meta.path || useRequestPath(req);
         if (this.pathMatcher) {
             const output = this.pathMatcher.exec(path);
             if (typeof output !== 'undefined') {
-                meta.mountPath = core.cleanDoubleSlashes(`${meta.mountPath || ''}/${output.path}`);
+                meta.mountPath = cleanDoubleSlashes(`${meta.mountPath || ''}/${output.path}`);
                 if (path === output.path) {
                     path = '/';
                 } else {
-                    path = core.withLeadingSlash(path.substring(output.path.length));
+                    path = withLeadingSlash(path.substring(output.path.length));
                 }
                 meta.params = smob.merge(meta.params || {}, output.params);
             }
@@ -412,7 +1400,7 @@ class Router {
                     match = layer.matchPath(path);
                     if (req.method && !layer.matchMethod(req.method)) {
                         match = false;
-                        if (req.method.toLowerCase() === core.Method.OPTIONS) {
+                        if (req.method.toLowerCase() === exports.Method.OPTIONS) {
                             allowedMethods = smob.mergeArrays(allowedMethods, layer.getMethods(), true);
                         }
                     }
@@ -429,7 +1417,7 @@ class Router {
                 const output = layer.exec(path);
                 if (output) {
                     layerMeta.params = smob.merge(output.params, layerMeta.params || {});
-                    layerMeta.mountPath = core.cleanDoubleSlashes(`${layerMeta.mountPath || ''}/${output.path}`);
+                    layerMeta.mountPath = cleanDoubleSlashes(`${layerMeta.mountPath || ''}/${output.path}`);
                 }
             }
             if (err) {
@@ -458,7 +1446,7 @@ class Router {
     // --------------------------------------------------
     route(path) {
         if (typeof path === 'string' && path.length > 0) {
-            path = core.withLeadingSlash(path);
+            path = withLeadingSlash(path);
         }
         const index = this.stack.findIndex((item)=>isRouteInstance(item) && item.path === path);
         if (index !== -1) {
@@ -562,18 +1550,80 @@ 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.createRequestTimeout = createRequestTimeout;
+exports.getCharsetForMimeType = getCharsetForMimeType;
+exports.getConfigOption = getConfigOption;
+exports.getMimeType = getMimeType;
+exports.getRequestAcceptableCharset = getRequestAcceptableCharset;
+exports.getRequestAcceptableCharsets = getRequestAcceptableCharsets;
+exports.getRequestAcceptableContentType = getRequestAcceptableContentType;
+exports.getRequestAcceptableContentTypes = getRequestAcceptableContentTypes;
+exports.getRequestAcceptableEncoding = getRequestAcceptableEncoding;
+exports.getRequestAcceptableEncodings = getRequestAcceptableEncodings;
+exports.getRequestAcceptableLanguage = getRequestAcceptableLanguage;
+exports.getRequestAcceptableLanguages = getRequestAcceptableLanguages;
+exports.getRequestHeader = getRequestHeader;
+exports.getRequestHostName = getRequestHostName;
+exports.getRequestIP = getRequestIP;
+exports.getRequestProtocol = getRequestProtocol;
+exports.hasLeadingSlash = hasLeadingSlash;
+exports.hasRequestCookies = hasRequestCookies;
+exports.hasRequestQuery = hasRequestQuery;
+exports.hasTrailingSlash = hasTrailingSlash;
 exports.isInstance = isInstance;
 exports.isLayerInstance = isLayerInstance;
+exports.isObject = isObject;
 exports.isPath = isPath;
 exports.isPromise = isPromise;
+exports.isRequestCacheable = isRequestCacheable;
 exports.isRouteInstance = isRouteInstance;
 exports.isRouterInstance = isRouterInstance;
+exports.matchRequestContentType = matchRequestContentType;
+exports.onResponseFinished = onResponseFinished;
 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]; }
-    });
-});
+exports.send = send;
+exports.sendAccepted = sendAccepted;
+exports.sendCreated = sendCreated;
+exports.sendFile = sendFile;
+exports.sendFormat = sendFormat;
+exports.sendRedirect = sendRedirect;
+exports.sendStream = sendStream;
+exports.setConfig = setConfig;
+exports.setConfigOption = setConfigOption;
+exports.setRequestBody = setRequestBody;
+exports.setRequestCookieFn = setRequestCookieFn;
+exports.setRequestCookies = setRequestCookies;
+exports.setRequestEnv = setRequestEnv;
+exports.setRequestHeader = setRequestHeader;
+exports.setRequestMountPath = setRequestMountPath;
+exports.setRequestParam = setRequestParam;
+exports.setRequestParams = setRequestParams;
+exports.setRequestQuery = setRequestQuery;
+exports.setRequestQueryFn = setRequestQueryFn;
+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;
+exports.useRequestEnv = useRequestEnv;
+exports.useRequestMountPath = useRequestMountPath;
+exports.useRequestNegotiator = useRequestNegotiator;
+exports.useRequestParam = useRequestParam;
+exports.useRequestParams = useRequestParams;
+exports.useRequestPath = useRequestPath;
+exports.useRequestQuery = useRequestQuery;
+exports.withLeadingSlash = withLeadingSlash;
+exports.withTrailingSlash = withTrailingSlash;
+exports.withoutLeadingSlash = withoutLeadingSlash;
+exports.withoutTrailingSlash = withoutTrailingSlash;
 //# sourceMappingURL=index.cjs.map