routup 0.14.2 → 1.0.0-alpha.2

package/dist/index.mjs

@@ -1,10 +1,110 @@
-import { send, setRequestParams, setRequestMountPath, Method, withLeadingSlash, withoutTrailingSlash, useRequestPath, cleanDoubleSlashes, HeaderName } from '@routup/core';
-export * from '@routup/core';
-import { isObject, hasOwnProperty, merge, mergeArrays } from 'smob';
+import { Continu } from 'continu';
+import process from 'node:process';
+import zod from 'zod';
+import { merge, hasOwnProperty, mergeArrays } from 'smob';
+import crypto from 'node:crypto';
+import { Stats, stat, createReadStream } from 'node:fs';
+import proxyAddr from 'proxy-addr';
+import { getType, get } from 'mime-explorer';
 import { GatewayTimeoutErrorOptions, BadRequestError } from '@ebec/http';
+import Negotiator from 'negotiator';
+import { URL } from 'node:url';
+import path from 'node:path';
 import { pathToRegexp } from 'path-to-regexp';
 import { createServer } from '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 Stats === 'function' && obj instanceof 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 = 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)
@@ -14,6 +114,23 @@ import { createServer } from 'node:http';
     return typeof input === 'object' && input !== null && input['@instanceof'] === Symbol.for(name);
 }
 
+function getMimeType(type) {
+    if (type.indexOf('/') !== -1) {
+        return type;
+    }
+    return getType(type);
+}
+function getCharsetForMimeType(type) {
+    if (/^text\/|^application\/(javascript|json)/.test(type)) {
+        return 'utf-8';
+    }
+    const meta = get(type);
+    if (meta && meta.charset) {
+        return meta.charset.toLowerCase();
+    }
+    return undefined;
+}
+
 /*
  * Copyright (c) 2022.
  * Author Peter Placzek (tada5hi)
@@ -49,6 +166,876 @@ 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({
+        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.
+ */ var Method;
+(function(Method) {
+    Method["GET"] = 'get';
+    Method["POST"] = 'post';
+    Method["PUT"] = 'put';
+    Method["PATCH"] = 'patch';
+    Method["DELETE"] = 'delete';
+    Method["OPTIONS"] = 'options';
+    Method["HEAD"] = 'head';
+})(Method || (Method = {}));
+var HeaderName;
+(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';
+})(HeaderName || (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 = 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] = 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] = 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] = 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 (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, 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, 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[HeaderName.X_FORWARDED_HOST];
+    if (!hostname || !req.socket.remoteAddress || !trustProxy(req.socket.remoteAddress, 0)) {
+        hostname = req.headers[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 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 (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[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] = 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(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(HeaderName.CONTENT_DISPOSITION, `attachment${filename ? `; filename="${filename}"` : ''}`);
+}
+
+function setResponseHeaderContentType(res, input, ifNotExists) {
+    if (ifNotExists) {
+        const header = res.getHeader(HeaderName.CONTENT_TYPE);
+        if (header) {
+            return;
+        }
+    }
+    const contentType = getMimeType(input);
+    if (contentType) {
+        res.setHeader(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(HeaderName.CONTENT_ENCODING, 'utf-8');
+        appendResponseHeaderDirective(res, 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(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(HeaderName.ETag, chunkHash);
+            if (res.req.headers[HeaderName.IF_NONE_MATCH] === chunkHash) {
+                res.statusCode = 304;
+            }
+        }
+    }
+    // strip irrelevant headers
+    if (res.statusCode === 204 || res.statusCode === 304) {
+        res.removeHeader(HeaderName.CONTENT_TYPE);
+        res.removeHeader(HeaderName.CONTENT_LENGTH);
+        res.removeHeader(HeaderName.TRANSFER_ENCODING);
+        chunk = '';
+    }
+    // alter headers for 205
+    if (res.statusCode === 205) {
+        res.setHeader(HeaderName.CONTENT_LENGTH, 0);
+        res.removeHeader(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;
+    }
+    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(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[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(HeaderName.CONTENT_RANGE, `bytes */${stats.size}`);
+                res.statusCode = 416;
+                res.end();
+                return;
+            }
+            res.setHeader(HeaderName.CONTENT_RANGE, `bytes ${streamOptions.start}-${streamOptions.end}/${stats.size}`);
+            res.setHeader(HeaderName.CONTENT_LENGTH, streamOptions.end - streamOptions.start + 1);
+        } else {
+            res.setHeader(HeaderName.CONTENT_LENGTH, stats.size);
+        }
+        res.setHeader(HeaderName.ACCEPT_RANGES, 'bytes');
+        res.setHeader(HeaderName.LAST_MODIFIED, stats.mtime.toUTCString());
+        res.setHeader(HeaderName.ETag, `W/"${stats.size}-${stats.mtime.getTime()}"`);
+        sendStream(res, 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)=>{
@@ -557,5 +1544,5 @@ class Router {
     }
 }
 
-export { Layer, PathMatcher, Route, Router, createRequestTimeout, isInstance, isLayerInstance, isPath, isPromise, isRouteInstance, isRouterInstance, processHandlerExecutionOutput };
+export { HeaderName, Layer, Method, PathMatcher, Route, Router, appendResponseHeader, appendResponseHeaderDirective, buildConfig, buildEtagFn, buildTrustProxyFn, cleanDoubleSlashes, createRequestTimeout, getCharsetForMimeType, getConfigOption, getMimeType, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, hasLeadingSlash, hasRequestCookies, hasRequestQuery, hasTrailingSlash, isInstance, isLayerInstance, isObject, isPath, isPromise, isRequestCacheable, isRouteInstance, isRouterInstance, matchRequestContentType, onResponseFinished, processHandlerExecutionOutput, send, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, setConfig, setConfigOption, setRequestBody, setRequestCookieFn, setRequestCookies, setRequestEnv, setRequestHeader, setRequestMountPath, setRequestParam, setRequestParams, setRequestQuery, setRequestQueryFn, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, unsetRequestEnv, useConfig, useRequestBody, useRequestCookie, useRequestCookies, useRequestEnv, useRequestMountPath, useRequestNegotiator, useRequestParam, useRequestParams, useRequestPath, useRequestQuery, withLeadingSlash, withTrailingSlash, withoutLeadingSlash, withoutTrailingSlash };
 //# sourceMappingURL=index.mjs.map