wooks 0.0.1-beta.0

package/dist/wooks.esm-bundler.js

@@ -0,0 +1,2644 @@
+import { escapeRegex, safeDecodeURIComponent, ProstoRouter } from '@prostojs/router';
+import http, { IncomingMessage, ServerResponse } from 'http';
+import { randomUUID } from 'crypto';
+import { Readable } from 'stream';
+import { createReadStream, promises } from 'fs';
+import path from 'path';
+import { URLSearchParams } from 'url';
+import { Socket } from 'net';
+
+const banner = () => `[wooks][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+
+function panic(error) {
+    console.error('' + '' + banner() + error + '');
+    return new Error(error);
+}
+
+let currentHttpContext = null;
+function useCurrentWooksContext() {
+    if (!currentHttpContext) {
+        throw panic('Use HTTP hooks only synchronously within the runtime of the request.');
+    }
+    const cc = currentHttpContext;
+    return {
+        getCtx: () => cc,
+        restoreCtx: () => setCurrentWooksContext(cc.req, cc.res, cc.params, cc.customContext),
+    };
+}
+function clearCurrentWooksContext() {
+    currentHttpContext = null;
+}
+function setCurrentWooksContext(req, res, params, customContext) {
+    currentHttpContext = { req, res, params, customContext };
+}
+const innerCacheSymbols = {
+    searchParams: Symbol('searchParams'),
+    cookies: Symbol('cookies'),
+    accept: Symbol('accept'),
+    authorization: Symbol('authorization'),
+    setHeader: Symbol('setHeader'),
+    setCookies: Symbol('setCookies'),
+    status: Symbol('status'),
+    response: Symbol('response'),
+    request: Symbol('request'),
+};
+function useCacheObject(name) {
+    const cc = useCurrentWooksContext().getCtx().customContext;
+    const cache = cc[name] = (cc[name] || {});
+    return cache;
+}
+function clearCacheObject(name) {
+    const cc = useCurrentWooksContext().getCtx().customContext;
+    const o = cc[name];
+    switch (typeof o) {
+        case 'object':
+            if (Array.isArray(o)) {
+                o.splice(0, o.length);
+            }
+            else {
+                for (const key in o) {
+                    delete o[key];
+                }
+            }
+            break;
+        case 'string':
+            cc[name] = '';
+            break;
+        default: cc[name] = {};
+    }
+}
+
+function createServer(opts, cb, hostname, onListen) {
+    const server = http.createServer(cb);
+    if (hostname) {
+        server.listen(opts.port, hostname, onListen);
+    }
+    else {
+        server.listen(opts.port, onListen);
+    }
+    return server;
+}
+
+const contentTypes = {
+    application: {
+        atomXml: 'application/atom+xml',
+        ediX12: 'application/EDI-X12',
+        edifact: 'application/EDIFACT',
+        json: 'application/json',
+        javascript: 'application/javascript',
+        octetStream: 'application/octet-stream',
+        ogg: 'application/ogg',
+        pdf: 'application/pdf',
+        postscript: 'application/postscript',
+        soapXml: 'application/soap+xml',
+        fontWoff: 'application/font-woff',
+        xhtmlXml: 'application/xhtml+xml',
+        xmlDtd: 'application/xml-dtd',
+        xopXml: 'application/xop+xml',
+        zip: 'application/zip',
+        gzip: 'application/gzip',
+        xBittorrent: 'application/x-bittorrent',
+        xTex: 'application/x-tex',
+        xml: 'application/xml',
+        msword: 'application/msword',
+        xWwwFormUrlencoded: 'application/x-www-form-urlencoded',
+        xDvi: 'application/x-dvi',
+        xLatex: 'application/x-latex',
+        xFontTtf: 'application/x-font-ttf',
+        xShockwaveFlash: 'application/x-shockwave-flash',
+        xStuffit: 'application/x-stuffit',
+        xRarCompressed: 'application/x-rar-compressed',
+        xTar: 'application/x-tar',
+        xJavascript: 'application/x-javascript',
+    },
+    audio: {
+        basic: 'audio/basic',
+        L24: 'audio/L24',
+        mp4: 'audio/mp4',
+        aac: 'audio/aac',
+        mpeg: 'audio/mpeg',
+        ogg: 'audio/ogg',
+        vorbis: 'audio/vorbis',
+        xMsWma: 'audio/x-ms-wma',
+        xMsWax: 'audio/x-ms-wax',
+        vndRnRealaudio: 'audio/vnd.rn-realaudio',
+        vndWave: 'audio/vnd.wave',
+        webm: 'audio/webm',
+    },
+    image: {
+        gif: 'image/gif',
+        jpeg: 'image/jpeg',
+        pjpeg: 'image/pjpeg',
+        png: 'image/png',
+        svgXml: 'image/svg+xml',
+        tiff: 'image/tiff',
+        vndMicrosoftIcon: 'image/vnd.microsoft.icon',
+        vndWapWbmp: 'image/vnd.wap.wbmp',
+        webp: 'image/webp',
+    },
+    message: {
+        http: 'message/http',
+        imdnXml: 'message/imdn+xml',
+        partial: 'message/partial',
+        rfc822: 'message/rfc822',
+    },
+    model: {
+        example: 'model/example',
+        iges: 'model/iges',
+        mesh: 'model/mesh',
+        vrml: 'model/vrml',
+        x3dBinary: 'model/x3d+binary',
+        x3dVrml: 'model/x3d+vrml',
+        x3dXml: 'model/x3d+xml',
+    },
+    text: {
+        cmd: 'text/cmd',
+        css: 'text/css',
+        csv: 'text/csv',
+        html: 'text/html',
+        plain: 'text/plain',
+        php: 'text/php',
+        xml: 'text/xml',
+        markdown: 'text/markdown',
+        cacheManifest: 'text/cache-manifest',
+    },
+    video: {
+        mpeg: 'video/mpeg',
+        mp4: 'video/mp4',
+        ogg: 'video/ogg',
+        quicktime: 'video/quicktime',
+        webm: 'video/webm',
+        xMsWmv: 'video/x-ms-wmv',
+        xFlv: 'video/x-flv',
+        xMsvideo: 'video/x-msvideo',
+        threeGpp: 'video/3gpp',
+        threeGpp2: 'video/3gpp2',
+    },
+};
+
+class BaseWooksResponseRenderer {
+    render(response) {
+        if (typeof response.body === 'string' || typeof response.body === 'boolean' || typeof response.body === 'number') {
+            if (!response.getContentType())
+                response.setContentType(contentTypes.text.plain);
+            return response.body.toString();
+        }
+        if (typeof response.body === 'undefined') {
+            return '';
+        }
+        if (typeof response.body === 'object') {
+            if (!response.getContentType())
+                response.setContentType(contentTypes.application.json);
+            return JSON.stringify(response.body);
+        }
+        throw panic('Unsupported body format "' + typeof response.body + '"');
+    }
+}
+
+const xForwardedFor = 'x-forwarded-for';
+function useRequest() {
+    const reqCache = useCacheObject(innerCacheSymbols.request);
+    const { req, customContext } = useCurrentWooksContext().getCtx();
+    async function rawBody() {
+        if (typeof reqCache.rawBody === 'undefined') {
+            reqCache.rawBody = new Promise((resolve, reject) => {
+                let body = Buffer.from('');
+                req.on('data', function (chunk) {
+                    body = Buffer.concat([body, chunk]);
+                });
+                req.on('error', function (err) {
+                    reject(err);
+                });
+                req.on('end', function () {
+                    resolve(body);
+                });
+            });
+        }
+        return reqCache.rawBody;
+    }
+    function reqId() {
+        if (!reqCache.reqId) {
+            reqCache.reqId = randomUUID();
+        }
+        return reqCache.reqId;
+    }
+    function getIp(options) {
+        var _a, _b, _c;
+        if (options === null || options === void 0 ? void 0 : options.trustProxy) {
+            if (typeof reqCache.forwardedIp !== 'string') {
+                if (typeof req.headers[xForwardedFor] === 'string' && req.headers[xForwardedFor]) {
+                    reqCache.forwardedIp = (_a = req.headers[xForwardedFor].split(',').shift()) === null || _a === void 0 ? void 0 : _a.trim();
+                }
+                else {
+                    return getIp();
+                }
+            }
+            return reqCache.forwardedIp || '';
+        }
+        else {
+            if (typeof reqCache.remoteIp !== 'string') {
+                reqCache.remoteIp = ((_b = req.socket) === null || _b === void 0 ? void 0 : _b.remoteAddress) || ((_c = req.connection) === null || _c === void 0 ? void 0 : _c.remoteAddress) || '';
+            }
+            return reqCache.remoteIp;
+        }
+    }
+    function getIpList() {
+        var _a, _b;
+        if (!reqCache.ipList) {
+            reqCache.ipList = {
+                remoteIp: ((_a = req.socket) === null || _a === void 0 ? void 0 : _a.remoteAddress) || ((_b = req.connection) === null || _b === void 0 ? void 0 : _b.remoteAddress) || '',
+                forwarded: (req.headers[xForwardedFor] || '').split(',').map(s => s.trim()),
+            };
+        }
+        return reqCache.ipList;
+    }
+    return {
+        rawRequest: req,
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        rawBody,
+        reqId,
+        getIp,
+        getIpList,
+        customContext,
+    };
+}
+function useResponse() {
+    const cache = useCacheObject(innerCacheSymbols.response);
+    const res = useCurrentWooksContext().getCtx().res;
+    const statusCache = useCacheObject(innerCacheSymbols.status);
+    function status(code) {
+        if (code) {
+            statusCache.code = code;
+        }
+        return statusCache.code;
+    }
+    const rawResponse = (options) => {
+        if (!options || !options.passthrough)
+            cache.responded = true;
+        return res;
+    };
+    const hasResponded = () => cache.responded;
+    return {
+        rawResponse,
+        hasResponded,
+        status,
+    };
+}
+function useRouteParams() {
+    const routeParams = useCurrentWooksContext().getCtx().params;
+    function getRouteParam(name) {
+        return routeParams[name];
+    }
+    return {
+        routeParams,
+        getRouteParam,
+    };
+}
+
+function useHeaders() {
+    return useRequest().headers;
+}
+function useSetHeaders() {
+    const cache = useCacheObject(innerCacheSymbols.setHeader);
+    function setHeader(name, value) {
+        cache[name] = value.toString();
+    }
+    function removeHeader(name) {
+        delete cache[name];
+    }
+    function setContentType(value) {
+        setHeader('Content-Type', value);
+    }
+    function enableCors(origin = '*') {
+        setHeader('Access-Control-Allow-Origin', origin);
+    }
+    return {
+        setHeader,
+        removeHeader,
+        setContentType,
+        headers: cache,
+        enableCors,
+    };
+}
+
+function useAccept() {
+    const { accept } = useHeaders();
+    const cache = useCacheObject(innerCacheSymbols.accept);
+    const accepts = (mime) => {
+        if (typeof cache[mime] !== 'boolean') {
+            cache[mime] = !!(accept && (accept === '*/*' || accept.indexOf(mime) >= 0));
+        }
+        return cache[mime];
+    };
+    return {
+        accept,
+        accepts,
+        acceptsJson: () => accepts(contentTypes.application.json),
+        acceptsXml: () => accepts(contentTypes.application.xml),
+        acceptsText: () => accepts(contentTypes.text.plain),
+        acceptsHtml: () => accepts(contentTypes.text.html),
+    };
+}
+
+function useAuthorization() {
+    const { authorization } = useHeaders();
+    const cache = useCacheObject(innerCacheSymbols.authorization);
+    const authType = () => {
+        if (authorization) {
+            if (typeof cache.type === 'undefined') {
+                const space = authorization.indexOf(' ');
+                cache.type = authorization.slice(0, space);
+            }
+            return cache.type;
+        }
+        return null;
+    };
+    const authRawCredentials = () => {
+        if (authorization) {
+            if (typeof cache.credentials === 'undefined') {
+                const space = authorization.indexOf(' ');
+                cache.credentials = authorization.slice(space + 1);
+            }
+            return cache.credentials;
+        }
+        return null;
+    };
+    return {
+        authorization,
+        authType,
+        authRawCredentials,
+        isBasic: () => { var _a; return ((_a = authType()) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === 'basic'; },
+        isBearer: () => { var _a; return ((_a = authType()) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === 'bearer'; },
+        basicCredentials: () => {
+            if (authorization) {
+                if (typeof cache.basicCredentials === 'undefined') {
+                    const type = authType();
+                    if ((type === null || type === void 0 ? void 0 : type.toLocaleLowerCase()) === 'basic') {
+                        const creds = Buffer.from(authRawCredentials() || '', 'base64').toString('ascii');
+                        const [username, password] = creds.split(':');
+                        cache.basicCredentials = { username, password };
+                    }
+                }
+                return cache.basicCredentials;
+            }
+            return null;
+        },
+    };
+}
+
+function convertTime(time, unit = 'ms') {
+    if (typeof time === 'number')
+        return time / units[unit];
+    const rg = /(\d+)(\w+)/g;
+    let t = 0;
+    let r;
+    while (r = rg.exec(time)) {
+        t += Number(r[1]) * (units[r[2]] || 0);
+    }
+    return t / units[unit];
+}
+const units = {
+    ms: 1,
+    s: 1000,
+    m: 1000 * 60,
+    h: 1000 * 60 * 60,
+    d: 1000 * 60 * 60 * 24,
+    w: 1000 * 60 * 60 * 24 * 7,
+    M: 1000 * 60 * 60 * 24 * 30,
+    Y: 1000 * 60 * 60 * 24 * 365,
+};
+
+function renderCacheControl(data) {
+    let attrs = '';
+    for (const [a, v] of Object.entries(data)) {
+        if (typeof v === 'undefined')
+            continue;
+        const func = cacheControlFunc[a];
+        if (typeof func === 'function') {
+            const val = func(v);
+            if (val) {
+                attrs += attrs ? ', ' + val : val;
+            }
+        }
+        else {
+            panic('Unknown Cache-Control attribute ' + a);
+        }
+    }
+    return attrs;
+}
+const cacheControlFunc = {
+    mustRevalidate: (v) => v ? 'must-revalidate' : '',
+    noCache: (v) => v ? (typeof v === 'string' ? `no-cache="${v}"` : 'no-cache') : '',
+    noStore: (v) => v ? 'no-store' : '',
+    noTransform: (v) => v ? 'no-transform' : '',
+    public: (v) => v ? 'public' : '',
+    private: (v) => v ? (typeof v === 'string' ? `private="${v}"` : 'private') : '',
+    proxyRevalidate: (v) => v ? 'proxy-revalidate' : '',
+    maxAge: (v) => 'max-age=' + convertTime(v, 's').toString(),
+    sMaxage: (v) => 's-maxage=' + convertTime(v, 's').toString(),
+};
+
+const renderAge = (v) => convertTime(v, 's').toString();
+const renderExpires = (v) => (typeof v === 'string' || typeof v === 'number' ? new Date(v).toUTCString() : v.toUTCString());
+const renderPragmaNoCache = (v) => v ? 'no-cache' : '';
+function useSetCacheControl() {
+    const { setHeader } = useSetHeaders();
+    const setAge = (value) => {
+        setHeader('Age', renderAge(value));
+    };
+    const setExpires = (value) => {
+        setHeader('Expires', renderExpires(value));
+    };
+    const setPragmaNoCache = (value = true) => {
+        setHeader('Pragma', renderPragmaNoCache(value));
+    };
+    const setCacheControl = (data) => {
+        setHeader('Cache-Control', renderCacheControl(data));
+    };
+    return {
+        setExpires,
+        setAge,
+        setPragmaNoCache,
+        setCacheControl,
+    };
+}
+
+function renderCookie(key, data) {
+    let attrs = '';
+    for (const [a, v] of Object.entries(data.attrs)) {
+        const func = cookieAttrFunc[a];
+        if (typeof func === 'function') {
+            const val = func(v);
+            attrs += val ? '; ' + val : '';
+        }
+        else {
+            panic('Unknown Set-Cookie attribute ' + a);
+        }
+    }
+    return `${key}=${encodeURIComponent(data.value)}${attrs}`;
+}
+const cookieAttrFunc = {
+    expires: (v) => 'Expires=' + (typeof v === 'string' || typeof v === 'number' ? new Date(v).toUTCString() : v.toUTCString()),
+    maxAge: (v) => 'Max-Age=' + convertTime(v, 's').toString(),
+    domain: (v) => 'Domain=' + v,
+    path: (v) => 'Path=' + v,
+    secure: (v) => v ? 'Secure' : '',
+    httpOnly: (v) => v ? 'HttpOnly' : '',
+    sameSite: (v) => v ? 'SameSite=' + (typeof v === 'string' ? v : 'Strict') : '',
+};
+
+function useCookies() {
+    const cache = useCacheObject(innerCacheSymbols.cookies);
+    const { cookie } = useHeaders();
+    function getCookie(name) {
+        if (typeof cache[name] === 'undefined') {
+            if (cookie) {
+                const result = new RegExp(`(?:^|; )${escapeRegex(name)}=(.*?)(?:;?$|; )`, 'i').exec(cookie);
+                cache[name] = result && result[1] ? safeDecodeURIComponent(result[1]) : null;
+            }
+            else {
+                cache[name] = null;
+            }
+        }
+        return cache[name];
+    }
+    return {
+        rawCookies: cookie,
+        getCookie,
+    };
+}
+function useSetCookies() {
+    const cache = useCacheObject(innerCacheSymbols.setCookies);
+    function setCookie(name, value, attrs) {
+        cache[name] = {
+            value,
+            attrs: attrs || {},
+        };
+    }
+    function cookies() {
+        return Object.entries(cache).map(([key, value]) => renderCookie(key, value));
+    }
+    function removeCookie(name) {
+        delete cache[name];
+    }
+    function clearCookies() {
+        clearCacheObject(innerCacheSymbols.setCookies);
+    }
+    return {
+        setCookie,
+        removeCookie,
+        clearCookies,
+        cookies,
+    };
+}
+
+class ProstoURLSearchParams extends URLSearchParams {
+    toJson() {
+        const json = {};
+        for (const [key, value] of this.entries()) {
+            if (isArrayParam(key)) {
+                const a = json[key] = (json[key] || []);
+                a.push(value);
+            }
+            else {
+                json[key] = value;
+            }
+        }
+        return json;
+    }
+}
+function isArrayParam(name) {
+    return name.endsWith('[]');
+}
+
+function useSearchParams() {
+    const url = useRequest().url || '';
+    const cache = useCacheObject(innerCacheSymbols.searchParams);
+    function rawSearchParams() {
+        if (typeof cache.raw === 'undefined') {
+            const i = url.indexOf('?');
+            cache.raw = i >= 0 ? url.slice(i) : '';
+        }
+        return cache.raw;
+    }
+    function urlSearchParams() {
+        if (!cache.urlSearchParams) {
+            cache.urlSearchParams = new ProstoURLSearchParams(rawSearchParams());
+        }
+        return cache.urlSearchParams;
+    }
+    return {
+        rawSearchParams,
+        urlSearchParams,
+        jsonSearchParams: () => urlSearchParams().toJson(),
+    };
+}
+
+const compressors = {
+    identity: {
+        compress: v => v,
+        uncompress: v => v,
+    },
+};
+async function uncompressBody(encodings, body) {
+    let newBody = body;
+    for (const e of encodings.reverse()) {
+        if (!compressors[e]) {
+            throw panic(`Usupported compression type "${e}".`);
+        }
+        newBody = await compressors[e].uncompress(body);
+    }
+    return newBody;
+}
+
+function useBody() {
+    const cache = useCacheObject(innerCacheSymbols.request);
+    const { rawBody } = useRequest();
+    const { 'content-type': contentType, 'content-encoding': contentEncoding } = useHeaders();
+    function contentIs(type) {
+        return (contentType || '').indexOf(type) >= 0;
+    }
+    function isJson() {
+        if (typeof cache.isJson === 'undefined') {
+            cache.isJson = contentIs(contentTypes.application.json);
+        }
+        return cache.isJson;
+    }
+    function isHtml() {
+        if (typeof cache.isHtml === 'undefined') {
+            cache.isHtml = contentIs(contentTypes.text.html);
+        }
+        return cache.isHtml;
+    }
+    function isXml() {
+        if (typeof cache.isXml === 'undefined') {
+            cache.isXml = contentIs(contentTypes.text.xml);
+        }
+        return cache.isXml;
+    }
+    function isText() {
+        if (typeof cache.isText === 'undefined') {
+            cache.isText = contentIs(contentTypes.text.plain);
+        }
+        return cache.isText;
+    }
+    function isBinary() {
+        if (typeof cache.isBinary === 'undefined') {
+            cache.isBinary = contentIs(contentTypes.application.octetStream);
+        }
+        return cache.isBinary;
+    }
+    function isFormData() {
+        if (typeof cache.isFormData === 'undefined') {
+            cache.isFormData = contentIs('multipart/form-data');
+        }
+        return cache.isFormData;
+    }
+    function isUrlencoded() {
+        if (typeof cache.isUrlencoded === 'undefined') {
+            cache.isUrlencoded = contentIs(contentTypes.application.xWwwFormUrlencoded);
+        }
+        return cache.isUrlencoded;
+    }
+    function isCompressed() {
+        if (typeof cache.isCompressed === 'undefined') {
+            const parts = contentEncodings();
+            for (const p of parts) {
+                cache.isCompressed = ['deflate', 'gzip', 'br'].includes(p);
+                if (cache.isCompressed)
+                    break;
+            }
+        }
+        return cache.isCompressed;
+    }
+    function contentEncodings() {
+        if (typeof cache.contentEncodings === 'undefined') {
+            cache.contentEncodings = (contentEncoding || '').split(',').map(p => p.trim()).filter(p => !!p);
+        }
+        return cache.contentEncodings;
+    }
+    async function parseBody() {
+        if (typeof cache.parsed === 'undefined') {
+            const body = await uncompressBody(contentEncodings(), (await rawBody()).toString());
+            if (isJson()) {
+                cache.parsed = jsonParser(body);
+            }
+            else if (isFormData()) {
+                cache.parsed = formDataParser(body);
+            }
+            else if (isUrlencoded()) {
+                cache.parsed = urlEncodedParser(body);
+            }
+            else if (isBinary()) {
+                cache.parsed = textParser(body);
+            }
+            else {
+                cache.parsed = textParser(body);
+            }
+        }
+        return cache.parsed;
+    }
+    function jsonParser(v) {
+        try {
+            return JSON.parse(v);
+        }
+        catch (e) {
+            throw new WooksError(400, e.message);
+        }
+    }
+    function textParser(v) {
+        return v;
+    }
+    function formDataParser(v) {
+        const boundary = '--' + (/boundary=([^;]+)(?:;|$)/.exec(contentType || '') || [, ''])[1];
+        if (!boundary)
+            throw new WooksError(EHttpStatusCode.BadRequest, 'form-data boundary not recognized');
+        const parts = v.trim().split(boundary);
+        const result = {};
+        let key = '';
+        let partContentType = 'text/plain';
+        for (const part of parts) {
+            parsePart();
+            key = '';
+            partContentType = 'text/plain';
+            let valueMode = false;
+            const lines = part.trim().split(/\n/g).map(s => s.trim());
+            for (const line of lines) {
+                if (valueMode) {
+                    if (!result[key]) {
+                        result[key] = line;
+                    }
+                    else {
+                        result[key] += '\n' + line;
+                    }
+                }
+                else {
+                    if (!line || line === '--') {
+                        valueMode = !!key;
+                        if (valueMode) {
+                            key = key.replace(/^["']/, '').replace(/["']$/, '');
+                        }
+                        continue;
+                    }
+                    if (line.toLowerCase().startsWith('content-disposition: form-data;')) {
+                        key = (/name=([^;]+)/.exec(line) || [])[1];
+                        if (!key)
+                            throw new WooksError(EHttpStatusCode.BadRequest, 'Could not read multipart name: ' + line);
+                        continue;
+                    }
+                    if (line.toLowerCase().startsWith('content-type:')) {
+                        partContentType = (/content-type:\s?([^;]+)/i.exec(line) || [])[1];
+                        if (!partContentType)
+                            throw new WooksError(EHttpStatusCode.BadRequest, 'Could not read content-type: ' + line);
+                        continue;
+                    }
+                }
+            }
+        }
+        parsePart();
+        function parsePart() {
+            if (key) {
+                if (partContentType.indexOf(contentTypes.application.json) >= 0) {
+                    result[key] = JSON.parse(result[key]);
+                }
+            }
+        }
+        return result;
+    }
+    function urlEncodedParser(v) {
+        return new ProstoURLSearchParams(v.trim()).toJson();
+    }
+    return {
+        isJson,
+        isHtml,
+        isXml,
+        isText,
+        isBinary,
+        isFormData,
+        isUrlencoded,
+        isCompressed,
+        contentEncodings,
+        parseBody,
+        rawBody,
+    };
+}
+function registerBodyCompressor(name, compressor) {
+    if (compressors[name]) {
+        throw panic(`Body compressor "${name}" already registered.`);
+    }
+    compressors[name] = compressor;
+}
+
+function setTestHttpContext(options) {
+    const req = new IncomingMessage(new Socket({}));
+    req.method = options.method || 'GET';
+    req.headers = options.headers || {};
+    req.url = options.url;
+    const res = new ServerResponse(req);
+    const cache = {};
+    if (options.cachedContext) {
+        const fromInnerContext = [
+            'cookies',
+            'authorization',
+        ];
+        for (const key of Object.keys(options.cachedContext)) {
+            if (fromInnerContext.includes(key)) {
+                cache[innerCacheSymbols[key]] = options.cachedContext[key];
+            }
+            else if (key === 'body') {
+                cache[innerCacheSymbols.request] = cache[innerCacheSymbols.request] || {};
+                Object.assign(cache[innerCacheSymbols.request], { parsed: options.cachedContext[key] });
+            }
+            else if (key === 'rawBody') {
+                cache[innerCacheSymbols.request] = cache[innerCacheSymbols.request] || {};
+                Object.assign(cache[innerCacheSymbols.request], { rawBody: options.cachedContext[key] });
+            }
+            else {
+                cache[key] = options.cachedContext[key];
+            }
+        }
+    }
+    setCurrentWooksContext(req, res, options.params || {}, cache);
+}
+
+const httpStatusCodes = {
+    [100]: 'Continue',
+    [101]: 'Switching protocols',
+    [102]: 'Processing',
+    [103]: 'Early Hints',
+    [200]: 'OK',
+    [201]: 'Created',
+    [202]: 'Accepted',
+    [203]: 'Non-Authoritative Information',
+    [204]: 'No Content',
+    [205]: 'Reset Content',
+    [206]: 'Partial Content',
+    [207]: 'Multi-Status',
+    [208]: 'Already Reported',
+    [226]: 'IM Used',
+    [300]: 'Multiple Choices',
+    [301]: 'Moved Permanently',
+    [302]: 'Found (Previously "Moved Temporarily")',
+    [303]: 'See Other',
+    [304]: 'Not Modified',
+    [305]: 'Use Proxy',
+    [306]: 'Switch Proxy',
+    [307]: 'Temporary Redirect',
+    [308]: 'Permanent Redirect',
+    [400]: 'Bad Request',
+    [401]: 'Unauthorized',
+    [402]: 'Payment Required',
+    [403]: 'Forbidden',
+    [404]: 'Not Found',
+    [405]: 'Method Not Allowed',
+    [406]: 'Not Acceptable',
+    [407]: 'Proxy Authentication Required',
+    [408]: 'Request Timeout',
+    [409]: 'Conflict',
+    [410]: 'Gone',
+    [411]: 'Length Required',
+    [412]: 'Precondition Failed',
+    [413]: 'Payload Too Large',
+    [414]: 'URI Too Long',
+    [415]: 'Unsupported Media Type',
+    [416]: 'Range Not Satisfiable',
+    [417]: 'Expectation Failed',
+    [418]: 'I\'m a Teapot',
+    [421]: 'Misdirected Request',
+    [422]: 'Unprocessable Entity',
+    [423]: 'Locked',
+    [424]: 'Failed Dependency',
+    [425]: 'Too Early',
+    [426]: 'Upgrade Required',
+    [428]: 'Precondition Required',
+    [429]: 'Too Many Requests',
+    [431]: 'Request Header Fields Too Large',
+    [451]: 'Unavailable For Legal Reasons',
+    [500]: 'Internal Server Error',
+    [501]: 'Not Implemented',
+    [502]: 'Bad Gateway',
+    [503]: 'Service Unavailable',
+    [504]: 'Gateway Timeout',
+    [505]: 'HTTP Version Not Supported',
+    [506]: 'Variant Also Negotiates',
+    [507]: 'Insufficient Storage',
+    [508]: 'Loop Detected',
+    [510]: 'Not Extended',
+    [511]: 'Network Authentication Required',
+};
+var EHttpStatusCode;
+(function (EHttpStatusCode) {
+    EHttpStatusCode[EHttpStatusCode["Continue"] = 100] = "Continue";
+    EHttpStatusCode[EHttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    EHttpStatusCode[EHttpStatusCode["Processing"] = 102] = "Processing";
+    EHttpStatusCode[EHttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
+    EHttpStatusCode[EHttpStatusCode["OK"] = 200] = "OK";
+    EHttpStatusCode[EHttpStatusCode["Created"] = 201] = "Created";
+    EHttpStatusCode[EHttpStatusCode["Accepted"] = 202] = "Accepted";
+    EHttpStatusCode[EHttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    EHttpStatusCode[EHttpStatusCode["NoContent"] = 204] = "NoContent";
+    EHttpStatusCode[EHttpStatusCode["ResetContent"] = 205] = "ResetContent";
+    EHttpStatusCode[EHttpStatusCode["PartialContent"] = 206] = "PartialContent";
+    EHttpStatusCode[EHttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
+    EHttpStatusCode[EHttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
+    EHttpStatusCode[EHttpStatusCode["IMUsed"] = 226] = "IMUsed";
+    EHttpStatusCode[EHttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
+    EHttpStatusCode[EHttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
+    EHttpStatusCode[EHttpStatusCode["Found"] = 302] = "Found";
+    EHttpStatusCode[EHttpStatusCode["SeeOther"] = 303] = "SeeOther";
+    EHttpStatusCode[EHttpStatusCode["NotModified"] = 304] = "NotModified";
+    EHttpStatusCode[EHttpStatusCode["UseProxy"] = 305] = "UseProxy";
+    EHttpStatusCode[EHttpStatusCode["SwitchProxy"] = 306] = "SwitchProxy";
+    EHttpStatusCode[EHttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    EHttpStatusCode[EHttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
+    EHttpStatusCode[EHttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    EHttpStatusCode[EHttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    EHttpStatusCode[EHttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
+    EHttpStatusCode[EHttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    EHttpStatusCode[EHttpStatusCode["NotFound"] = 404] = "NotFound";
+    EHttpStatusCode[EHttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    EHttpStatusCode[EHttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
+    EHttpStatusCode[EHttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    EHttpStatusCode[EHttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
+    EHttpStatusCode[EHttpStatusCode["Conflict"] = 409] = "Conflict";
+    EHttpStatusCode[EHttpStatusCode["Gone"] = 410] = "Gone";
+    EHttpStatusCode[EHttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
+    EHttpStatusCode[EHttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
+    EHttpStatusCode[EHttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    EHttpStatusCode[EHttpStatusCode["URITooLong"] = 414] = "URITooLong";
+    EHttpStatusCode[EHttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    EHttpStatusCode[EHttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    EHttpStatusCode[EHttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
+    EHttpStatusCode[EHttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
+    EHttpStatusCode[EHttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    EHttpStatusCode[EHttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    EHttpStatusCode[EHttpStatusCode["Locked"] = 423] = "Locked";
+    EHttpStatusCode[EHttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
+    EHttpStatusCode[EHttpStatusCode["TooEarly"] = 425] = "TooEarly";
+    EHttpStatusCode[EHttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
+    EHttpStatusCode[EHttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
+    EHttpStatusCode[EHttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
+    EHttpStatusCode[EHttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    EHttpStatusCode[EHttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    EHttpStatusCode[EHttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
+    EHttpStatusCode[EHttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
+    EHttpStatusCode[EHttpStatusCode["BadGateway"] = 502] = "BadGateway";
+    EHttpStatusCode[EHttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    EHttpStatusCode[EHttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+    EHttpStatusCode[EHttpStatusCode["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+    EHttpStatusCode[EHttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    EHttpStatusCode[EHttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
+    EHttpStatusCode[EHttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
+    EHttpStatusCode[EHttpStatusCode["NotExtended"] = 510] = "NotExtended";
+    EHttpStatusCode[EHttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(EHttpStatusCode || (EHttpStatusCode = {}));
+
+const defaultStatus = {
+    GET: EHttpStatusCode.OK,
+    POST: EHttpStatusCode.Created,
+    PUT: EHttpStatusCode.Created,
+    PATCH: EHttpStatusCode.Accepted,
+    DELETE: EHttpStatusCode.Accepted,
+};
+const baseRenderer = new BaseWooksResponseRenderer();
+class BaseWooksResponse {
+    constructor(renderer = baseRenderer) {
+        this.renderer = renderer;
+        this._status = 0;
+        this._headers = {};
+    }
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+    }
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = value;
+    }
+    setStatus(value) {
+        this.status = value;
+        return this;
+    }
+    setBody(value) {
+        this.body = value;
+        return this;
+    }
+    getContentType() {
+        return this._headers['Content-Type'];
+    }
+    setContentType(value) {
+        this._headers['Content-Type'] = value;
+        return this;
+    }
+    enableCors(origin = '*') {
+        this._headers['Access-Control-Allow-Origin'] = origin;
+        return this;
+    }
+    setCookie(name, value, attrs) {
+        const cookies = this._headers['Set-Cookie'] = (this._headers['Set-Cookie'] || []);
+        cookies.push(renderCookie(name, { value, attrs: attrs || {} }));
+        return this;
+    }
+    setCacheControl(data) {
+        this.setHeader('Cache-Control', renderCacheControl(data));
+    }
+    setCookieRaw(rawValue) {
+        const cookies = this._headers['Set-Cookie'] = (this._headers['Set-Cookie'] || []);
+        cookies.push(rawValue);
+        return this;
+    }
+    header(name, value) {
+        this._headers[name] = value;
+        return this;
+    }
+    setHeader(name, value) {
+        return this.header(name, value);
+    }
+    getHeader(name) {
+        return this._headers[name];
+    }
+    mergeHeaders() {
+        const { headers } = useSetHeaders();
+        const { cookies, removeCookie } = useSetCookies();
+        const newCookies = (this._headers['Set-Cookie'] || []);
+        for (const cookie of newCookies) {
+            removeCookie(cookie.slice(0, cookie.indexOf('=')));
+        }
+        this._headers = {
+            ...headers,
+            ...this._headers,
+        };
+        const setCookie = [...newCookies, ...cookies()];
+        if (setCookie && setCookie.length) {
+            this._headers['Set-Cookie'] = setCookie;
+        }
+        return this;
+    }
+    mergeStatus(renderedBody) {
+        this.status = this.status || useResponse().status();
+        if (!this.status) {
+            const { method } = useRequest();
+            this.status = renderedBody ? defaultStatus[method] || EHttpStatusCode.OK : EHttpStatusCode.NoContent;
+        }
+        return this;
+    }
+    respond() {
+        const { rawResponse, hasResponded } = useResponse();
+        const { method, rawRequest } = useRequest();
+        if (hasResponded()) {
+            throw panic('The response was already sent.');
+        }
+        this.mergeHeaders();
+        const res = rawResponse();
+        if (this.body instanceof Readable) {
+            const stream = this.body;
+            this.mergeStatus('ok');
+            res.writeHead(this.status, {
+                ...this._headers,
+            });
+            rawRequest.once('close', () => {
+                stream.destroy();
+            });
+            if (method === 'HEAD') {
+                stream.destroy();
+                res.end();
+            }
+            else {
+                stream.on('error', () => {
+                    stream.destroy();
+                    res.end();
+                });
+                stream.on('close', () => {
+                    stream.destroy();
+                });
+                stream.pipe(res);
+            }
+        }
+        else {
+            const renderedBody = this.renderer.render(this);
+            this.mergeStatus(renderedBody);
+            res.writeHead(this.status, {
+                'Content-Length': Buffer.byteLength(renderedBody),
+                ...this._headers,
+            }).end(method !== 'HEAD' ? renderedBody : '');
+        }
+    }
+}
+
+const preStyles = 'font-family: monospace;'
+    + 'width: 100%;'
+    + 'max-width: 900px;'
+    + 'padding: 10px;'
+    + 'margin: 20px auto;'
+    + 'border-radius: 8px;'
+    + 'background-color: #494949;'
+    + 'box-shadow: 0px 0px 3px 2px rgb(255 255 255 / 20%);';
+class WooksErrorRenderer extends BaseWooksResponseRenderer {
+    renderHtml(response) {
+        const data = response.body || {};
+        response.setContentType(contentTypes.text.html);
+        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
+        return '<html style="background-color: #333; color: #bbb;">' +
+            `<head><title>${data.statusCode} ${httpStatusCodes[data.statusCode]}</title></head>` +
+            `<body><center><h1>${data.statusCode} ${httpStatusCodes[data.statusCode]}</h1></center>` +
+            `<center><h4>${data.message}</h1></center><hr color="#666">` +
+            `<center style="color: #666;"> wooks v${"0.0.1-alpha.10"} </center>` +
+            `${keys.length ? `<pre style="${preStyles}">${JSON.stringify({ ...data, statusCode: undefined, message: undefined, error: undefined }, null, '  ')}</pre>` : ''}` +
+            '</body></html>';
+    }
+    renderText(response) {
+        const data = response.body || {};
+        response.setContentType(contentTypes.text.plain);
+        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
+        return `${data.statusCode} ${httpStatusCodes[data.statusCode]}\n${data.message}`
+            + `\n\n${keys.length ? `${JSON.stringify({ ...data, statusCode: undefined, message: undefined, error: undefined }, null, '  ')}` : ''}`;
+    }
+    renderJson(response) {
+        const data = response.body || {};
+        response.setContentType(contentTypes.application.json);
+        const keys = Object.keys(data).filter(key => !['statusCode', 'error', 'message'].includes(key));
+        return `{"statusCode":${escapeQuotes(data.statusCode)},`
+            + `"error":"${escapeQuotes(data.error)}",`
+            + `"message":"${escapeQuotes(data.message)}"`
+            + `${keys.length ? (',' + keys.map(k => `"${escapeQuotes(k)}":${JSON.stringify(data[k])}`).join(',')) : ''}}`;
+    }
+    render(response) {
+        var _a;
+        const { acceptsJson, acceptsText, acceptsHtml } = useAccept();
+        response.status = ((_a = response.body) === null || _a === void 0 ? void 0 : _a.statusCode) || 500;
+        if (acceptsJson()) {
+            return this.renderJson(response);
+        }
+        else if (acceptsHtml()) {
+            return this.renderHtml(response);
+        }
+        else if (acceptsText()) {
+            return this.renderText(response);
+        }
+        else {
+            return this.renderJson(response);
+        }
+    }
+}
+function escapeQuotes(s) {
+    return (typeof s === 'number' ? s : (s || '')).toString().replace(/[\""]/g, '\\"');
+}
+
+class WooksError extends Error {
+    constructor(code = 500, _body = '') {
+        super(typeof _body === 'string' ? _body : _body.message);
+        this.code = code;
+        this._body = _body;
+    }
+    get body() {
+        return typeof this._body === 'string' ? {
+            statusCode: this.code,
+            message: this.message,
+            error: httpStatusCodes[this.code],
+        } : {
+            ...this._body,
+            statusCode: this.code,
+            message: this.message,
+            error: httpStatusCodes[this.code],
+        };
+    }
+    attachRenderer(renderer) {
+        this.renderer = renderer;
+    }
+    getRenderer() {
+        return this.renderer;
+    }
+}
+
+function createResponseFrom(data) {
+    const { hasResponded } = useResponse();
+    if (hasResponded())
+        return null;
+    if (data instanceof Error) {
+        const r = new BaseWooksResponse(new WooksErrorRenderer());
+        let httpError;
+        if (data instanceof WooksError) {
+            httpError = data;
+        }
+        else {
+            httpError = new WooksError(500, data.message);
+        }
+        r.setBody(httpError.body);
+        return r;
+    }
+    else if (data instanceof BaseWooksResponse) {
+        return data;
+    }
+    else {
+        return new BaseWooksResponse().setBody(data);
+    }
+}
+
+class Wooks {
+    constructor(options) {
+        this.options = options;
+        this.router = new ProstoRouter();
+        this._uncoughtExceptionHandler = ((err) => {
+            this.printError('Uncought exception: ', err);
+        }).bind(this);
+    }
+    listen(port, hostname, cb) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            const myCb = () => {
+                var _a;
+                const fn = typeof hostname === 'function' ? hostname : cb;
+                process.on('uncaughtException', this._uncoughtExceptionHandler);
+                if (fn) {
+                    fn();
+                }
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.off('error', reject);
+                resolve();
+            };
+            try {
+                this.server = createServer({
+                    port,
+                }, this.processRequest.bind(this), typeof hostname === 'string' ? hostname : '', myCb);
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.on('error', reject);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            var _a;
+            (_a = this.server) === null || _a === void 0 ? void 0 : _a.close((err) => {
+                if (err)
+                    return reject(err);
+                process.off('uncaughtException', this._uncoughtExceptionHandler);
+                resolve(this.server);
+            });
+        });
+    }
+    processRequest(req, res) {
+        var _a;
+        const found = this.router.lookup(req.method, req.url);
+        const ctx = {
+            __setHeader: {
+                Server: 'wooks v' + "0.0.1-alpha.10",
+            },
+        };
+        if (found) {
+            const params = found.ctx.params;
+            setCurrentWooksContext(req, res, params, ctx);
+            const { restoreCtx } = useCurrentWooksContext();
+            this.processHandlers(req, res, found)
+                .catch((e) => {
+                var _a;
+                this.printError('Internal error, please report: ', e);
+                restoreCtx();
+                (_a = createResponseFrom(e)) === null || _a === void 0 ? void 0 : _a.respond();
+                clearCurrentWooksContext();
+                console.error('' + '' + banner(), e, '');
+            });
+        }
+        else {
+            setCurrentWooksContext(req, res, {}, ctx);
+            (_a = createResponseFrom(new WooksError(404))) === null || _a === void 0 ? void 0 : _a.respond();
+            clearCurrentWooksContext();
+        }
+    }
+    async processHandlers(req, res, found) {
+        var _a, _b;
+        const { restoreCtx } = useCurrentWooksContext();
+        for (const [i, handler] of found.route.handlers.entries()) {
+            const last = found.route.handlers.length === i + 1;
+            try {
+                restoreCtx();
+                const promise = handler();
+                clearCurrentWooksContext();
+                const result = await promise;
+                restoreCtx();
+                (_a = createResponseFrom(result)) === null || _a === void 0 ? void 0 : _a.respond();
+                clearCurrentWooksContext();
+                break;
+            }
+            catch (e) {
+                this.printError('Uncought route handler exception: ' + (req.url || '') + '\n', e);
+                if (last) {
+                    restoreCtx();
+                    (_b = createResponseFrom(e)) === null || _b === void 0 ? void 0 : _b.respond();
+                    clearCurrentWooksContext();
+                }
+            }
+        }
+    }
+    printError(expl, e) {
+        if (!(e instanceof WooksError)) {
+            panic(expl + e.message);
+            console.error('' + (e.stack || '') + '');
+        }
+    }
+    get(path, handler) {
+        this.router.on('HEAD', path, handler);
+        return this.router.on('GET', path, handler);
+    }
+    post(path, handler) {
+        return this.router.on('POST', path, handler);
+    }
+    put(path, handler) {
+        return this.router.on('PUT', path, handler);
+    }
+    delete(path, handler) {
+        return this.router.on('DELETE', path, handler);
+    }
+    patch(path, handler) {
+        return this.router.on('PATCH', path, handler);
+    }
+    on(method, path, handler) {
+        return this.router.on(method, path, handler);
+    }
+}
+
+const extensions = {
+    '123': 'application/vnd.lotus-1-2-3',
+    'ez': 'application/andrew-inset',
+    'aw': 'application/applixware',
+    'atom': 'application/atom+xml',
+    'atomcat': 'application/atomcat+xml',
+    'atomdeleted': 'application/atomdeleted+xml',
+    'atomsvc': 'application/atomsvc+xml',
+    'dwd': 'application/atsc-dwd+xml',
+    'held': 'application/atsc-held+xml',
+    'rsat': 'application/atsc-rsat+xml',
+    'bdoc': 'application/x-bdoc',
+    'xcs': 'application/calendar+xml',
+    'ccxml': 'application/ccxml+xml',
+    'cdfx': 'application/cdfx+xml',
+    'cdmia': 'application/cdmi-capability',
+    'cdmic': 'application/cdmi-container',
+    'cdmid': 'application/cdmi-domain',
+    'cdmio': 'application/cdmi-object',
+    'cdmiq': 'application/cdmi-queue',
+    'cpl': 'application/cpl+xml',
+    'cu': 'application/cu-seeme',
+    'cwl': 'application/cwl',
+    'mpd': 'application/dash+xml',
+    'mpp': 'application/vnd.ms-project',
+    'davmount': 'application/davmount+xml',
+    'dbk': 'application/docbook+xml',
+    'dssc': 'application/dssc+der',
+    'xdssc': 'application/dssc+xml',
+    'ecma': 'application/ecmascript',
+    'emma': 'application/emma+xml',
+    'emotionml': 'application/emotionml+xml',
+    'epub': 'application/epub+zip',
+    'exi': 'application/exi',
+    'exp': 'application/express',
+    'fdf': 'application/vnd.fdf',
+    'fdt': 'application/fdt+xml',
+    'pfr': 'application/font-tdpfr',
+    'geojson': 'application/geo+json',
+    'gml': 'application/gml+xml',
+    'gpx': 'application/gpx+xml',
+    'gxf': 'application/gxf',
+    'gz': 'application/gzip',
+    'hjson': 'application/hjson',
+    'stk': 'application/hyperstudio',
+    'ink': 'application/inkml+xml',
+    'inkml': 'application/inkml+xml',
+    'ipfix': 'application/ipfix',
+    'its': 'application/its+xml',
+    'jar': 'application/java-archive',
+    'war': 'application/java-archive',
+    'ear': 'application/java-archive',
+    'ser': 'application/java-serialized-object',
+    'class': 'application/java-vm',
+    'js': 'application/javascript',
+    'mjs': 'application/javascript',
+    'json': 'application/json',
+    'map': 'application/json',
+    'json5': 'application/json5',
+    'jsonml': 'application/jsonml+json',
+    'jsonld': 'application/ld+json',
+    'lgr': 'application/lgr+xml',
+    'lostxml': 'application/lost+xml',
+    'hqx': 'application/mac-binhex40',
+    'cpt': 'application/mac-compactpro',
+    'mads': 'application/mads+xml',
+    'webmanifest': 'application/manifest+json',
+    'mrc': 'application/marc',
+    'mrcx': 'application/marcxml+xml',
+    'ma': 'application/mathematica',
+    'nb': 'application/mathematica',
+    'mb': 'application/mathematica',
+    'mathml': 'application/mathml+xml',
+    'mbox': 'application/mbox',
+    'mpf': 'application/media-policy-dataset+xml',
+    'mscml': 'application/mediaservercontrol+xml',
+    'metalink': 'application/metalink+xml',
+    'meta4': 'application/metalink4+xml',
+    'mets': 'application/mets+xml',
+    'maei': 'application/mmt-aei+xml',
+    'musd': 'application/mmt-usd+xml',
+    'mods': 'application/mods+xml',
+    'm21': 'application/mp21',
+    'mp21': 'application/mp21',
+    'mp4s': 'application/mp4',
+    'm4p': 'application/mp4',
+    'doc': 'application/msword',
+    'dot': 'application/msword',
+    'mxf': 'application/mxf',
+    'nq': 'application/n-quads',
+    'nt': 'application/n-triples',
+    'cjs': 'application/node',
+    'bin': 'application/octet-stream',
+    'dms': 'application/octet-stream',
+    'lrf': 'application/octet-stream',
+    'mar': 'application/octet-stream',
+    'so': 'application/octet-stream',
+    'dist': 'application/octet-stream',
+    'distz': 'application/octet-stream',
+    'pkg': 'application/octet-stream',
+    'bpk': 'application/octet-stream',
+    'dump': 'application/octet-stream',
+    'elc': 'application/octet-stream',
+    'deploy': 'application/octet-stream',
+    'exe': 'application/x-msdownload',
+    'dll': 'application/x-msdownload',
+    'deb': 'application/x-debian-package',
+    'dmg': 'application/x-apple-diskimage',
+    'iso': 'application/x-iso9660-image',
+    'img': 'application/octet-stream',
+    'msi': 'application/x-msdownload',
+    'msp': 'application/octet-stream',
+    'msm': 'application/octet-stream',
+    'buffer': 'application/octet-stream',
+    'oda': 'application/oda',
+    'opf': 'application/oebps-package+xml',
+    'ogx': 'application/ogg',
+    'omdoc': 'application/omdoc+xml',
+    'onetoc': 'application/onenote',
+    'onetoc2': 'application/onenote',
+    'onetmp': 'application/onenote',
+    'onepkg': 'application/onenote',
+    'oxps': 'application/oxps',
+    'relo': 'application/p2p-overlay+xml',
+    'xer': 'application/patch-ops-error+xml',
+    'pdf': 'application/pdf',
+    'pgp': 'application/pgp-encrypted',
+    'asc': 'application/pgp-signature',
+    'sig': 'application/pgp-signature',
+    'prf': 'application/pics-rules',
+    'p10': 'application/pkcs10',
+    'p7m': 'application/pkcs7-mime',
+    'p7c': 'application/pkcs7-mime',
+    'p7s': 'application/pkcs7-signature',
+    'p8': 'application/pkcs8',
+    'ac': 'application/vnd.nokia.n-gage.ac+xml',
+    'cer': 'application/pkix-cert',
+    'crl': 'application/pkix-crl',
+    'pkipath': 'application/pkix-pkipath',
+    'pki': 'application/pkixcmp',
+    'pls': 'application/pls+xml',
+    'ai': 'application/postscript',
+    'eps': 'application/postscript',
+    'ps': 'application/postscript',
+    'provx': 'application/provenance+xml',
+    'cww': 'application/prs.cww',
+    'pskcxml': 'application/pskc+xml',
+    'raml': 'application/raml+yaml',
+    'rdf': 'application/rdf+xml',
+    'owl': 'application/rdf+xml',
+    'rif': 'application/reginfo+xml',
+    'rnc': 'application/relax-ng-compact-syntax',
+    'rl': 'application/resource-lists+xml',
+    'rld': 'application/resource-lists-diff+xml',
+    'rs': 'application/rls-services+xml',
+    'rapd': 'application/route-apd+xml',
+    'sls': 'application/route-s-tsid+xml',
+    'rusd': 'application/route-usd+xml',
+    'gbr': 'application/rpki-ghostbusters',
+    'mft': 'application/rpki-manifest',
+    'roa': 'application/rpki-roa',
+    'rsd': 'application/rsd+xml',
+    'rss': 'application/rss+xml',
+    'rtf': 'text/rtf',
+    'sbml': 'application/sbml+xml',
+    'scq': 'application/scvp-cv-request',
+    'scs': 'application/scvp-cv-response',
+    'spq': 'application/scvp-vp-request',
+    'spp': 'application/scvp-vp-response',
+    'sdp': 'application/sdp',
+    'senmlx': 'application/senml+xml',
+    'sensmlx': 'application/sensml+xml',
+    'setpay': 'application/set-payment-initiation',
+    'setreg': 'application/set-registration-initiation',
+    'shf': 'application/shf+xml',
+    'siv': 'application/sieve',
+    'sieve': 'application/sieve',
+    'smi': 'application/smil+xml',
+    'smil': 'application/smil+xml',
+    'rq': 'application/sparql-query',
+    'srx': 'application/sparql-results+xml',
+    'gram': 'application/srgs',
+    'grxml': 'application/srgs+xml',
+    'sru': 'application/sru+xml',
+    'ssdl': 'application/ssdl+xml',
+    'ssml': 'application/ssml+xml',
+    'swidtag': 'application/swid+xml',
+    'tei': 'application/tei+xml',
+    'teicorpus': 'application/tei+xml',
+    'tfi': 'application/thraud+xml',
+    'tsd': 'application/timestamped-data',
+    'toml': 'application/toml',
+    'trig': 'application/trig',
+    'ttml': 'application/ttml+xml',
+    'ubj': 'application/ubjson',
+    'rsheet': 'application/urc-ressheet+xml',
+    'td': 'application/urc-targetdesc+xml',
+    '1km': 'application/vnd.1000minds.decision-model+xml',
+    'plb': 'application/vnd.3gpp.pic-bw-large',
+    'psb': 'application/vnd.3gpp.pic-bw-small',
+    'pvb': 'application/vnd.3gpp.pic-bw-var',
+    'tcap': 'application/vnd.3gpp2.tcap',
+    'pwn': 'application/vnd.3m.post-it-notes',
+    'aso': 'application/vnd.accpac.simply.aso',
+    'imp': 'application/vnd.accpac.simply.imp',
+    'acu': 'application/vnd.acucobol',
+    'atc': 'application/vnd.acucorp',
+    'acutc': 'application/vnd.acucorp',
+    'air': 'application/vnd.adobe.air-application-installer-package+zip',
+    'fcdt': 'application/vnd.adobe.formscentral.fcdt',
+    'fxp': 'application/vnd.adobe.fxp',
+    'fxpl': 'application/vnd.adobe.fxp',
+    'xdp': 'application/vnd.adobe.xdp+xml',
+    'xfdf': 'application/xfdf',
+    'age': 'application/vnd.age',
+    'ahead': 'application/vnd.ahead.space',
+    'azf': 'application/vnd.airzip.filesecure.azf',
+    'azs': 'application/vnd.airzip.filesecure.azs',
+    'azw': 'application/vnd.amazon.ebook',
+    'acc': 'application/vnd.americandynamics.acc',
+    'ami': 'application/vnd.amiga.ami',
+    'apk': 'application/vnd.android.package-archive',
+    'cii': 'application/vnd.anser-web-certificate-issue-initiation',
+    'fti': 'application/vnd.anser-web-funds-transfer-initiation',
+    'atx': 'application/vnd.antix.game-component',
+    'mpkg': 'application/vnd.apple.installer+xml',
+    'key': 'application/x-iwork-keynote-sffkey',
+    'm3u8': 'application/vnd.apple.mpegurl',
+    'numbers': 'application/x-iwork-numbers-sffnumbers',
+    'pages': 'application/x-iwork-pages-sffpages',
+    'pkpass': 'application/vnd.apple.pkpass',
+    'swi': 'application/vnd.aristanetworks.swi',
+    'iota': 'application/vnd.astraea-software.iota',
+    'aep': 'application/vnd.audiograph',
+    'bmml': 'application/vnd.balsamiq.bmml+xml',
+    'mpm': 'application/vnd.blueice.multipass',
+    'bmi': 'application/vnd.bmi',
+    'rep': 'application/vnd.businessobjects',
+    'cdxml': 'application/vnd.chemdraw+xml',
+    'mmd': 'application/vnd.chipnuts.karaoke-mmd',
+    'cdy': 'application/vnd.cinderella',
+    'csl': 'application/vnd.citationstyles.style+xml',
+    'cla': 'application/vnd.claymore',
+    'rp9': 'application/vnd.cloanto.rp9',
+    'c4g': 'application/vnd.clonk.c4group',
+    'c4d': 'application/vnd.clonk.c4group',
+    'c4f': 'application/vnd.clonk.c4group',
+    'c4p': 'application/vnd.clonk.c4group',
+    'c4u': 'application/vnd.clonk.c4group',
+    'c11amc': 'application/vnd.cluetrust.cartomobile-config',
+    'c11amz': 'application/vnd.cluetrust.cartomobile-config-pkg',
+    'csp': 'application/vnd.commonspace',
+    'cdbcmsg': 'application/vnd.contact.cmsg',
+    'cmc': 'application/vnd.cosmocaller',
+    'clkx': 'application/vnd.crick.clicker',
+    'clkk': 'application/vnd.crick.clicker.keyboard',
+    'clkp': 'application/vnd.crick.clicker.palette',
+    'clkt': 'application/vnd.crick.clicker.template',
+    'clkw': 'application/vnd.crick.clicker.wordbank',
+    'wbs': 'application/vnd.criticaltools.wbs+xml',
+    'pml': 'application/vnd.ctc-posml',
+    'ppd': 'application/vnd.cups-ppd',
+    'car': 'application/vnd.curl.car',
+    'pcurl': 'application/vnd.curl.pcurl',
+    'dart': 'application/vnd.dart',
+    'rdz': 'application/vnd.data-vision.rdz',
+    'dbf': 'application/vnd.dbf',
+    'uvf': 'application/vnd.dece.data',
+    'uvvf': 'application/vnd.dece.data',
+    'uvd': 'application/vnd.dece.data',
+    'uvvd': 'application/vnd.dece.data',
+    'uvt': 'application/vnd.dece.ttml+xml',
+    'uvvt': 'application/vnd.dece.ttml+xml',
+    'uvx': 'application/vnd.dece.unspecified',
+    'uvvx': 'application/vnd.dece.unspecified',
+    'uvz': 'application/vnd.dece.zip',
+    'uvvz': 'application/vnd.dece.zip',
+    'fe_launch': 'application/vnd.denovo.fcselayout-link',
+    'dna': 'application/vnd.dna',
+    'mlp': 'application/vnd.dolby.mlp',
+    'dpg': 'application/vnd.dpgraph',
+    'dfac': 'application/vnd.dreamfactory',
+    'kpxx': 'application/vnd.ds-keypoint',
+    'ait': 'application/vnd.dvb.ait',
+    'svc': 'application/vnd.dvb.service',
+    'geo': 'application/vnd.dynageo',
+    'mag': 'application/vnd.ecowin.chart',
+    'nml': 'application/vnd.enliven',
+    'esf': 'application/vnd.epson.esf',
+    'msf': 'application/vnd.epson.msf',
+    'qam': 'application/vnd.epson.quickanime',
+    'slt': 'application/vnd.epson.salt',
+    'ssf': 'application/vnd.epson.ssf',
+    'es3': 'application/vnd.eszigno3+xml',
+    'et3': 'application/vnd.eszigno3+xml',
+    'ez2': 'application/vnd.ezpix-album',
+    'ez3': 'application/vnd.ezpix-package',
+    'mseed': 'application/vnd.fdsn.mseed',
+    'seed': 'application/vnd.fdsn.seed',
+    'dataless': 'application/vnd.fdsn.seed',
+    'gph': 'application/vnd.flographit',
+    'ftc': 'application/vnd.fluxtime.clip',
+    'fm': 'application/vnd.framemaker',
+    'frame': 'application/vnd.framemaker',
+    'maker': 'application/vnd.framemaker',
+    'book': 'application/vnd.framemaker',
+    'fnc': 'application/vnd.frogans.fnc',
+    'ltf': 'application/vnd.frogans.ltf',
+    'fsc': 'application/vnd.fsc.weblaunch',
+    'oas': 'application/vnd.fujitsu.oasys',
+    'oa2': 'application/vnd.fujitsu.oasys2',
+    'oa3': 'application/vnd.fujitsu.oasys3',
+    'fg5': 'application/vnd.fujitsu.oasysgp',
+    'bh2': 'application/vnd.fujitsu.oasysprs',
+    'ddd': 'application/vnd.fujixerox.ddd',
+    'xdw': 'application/vnd.fujixerox.docuworks',
+    'xbd': 'application/vnd.fujixerox.docuworks.binder',
+    'fzs': 'application/vnd.fuzzysheet',
+    'txd': 'application/vnd.genomatix.tuxedo',
+    'ggb': 'application/vnd.geogebra.file',
+    'ggt': 'application/vnd.geogebra.tool',
+    'gex': 'application/vnd.geometry-explorer',
+    'gre': 'application/vnd.geometry-explorer',
+    'gxt': 'application/vnd.geonext',
+    'g2w': 'application/vnd.geoplan',
+    'g3w': 'application/vnd.geospace',
+    'gmx': 'application/vnd.gmx',
+    'gdoc': 'application/vnd.google-apps.document',
+    'gslides': 'application/vnd.google-apps.presentation',
+    'gsheet': 'application/vnd.google-apps.spreadsheet',
+    'kml': 'application/vnd.google-earth.kml+xml',
+    'kmz': 'application/vnd.google-earth.kmz',
+    'gqf': 'application/vnd.grafeq',
+    'gqs': 'application/vnd.grafeq',
+    'gac': 'application/vnd.groove-account',
+    'ghf': 'application/vnd.groove-help',
+    'gim': 'application/vnd.groove-identity-message',
+    'grv': 'application/vnd.groove-injector',
+    'gtm': 'application/vnd.groove-tool-message',
+    'tpl': 'application/vnd.groove-tool-template',
+    'vcg': 'application/vnd.groove-vcard',
+    'hal': 'application/vnd.hal+xml',
+    'zmm': 'application/vnd.handheld-entertainment+xml',
+    'hbci': 'application/vnd.hbci',
+    'les': 'application/vnd.hhe.lesson-player',
+    'hpgl': 'application/vnd.hp-hpgl',
+    'hpid': 'application/vnd.hp-hpid',
+    'hps': 'application/vnd.hp-hps',
+    'jlt': 'application/vnd.hp-jlyt',
+    'pcl': 'application/vnd.hp-pcl',
+    'pclxl': 'application/vnd.hp-pclxl',
+    'sfd-hdstx': 'application/vnd.hydrostatix.sof-data',
+    'mpy': 'application/vnd.ibm.minipay',
+    'afp': 'application/vnd.ibm.modcap',
+    'listafp': 'application/vnd.ibm.modcap',
+    'list3820': 'application/vnd.ibm.modcap',
+    'irm': 'application/vnd.ibm.rights-management',
+    'sc': 'application/vnd.ibm.secure-container',
+    'icc': 'application/vnd.iccprofile',
+    'icm': 'application/vnd.iccprofile',
+    'igl': 'application/vnd.igloader',
+    'ivp': 'application/vnd.immervision-ivp',
+    'ivu': 'application/vnd.immervision-ivu',
+    'igm': 'application/vnd.insors.igm',
+    'xpw': 'application/vnd.intercon.formnet',
+    'xpx': 'application/vnd.intercon.formnet',
+    'i2g': 'application/vnd.intergeo',
+    'qbo': 'application/vnd.intu.qbo',
+    'qfx': 'application/vnd.intu.qfx',
+    'rcprofile': 'application/vnd.ipunplugged.rcprofile',
+    'irp': 'application/vnd.irepository.package+xml',
+    'xpr': 'application/vnd.is-xpr',
+    'fcs': 'application/vnd.isac.fcs',
+    'jam': 'application/vnd.jam',
+    'rms': 'application/vnd.jcp.javame.midlet-rms',
+    'jisp': 'application/vnd.jisp',
+    'joda': 'application/vnd.joost.joda-archive',
+    'ktz': 'application/vnd.kahootz',
+    'ktr': 'application/vnd.kahootz',
+    'karbon': 'application/vnd.kde.karbon',
+    'chrt': 'application/vnd.kde.kchart',
+    'kfo': 'application/vnd.kde.kformula',
+    'flw': 'application/vnd.kde.kivio',
+    'kon': 'application/vnd.kde.kontour',
+    'kpr': 'application/vnd.kde.kpresenter',
+    'kpt': 'application/vnd.kde.kpresenter',
+    'ksp': 'application/vnd.kde.kspread',
+    'kwd': 'application/vnd.kde.kword',
+    'kwt': 'application/vnd.kde.kword',
+    'htke': 'application/vnd.kenameaapp',
+    'kia': 'application/vnd.kidspiration',
+    'kne': 'application/vnd.kinar',
+    'knp': 'application/vnd.kinar',
+    'skp': 'application/vnd.koan',
+    'skd': 'application/vnd.koan',
+    'skt': 'application/vnd.koan',
+    'skm': 'application/vnd.koan',
+    'sse': 'application/vnd.kodak-descriptor',
+    'lasxml': 'application/vnd.las.las+xml',
+    'lbd': 'application/vnd.llamagraphics.life-balance.desktop',
+    'lbe': 'application/vnd.llamagraphics.life-balance.exchange+xml',
+    'apr': 'application/vnd.lotus-approach',
+    'pre': 'application/vnd.lotus-freelance',
+    'nsf': 'application/vnd.lotus-notes',
+    'org': 'text/x-org',
+    'scm': 'application/vnd.lotus-screencam',
+    'lwp': 'application/vnd.lotus-wordpro',
+    'portpkg': 'application/vnd.macports.portpkg',
+    'mvt': 'application/vnd.mapbox-vector-tile',
+    'mcd': 'application/vnd.mcd',
+    'mc1': 'application/vnd.medcalcdata',
+    'cdkey': 'application/vnd.mediastation.cdkey',
+    'mwf': 'application/vnd.mfer',
+    'mfm': 'application/vnd.mfmp',
+    'flo': 'application/vnd.micrografx.flo',
+    'igx': 'application/vnd.micrografx.igx',
+    'mif': 'application/vnd.mif',
+    'daf': 'application/vnd.mobius.daf',
+    'dis': 'application/vnd.mobius.dis',
+    'mbk': 'application/vnd.mobius.mbk',
+    'mqy': 'application/vnd.mobius.mqy',
+    'msl': 'application/vnd.mobius.msl',
+    'plc': 'application/vnd.mobius.plc',
+    'txf': 'application/vnd.mobius.txf',
+    'mpn': 'application/vnd.mophun.application',
+    'mpc': 'application/vnd.mophun.certificate',
+    'xul': 'application/vnd.mozilla.xul+xml',
+    'cil': 'application/vnd.ms-artgalry',
+    'cab': 'application/vnd.ms-cab-compressed',
+    'xls': 'application/vnd.ms-excel',
+    'xlm': 'application/vnd.ms-excel',
+    'xla': 'application/vnd.ms-excel',
+    'xlc': 'application/vnd.ms-excel',
+    'xlt': 'application/vnd.ms-excel',
+    'xlw': 'application/vnd.ms-excel',
+    'xlam': 'application/vnd.ms-excel.addin.macroenabled.12',
+    'xlsb': 'application/vnd.ms-excel.sheet.binary.macroenabled.12',
+    'xlsm': 'application/vnd.ms-excel.sheet.macroenabled.12',
+    'xltm': 'application/vnd.ms-excel.template.macroenabled.12',
+    'eot': 'application/vnd.ms-fontobject',
+    'chm': 'application/vnd.ms-htmlhelp',
+    'ims': 'application/vnd.ms-ims',
+    'lrm': 'application/vnd.ms-lrm',
+    'thmx': 'application/vnd.ms-officetheme',
+    'msg': 'application/vnd.ms-outlook',
+    'cat': 'application/vnd.ms-pki.seccat',
+    'stl': 'model/stl',
+    'ppt': 'application/vnd.ms-powerpoint',
+    'pps': 'application/vnd.ms-powerpoint',
+    'pot': 'application/vnd.ms-powerpoint',
+    'ppam': 'application/vnd.ms-powerpoint.addin.macroenabled.12',
+    'pptm': 'application/vnd.ms-powerpoint.presentation.macroenabled.12',
+    'sldm': 'application/vnd.ms-powerpoint.slide.macroenabled.12',
+    'ppsm': 'application/vnd.ms-powerpoint.slideshow.macroenabled.12',
+    'potm': 'application/vnd.ms-powerpoint.template.macroenabled.12',
+    'mpt': 'application/vnd.ms-project',
+    'docm': 'application/vnd.ms-word.document.macroenabled.12',
+    'dotm': 'application/vnd.ms-word.template.macroenabled.12',
+    'wps': 'application/vnd.ms-works',
+    'wks': 'application/vnd.ms-works',
+    'wcm': 'application/vnd.ms-works',
+    'wdb': 'application/vnd.ms-works',
+    'wpl': 'application/vnd.ms-wpl',
+    'xps': 'application/vnd.ms-xpsdocument',
+    'mseq': 'application/vnd.mseq',
+    'mus': 'application/vnd.musician',
+    'msty': 'application/vnd.muvee.style',
+    'taglet': 'application/vnd.mynfc',
+    'nlu': 'application/vnd.neurolanguage.nlu',
+    'ntf': 'application/vnd.nitf',
+    'nitf': 'application/vnd.nitf',
+    'nnd': 'application/vnd.noblenet-directory',
+    'nns': 'application/vnd.noblenet-sealer',
+    'nnw': 'application/vnd.noblenet-web',
+    'ngdat': 'application/vnd.nokia.n-gage.data',
+    'n-gage': 'application/vnd.nokia.n-gage.symbian.install',
+    'rpst': 'application/vnd.nokia.radio-preset',
+    'rpss': 'application/vnd.nokia.radio-presets',
+    'edm': 'application/vnd.novadigm.edm',
+    'edx': 'application/vnd.novadigm.edx',
+    'ext': 'application/vnd.novadigm.ext',
+    'odc': 'application/vnd.oasis.opendocument.chart',
+    'otc': 'application/vnd.oasis.opendocument.chart-template',
+    'odb': 'application/vnd.oasis.opendocument.database',
+    'odf': 'application/vnd.oasis.opendocument.formula',
+    'odft': 'application/vnd.oasis.opendocument.formula-template',
+    'odg': 'application/vnd.oasis.opendocument.graphics',
+    'otg': 'application/vnd.oasis.opendocument.graphics-template',
+    'odi': 'application/vnd.oasis.opendocument.image',
+    'oti': 'application/vnd.oasis.opendocument.image-template',
+    'odp': 'application/vnd.oasis.opendocument.presentation',
+    'otp': 'application/vnd.oasis.opendocument.presentation-template',
+    'ods': 'application/vnd.oasis.opendocument.spreadsheet',
+    'ots': 'application/vnd.oasis.opendocument.spreadsheet-template',
+    'odt': 'application/vnd.oasis.opendocument.text',
+    'odm': 'application/vnd.oasis.opendocument.text-master',
+    'ott': 'application/vnd.oasis.opendocument.text-template',
+    'oth': 'application/vnd.oasis.opendocument.text-web',
+    'xo': 'application/vnd.olpc-sugar',
+    'dd2': 'application/vnd.oma.dd2+xml',
+    'obgx': 'application/vnd.openblox.game+xml',
+    'oxt': 'application/vnd.openofficeorg.extension',
+    'osm': 'application/vnd.openstreetmap.data+xml',
+    'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'sldx': 'application/vnd.openxmlformats-officedocument.presentationml.slide',
+    'ppsx': 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
+    'potx': 'application/vnd.openxmlformats-officedocument.presentationml.template',
+    'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'xltx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
+    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'dotx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+    'mgp': 'application/vnd.osgeo.mapguide.package',
+    'dp': 'application/vnd.osgi.dp',
+    'esa': 'application/vnd.osgi.subsystem',
+    'pdb': 'application/x-pilot',
+    'pqa': 'application/vnd.palm',
+    'oprc': 'application/vnd.palm',
+    'paw': 'application/vnd.pawaafile',
+    'str': 'application/vnd.pg.format',
+    'ei6': 'application/vnd.pg.osasli',
+    'efif': 'application/vnd.picsel',
+    'wg': 'application/vnd.pmi.widget',
+    'plf': 'application/vnd.pocketlearn',
+    'pbd': 'application/vnd.powerbuilder6',
+    'box': 'application/vnd.previewsystems.box',
+    'mgz': 'application/vnd.proteus.magazine',
+    'qps': 'application/vnd.publishare-delta-tree',
+    'ptid': 'application/vnd.pvi.ptid1',
+    'qxd': 'application/vnd.quark.quarkxpress',
+    'qxt': 'application/vnd.quark.quarkxpress',
+    'qwd': 'application/vnd.quark.quarkxpress',
+    'qwt': 'application/vnd.quark.quarkxpress',
+    'qxl': 'application/vnd.quark.quarkxpress',
+    'qxb': 'application/vnd.quark.quarkxpress',
+    'rar': 'application/x-rar-compressed',
+    'bed': 'application/vnd.realvnc.bed',
+    'mxl': 'application/vnd.recordare.musicxml',
+    'musicxml': 'application/vnd.recordare.musicxml+xml',
+    'cryptonote': 'application/vnd.rig.cryptonote',
+    'cod': 'application/vnd.rim.cod',
+    'rm': 'application/vnd.rn-realmedia',
+    'rmvb': 'application/vnd.rn-realmedia-vbr',
+    'link66': 'application/vnd.route66.link66+xml',
+    'st': 'application/vnd.sailingtracker.track',
+    'see': 'application/vnd.seemail',
+    'sema': 'application/vnd.sema',
+    'semd': 'application/vnd.semd',
+    'semf': 'application/vnd.semf',
+    'ifm': 'application/vnd.shana.informed.formdata',
+    'itp': 'application/vnd.shana.informed.formtemplate',
+    'iif': 'application/vnd.shana.informed.interchange',
+    'ipk': 'application/vnd.shana.informed.package',
+    'twd': 'application/vnd.simtech-mindmapper',
+    'twds': 'application/vnd.simtech-mindmapper',
+    'mmf': 'application/vnd.smaf',
+    'teacher': 'application/vnd.smart.teacher',
+    'fo': 'application/vnd.software602.filler.form+xml',
+    'sdkm': 'application/vnd.solent.sdkm+xml',
+    'sdkd': 'application/vnd.solent.sdkm+xml',
+    'dxp': 'application/vnd.spotfire.dxp',
+    'sfs': 'application/vnd.spotfire.sfs',
+    'sdc': 'application/vnd.stardivision.calc',
+    'sda': 'application/vnd.stardivision.draw',
+    'sdd': 'application/vnd.stardivision.impress',
+    'smf': 'application/vnd.stardivision.math',
+    'sdw': 'application/vnd.stardivision.writer',
+    'vor': 'application/vnd.stardivision.writer',
+    'sgl': 'application/vnd.stardivision.writer-global',
+    'smzip': 'application/vnd.stepmania.package',
+    'sm': 'application/vnd.stepmania.stepchart',
+    'wadl': 'application/vnd.sun.wadl+xml',
+    'sxc': 'application/vnd.sun.xml.calc',
+    'stc': 'application/vnd.sun.xml.calc.template',
+    'sxd': 'application/vnd.sun.xml.draw',
+    'std': 'application/vnd.sun.xml.draw.template',
+    'sxi': 'application/vnd.sun.xml.impress',
+    'sti': 'application/vnd.sun.xml.impress.template',
+    'sxm': 'application/vnd.sun.xml.math',
+    'sxw': 'application/vnd.sun.xml.writer',
+    'sxg': 'application/vnd.sun.xml.writer.global',
+    'stw': 'application/vnd.sun.xml.writer.template',
+    'sus': 'application/vnd.sus-calendar',
+    'susp': 'application/vnd.sus-calendar',
+    'svd': 'application/vnd.svd',
+    'sis': 'application/vnd.symbian.install',
+    'sisx': 'application/vnd.symbian.install',
+    'xsm': 'application/vnd.syncml+xml',
+    'bdm': 'application/vnd.syncml.dm+wbxml',
+    'xdm': 'application/vnd.syncml.dm+xml',
+    'ddf': 'application/vnd.syncml.dmddf+xml',
+    'tao': 'application/vnd.tao.intent-module-archive',
+    'pcap': 'application/vnd.tcpdump.pcap',
+    'cap': 'application/vnd.tcpdump.pcap',
+    'dmp': 'application/vnd.tcpdump.pcap',
+    'tmo': 'application/vnd.tmobile-livetv',
+    'tpt': 'application/vnd.trid.tpt',
+    'mxs': 'application/vnd.triscape.mxs',
+    'tra': 'application/vnd.trueapp',
+    'ufd': 'application/vnd.ufdl',
+    'ufdl': 'application/vnd.ufdl',
+    'utz': 'application/vnd.uiq.theme',
+    'umj': 'application/vnd.umajin',
+    'unityweb': 'application/vnd.unity',
+    'uoml': 'application/vnd.uoml+xml',
+    'vcx': 'application/vnd.vcx',
+    'vsd': 'application/vnd.visio',
+    'vst': 'application/vnd.visio',
+    'vss': 'application/vnd.visio',
+    'vsw': 'application/vnd.visio',
+    'vis': 'application/vnd.visionary',
+    'vsf': 'application/vnd.vsf',
+    'wbxml': 'application/vnd.wap.wbxml',
+    'wmlc': 'application/vnd.wap.wmlc',
+    'wmlsc': 'application/vnd.wap.wmlscriptc',
+    'wtb': 'application/vnd.webturbo',
+    'nbp': 'application/vnd.wolfram.player',
+    'wpd': 'application/vnd.wordperfect',
+    'wqd': 'application/vnd.wqd',
+    'stf': 'application/vnd.wt.stf',
+    'xar': 'application/vnd.xara',
+    'xfdl': 'application/vnd.xfdl',
+    'hvd': 'application/vnd.yamaha.hv-dic',
+    'hvs': 'application/vnd.yamaha.hv-script',
+    'hvp': 'application/vnd.yamaha.hv-voice',
+    'osf': 'application/vnd.yamaha.openscoreformat',
+    'osfpvg': 'application/vnd.yamaha.openscoreformat.osfpvg+xml',
+    'saf': 'application/vnd.yamaha.smaf-audio',
+    'spf': 'application/vnd.yamaha.smaf-phrase',
+    'cmp': 'application/vnd.yellowriver-custom-menu',
+    'zir': 'application/vnd.zul',
+    'zirz': 'application/vnd.zul',
+    'zaz': 'application/vnd.zzazz.deck+xml',
+    'vxml': 'application/voicexml+xml',
+    'wasm': 'application/wasm',
+    'wif': 'application/watcherinfo+xml',
+    'wgt': 'application/widget',
+    'hlp': 'application/winhlp',
+    'wsdl': 'application/wsdl+xml',
+    'wspolicy': 'application/wspolicy+xml',
+    '7z': 'application/x-7z-compressed',
+    'abw': 'application/x-abiword',
+    'ace': 'application/x-ace-compressed',
+    'arj': 'application/x-arj',
+    'aab': 'application/x-authorware-bin',
+    'x32': 'application/x-authorware-bin',
+    'u32': 'application/x-authorware-bin',
+    'vox': 'application/x-authorware-bin',
+    'aam': 'application/x-authorware-map',
+    'aas': 'application/x-authorware-seg',
+    'bcpio': 'application/x-bcpio',
+    'torrent': 'application/x-bittorrent',
+    'blb': 'application/x-blorb',
+    'blorb': 'application/x-blorb',
+    'bz': 'application/x-bzip',
+    'bz2': 'application/x-bzip2',
+    'boz': 'application/x-bzip2',
+    'cbr': 'application/x-cbr',
+    'cba': 'application/x-cbr',
+    'cbt': 'application/x-cbr',
+    'cbz': 'application/x-cbr',
+    'cb7': 'application/x-cbr',
+    'vcd': 'application/x-cdlink',
+    'cfs': 'application/x-cfs-compressed',
+    'chat': 'application/x-chat',
+    'pgn': 'application/x-chess-pgn',
+    'crx': 'application/x-chrome-extension',
+    'cco': 'application/x-cocoa',
+    'nsc': 'application/x-conference',
+    'cpio': 'application/x-cpio',
+    'csh': 'application/x-csh',
+    'udeb': 'application/x-debian-package',
+    'dgc': 'application/x-dgc-compressed',
+    'dir': 'application/x-director',
+    'dcr': 'application/x-director',
+    'dxr': 'application/x-director',
+    'cst': 'application/x-director',
+    'cct': 'application/x-director',
+    'cxt': 'application/x-director',
+    'w3d': 'application/x-director',
+    'fgd': 'application/x-director',
+    'swa': 'application/x-director',
+    'wad': 'application/x-doom',
+    'ncx': 'application/x-dtbncx+xml',
+    'dtb': 'application/x-dtbook+xml',
+    'res': 'application/x-dtbresource+xml',
+    'dvi': 'application/x-dvi',
+    'evy': 'application/x-envoy',
+    'eva': 'application/x-eva',
+    'bdf': 'application/x-font-bdf',
+    'gsf': 'application/x-font-ghostscript',
+    'psf': 'application/x-font-linux-psf',
+    'pcf': 'application/x-font-pcf',
+    'snf': 'application/x-font-snf',
+    'pfa': 'application/x-font-type1',
+    'pfb': 'application/x-font-type1',
+    'pfm': 'application/x-font-type1',
+    'afm': 'application/x-font-type1',
+    'arc': 'application/x-freearc',
+    'spl': 'application/x-futuresplash',
+    'gca': 'application/x-gca-compressed',
+    'ulx': 'application/x-glulx',
+    'gnumeric': 'application/x-gnumeric',
+    'gramps': 'application/x-gramps-xml',
+    'gtar': 'application/x-gtar',
+    'hdf': 'application/x-hdf',
+    'php': 'application/x-httpd-php',
+    'install': 'application/x-install-instructions',
+    'jardiff': 'application/x-java-archive-diff',
+    'jnlp': 'application/x-java-jnlp-file',
+    'kdbx': 'application/x-keepass2',
+    'latex': 'application/x-latex',
+    'luac': 'application/x-lua-bytecode',
+    'lzh': 'application/x-lzh-compressed',
+    'lha': 'application/x-lzh-compressed',
+    'run': 'application/x-makeself',
+    'mie': 'application/x-mie',
+    'prc': 'model/prc',
+    'mobi': 'application/x-mobipocket-ebook',
+    'application': 'application/x-ms-application',
+    'lnk': 'application/x-ms-shortcut',
+    'wmd': 'application/x-ms-wmd',
+    'wmz': 'application/x-msmetafile',
+    'xbap': 'application/x-ms-xbap',
+    'mdb': 'application/x-msaccess',
+    'obd': 'application/x-msbinder',
+    'crd': 'application/x-mscardfile',
+    'clp': 'application/x-msclip',
+    'com': 'application/x-msdownload',
+    'bat': 'application/x-msdownload',
+    'mvb': 'application/x-msmediaview',
+    'm13': 'application/x-msmediaview',
+    'm14': 'application/x-msmediaview',
+    'wmf': 'image/wmf',
+    'emf': 'image/emf',
+    'emz': 'application/x-msmetafile',
+    'mny': 'application/x-msmoney',
+    'pub': 'application/x-mspublisher',
+    'scd': 'application/x-msschedule',
+    'trm': 'application/x-msterminal',
+    'wri': 'application/x-mswrite',
+    'nc': 'application/x-netcdf',
+    'cdf': 'application/x-netcdf',
+    'pac': 'application/x-ns-proxy-autoconfig',
+    'nzb': 'application/x-nzb',
+    'pl': 'application/x-perl',
+    'pm': 'application/x-perl',
+    'p12': 'application/x-pkcs12',
+    'pfx': 'application/x-pkcs12',
+    'p7b': 'application/x-pkcs7-certificates',
+    'spc': 'application/x-pkcs7-certificates',
+    'p7r': 'application/x-pkcs7-certreqresp',
+    'rpm': 'application/x-redhat-package-manager',
+    'ris': 'application/x-research-info-systems',
+    'sea': 'application/x-sea',
+    'sh': 'application/x-sh',
+    'shar': 'application/x-shar',
+    'swf': 'application/x-shockwave-flash',
+    'xap': 'application/x-silverlight-app',
+    'sql': 'application/x-sql',
+    'sit': 'application/x-stuffit',
+    'sitx': 'application/x-stuffitx',
+    'srt': 'application/x-subrip',
+    'sv4cpio': 'application/x-sv4cpio',
+    'sv4crc': 'application/x-sv4crc',
+    't3': 'application/x-t3vm-image',
+    'gam': 'application/x-tads',
+    'tar': 'application/x-tar',
+    'tcl': 'application/x-tcl',
+    'tk': 'application/x-tcl',
+    'tex': 'application/x-tex',
+    'tfm': 'application/x-tex-tfm',
+    'texinfo': 'application/x-texinfo',
+    'texi': 'application/x-texinfo',
+    'obj': 'model/obj',
+    'ustar': 'application/x-ustar',
+    'hdd': 'application/x-virtualbox-hdd',
+    'ova': 'application/x-virtualbox-ova',
+    'ovf': 'application/x-virtualbox-ovf',
+    'vbox': 'application/x-virtualbox-vbox',
+    'vbox-extpack': 'application/x-virtualbox-vbox-extpack',
+    'vdi': 'application/x-virtualbox-vdi',
+    'vhd': 'application/x-virtualbox-vhd',
+    'vmdk': 'application/x-virtualbox-vmdk',
+    'src': 'application/x-wais-source',
+    'webapp': 'application/x-web-app-manifest+json',
+    'der': 'application/x-x509-ca-cert',
+    'crt': 'application/x-x509-ca-cert',
+    'pem': 'application/x-x509-ca-cert',
+    'fig': 'application/x-xfig',
+    'xlf': 'application/xliff+xml',
+    'xpi': 'application/x-xpinstall',
+    'xz': 'application/x-xz',
+    'z1': 'application/x-zmachine',
+    'z2': 'application/x-zmachine',
+    'z3': 'application/x-zmachine',
+    'z4': 'application/x-zmachine',
+    'z5': 'application/x-zmachine',
+    'z6': 'application/x-zmachine',
+    'z7': 'application/x-zmachine',
+    'z8': 'application/x-zmachine',
+    'xaml': 'application/xaml+xml',
+    'xav': 'application/xcap-att+xml',
+    'xca': 'application/xcap-caps+xml',
+    'xdf': 'application/xcap-diff+xml',
+    'xel': 'application/xcap-el+xml',
+    'xns': 'application/xcap-ns+xml',
+    'xenc': 'application/xenc+xml',
+    'xhtml': 'application/xhtml+xml',
+    'xht': 'application/xhtml+xml',
+    'xml': 'text/xml',
+    'xsl': 'application/xslt+xml',
+    'xsd': 'application/xml',
+    'rng': 'application/xml',
+    'dtd': 'application/xml-dtd',
+    'xop': 'application/xop+xml',
+    'xpl': 'application/xproc+xml',
+    'xslt': 'application/xslt+xml',
+    'xspf': 'application/xspf+xml',
+    'mxml': 'application/xv+xml',
+    'xhvml': 'application/xv+xml',
+    'xvml': 'application/xv+xml',
+    'xvm': 'application/xv+xml',
+    'yang': 'application/yang',
+    'yin': 'application/yin+xml',
+    'zip': 'application/zip',
+    '3gpp': 'video/3gpp',
+    'adp': 'audio/adpcm',
+    'amr': 'audio/amr',
+    'au': 'audio/basic',
+    'snd': 'audio/basic',
+    'mid': 'audio/midi',
+    'midi': 'audio/midi',
+    'kar': 'audio/midi',
+    'rmi': 'audio/midi',
+    'mxmf': 'audio/mobile-xmf',
+    'mp3': 'audio/mpeg',
+    'm4a': 'audio/x-m4a',
+    'mp4a': 'audio/mp4',
+    'mpga': 'audio/mpeg',
+    'mp2': 'audio/mpeg',
+    'mp2a': 'audio/mpeg',
+    'm2a': 'audio/mpeg',
+    'm3a': 'audio/mpeg',
+    'oga': 'audio/ogg',
+    'ogg': 'audio/ogg',
+    'spx': 'audio/ogg',
+    'opus': 'audio/ogg',
+    's3m': 'audio/s3m',
+    'sil': 'audio/silk',
+    'uva': 'audio/vnd.dece.audio',
+    'uvva': 'audio/vnd.dece.audio',
+    'eol': 'audio/vnd.digital-winds',
+    'dra': 'audio/vnd.dra',
+    'dts': 'audio/vnd.dts',
+    'dtshd': 'audio/vnd.dts.hd',
+    'lvp': 'audio/vnd.lucent.voice',
+    'pya': 'audio/vnd.ms-playready.media.pya',
+    'ecelp4800': 'audio/vnd.nuera.ecelp4800',
+    'ecelp7470': 'audio/vnd.nuera.ecelp7470',
+    'ecelp9600': 'audio/vnd.nuera.ecelp9600',
+    'rip': 'audio/vnd.rip',
+    'wav': 'audio/x-wav',
+    'weba': 'audio/webm',
+    'aac': 'audio/x-aac',
+    'aif': 'audio/x-aiff',
+    'aiff': 'audio/x-aiff',
+    'aifc': 'audio/x-aiff',
+    'caf': 'audio/x-caf',
+    'flac': 'audio/x-flac',
+    'mka': 'audio/x-matroska',
+    'm3u': 'audio/x-mpegurl',
+    'wax': 'audio/x-ms-wax',
+    'wma': 'audio/x-ms-wma',
+    'ram': 'audio/x-pn-realaudio',
+    'ra': 'audio/x-realaudio',
+    'rmp': 'audio/x-pn-realaudio-plugin',
+    'xm': 'audio/xm',
+    'cdx': 'chemical/x-cdx',
+    'cif': 'chemical/x-cif',
+    'cmdf': 'chemical/x-cmdf',
+    'cml': 'chemical/x-cml',
+    'csml': 'chemical/x-csml',
+    'xyz': 'chemical/x-xyz',
+    'ttc': 'font/collection',
+    'otf': 'font/otf',
+    'ttf': 'font/ttf',
+    'woff': 'font/woff',
+    'woff2': 'font/woff2',
+    'exr': 'image/aces',
+    'apng': 'image/apng',
+    'avci': 'image/avci',
+    'avcs': 'image/avcs',
+    'avif': 'image/avif',
+    'bmp': 'image/x-ms-bmp',
+    'cgm': 'image/cgm',
+    'drle': 'image/dicom-rle',
+    'fits': 'image/fits',
+    'g3': 'image/g3fax',
+    'gif': 'image/gif',
+    'heic': 'image/heic',
+    'heics': 'image/heic-sequence',
+    'heif': 'image/heif',
+    'heifs': 'image/heif-sequence',
+    'hej2': 'image/hej2k',
+    'hsj2': 'image/hsj2',
+    'ief': 'image/ief',
+    'jls': 'image/jls',
+    'jp2': 'image/jp2',
+    'jpg2': 'image/jp2',
+    'jpeg': 'image/jpeg',
+    'jpg': 'image/jpeg',
+    'jpe': 'image/jpeg',
+    'jph': 'image/jph',
+    'jhc': 'image/jphc',
+    'jpm': 'video/jpm',
+    'jpx': 'image/jpx',
+    'jpf': 'image/jpx',
+    'jxr': 'image/jxr',
+    'jxra': 'image/jxra',
+    'jxrs': 'image/jxrs',
+    'jxs': 'image/jxs',
+    'jxsc': 'image/jxsc',
+    'jxsi': 'image/jxsi',
+    'jxss': 'image/jxss',
+    'ktx': 'image/ktx',
+    'ktx2': 'image/ktx2',
+    'png': 'image/png',
+    'btif': 'image/prs.btif',
+    'pti': 'image/prs.pti',
+    'sgi': 'image/sgi',
+    'svg': 'image/svg+xml',
+    'svgz': 'image/svg+xml',
+    't38': 'image/t38',
+    'tif': 'image/tiff',
+    'tiff': 'image/tiff',
+    'tfx': 'image/tiff-fx',
+    'psd': 'image/vnd.adobe.photoshop',
+    'azv': 'image/vnd.airzip.accelerator.azv',
+    'uvi': 'image/vnd.dece.graphic',
+    'uvvi': 'image/vnd.dece.graphic',
+    'uvg': 'image/vnd.dece.graphic',
+    'uvvg': 'image/vnd.dece.graphic',
+    'djvu': 'image/vnd.djvu',
+    'djv': 'image/vnd.djvu',
+    'sub': 'text/vnd.dvb.subtitle',
+    'dwg': 'image/vnd.dwg',
+    'dxf': 'image/vnd.dxf',
+    'fbs': 'image/vnd.fastbidsheet',
+    'fpx': 'image/vnd.fpx',
+    'fst': 'image/vnd.fst',
+    'mmr': 'image/vnd.fujixerox.edmics-mmr',
+    'rlc': 'image/vnd.fujixerox.edmics-rlc',
+    'ico': 'image/x-icon',
+    'dds': 'image/vnd.ms-dds',
+    'mdi': 'image/vnd.ms-modi',
+    'wdp': 'image/vnd.ms-photo',
+    'npx': 'image/vnd.net-fpx',
+    'b16': 'image/vnd.pco.b16',
+    'tap': 'image/vnd.tencent.tap',
+    'vtf': 'image/vnd.valve.source.texture',
+    'wbmp': 'image/vnd.wap.wbmp',
+    'xif': 'image/vnd.xiff',
+    'pcx': 'image/x-pcx',
+    'webp': 'image/webp',
+    '3ds': 'image/x-3ds',
+    'ras': 'image/x-cmu-raster',
+    'cmx': 'image/x-cmx',
+    'fh': 'image/x-freehand',
+    'fhc': 'image/x-freehand',
+    'fh4': 'image/x-freehand',
+    'fh5': 'image/x-freehand',
+    'fh7': 'image/x-freehand',
+    'jng': 'image/x-jng',
+    'sid': 'image/x-mrsid-image',
+    'pic': 'image/x-pict',
+    'pct': 'image/x-pict',
+    'pnm': 'image/x-portable-anymap',
+    'pbm': 'image/x-portable-bitmap',
+    'pgm': 'image/x-portable-graymap',
+    'ppm': 'image/x-portable-pixmap',
+    'rgb': 'image/x-rgb',
+    'tga': 'image/x-tga',
+    'xbm': 'image/x-xbitmap',
+    'xpm': 'image/x-xpixmap',
+    'xwd': 'image/x-xwindowdump',
+    'disposition-notification': 'message/disposition-notification',
+    'u8msg': 'message/global',
+    'u8dsn': 'message/global-delivery-status',
+    'u8mdn': 'message/global-disposition-notification',
+    'u8hdr': 'message/global-headers',
+    'eml': 'message/rfc822',
+    'mime': 'message/rfc822',
+    'wsc': 'message/vnd.wfa.wsc',
+    '3mf': 'model/3mf',
+    'gltf': 'model/gltf+json',
+    'glb': 'model/gltf-binary',
+    'igs': 'model/iges',
+    'iges': 'model/iges',
+    'msh': 'model/mesh',
+    'mesh': 'model/mesh',
+    'silo': 'model/mesh',
+    'mtl': 'model/mtl',
+    'stpx': 'model/step+xml',
+    'stpz': 'model/step+zip',
+    'stpxz': 'model/step-xml+zip',
+    'u3d': 'model/u3d',
+    'dae': 'model/vnd.collada+xml',
+    'dwf': 'model/vnd.dwf',
+    'gdl': 'model/vnd.gdl',
+    'gtw': 'model/vnd.gtw',
+    'mts': 'model/vnd.mts',
+    'ogex': 'model/vnd.opengex',
+    'x_b': 'model/vnd.parasolid.transmit.binary',
+    'x_t': 'model/vnd.parasolid.transmit.text',
+    'vds': 'model/vnd.sap.vds',
+    'usdz': 'model/vnd.usdz+zip',
+    'bsp': 'model/vnd.valve.source.compiled-map',
+    'vtu': 'model/vnd.vtu',
+    'wrl': 'model/vrml',
+    'vrml': 'model/vrml',
+    'x3db': 'model/x3d+fastinfoset',
+    'x3dbz': 'model/x3d+binary',
+    'x3dv': 'model/x3d-vrml',
+    'x3dvz': 'model/x3d+vrml',
+    'x3d': 'model/x3d+xml',
+    'x3dz': 'model/x3d+xml',
+    'appcache': 'text/cache-manifest',
+    'manifest': 'text/cache-manifest',
+    'ics': 'text/calendar',
+    'ifb': 'text/calendar',
+    'coffee': 'text/coffeescript',
+    'litcoffee': 'text/coffeescript',
+    'css': 'text/css',
+    'csv': 'text/csv',
+    'html': 'text/html',
+    'htm': 'text/html',
+    'shtml': 'text/html',
+    'jade': 'text/jade',
+    'jsx': 'text/jsx',
+    'less': 'text/less',
+    'markdown': 'text/markdown',
+    'md': 'text/markdown',
+    'mml': 'text/mathml',
+    'mdx': 'text/mdx',
+    'n3': 'text/n3',
+    'txt': 'text/plain',
+    'text': 'text/plain',
+    'conf': 'text/plain',
+    'def': 'text/plain',
+    'list': 'text/plain',
+    'log': 'text/plain',
+    'in': 'text/plain',
+    'ini': 'text/plain',
+    'dsc': 'text/prs.lines.tag',
+    'rtx': 'text/richtext',
+    'sgml': 'text/sgml',
+    'sgm': 'text/sgml',
+    'shex': 'text/shex',
+    'slim': 'text/slim',
+    'slm': 'text/slim',
+    'spdx': 'text/spdx',
+    'stylus': 'text/stylus',
+    'styl': 'text/stylus',
+    'tsv': 'text/tab-separated-values',
+    't': 'text/troff',
+    'tr': 'text/troff',
+    'roff': 'text/troff',
+    'man': 'text/troff',
+    'me': 'text/troff',
+    'ms': 'text/troff',
+    'ttl': 'text/turtle',
+    'uri': 'text/uri-list',
+    'uris': 'text/uri-list',
+    'urls': 'text/uri-list',
+    'vcard': 'text/vcard',
+    'curl': 'text/vnd.curl',
+    'dcurl': 'text/vnd.curl.dcurl',
+    'mcurl': 'text/vnd.curl.mcurl',
+    'scurl': 'text/vnd.curl.scurl',
+    'ged': 'text/vnd.familysearch.gedcom',
+    'fly': 'text/vnd.fly',
+    'flx': 'text/vnd.fmi.flexstor',
+    'gv': 'text/vnd.graphviz',
+    '3dml': 'text/vnd.in3d.3dml',
+    'spot': 'text/vnd.in3d.spot',
+    'jad': 'text/vnd.sun.j2me.app-descriptor',
+    'wml': 'text/vnd.wap.wml',
+    'wmls': 'text/vnd.wap.wmlscript',
+    'vtt': 'text/vtt',
+    's': 'text/x-asm',
+    'asm': 'text/x-asm',
+    'c': 'text/x-c',
+    'cc': 'text/x-c',
+    'cxx': 'text/x-c',
+    'cpp': 'text/x-c',
+    'h': 'text/x-c',
+    'hh': 'text/x-c',
+    'dic': 'text/x-c',
+    'htc': 'text/x-component',
+    'f': 'text/x-fortran',
+    'for': 'text/x-fortran',
+    'f77': 'text/x-fortran',
+    'f90': 'text/x-fortran',
+    'hbs': 'text/x-handlebars-template',
+    'java': 'text/x-java-source',
+    'lua': 'text/x-lua',
+    'mkd': 'text/x-markdown',
+    'nfo': 'text/x-nfo',
+    'opml': 'text/x-opml',
+    'p': 'text/x-pascal',
+    'pas': 'text/x-pascal',
+    'pde': 'text/x-processing',
+    'sass': 'text/x-sass',
+    'scss': 'text/x-scss',
+    'etx': 'text/x-setext',
+    'sfv': 'text/x-sfv',
+    'ymp': 'text/x-suse-ymp',
+    'uu': 'text/x-uuencode',
+    'vcs': 'text/x-vcalendar',
+    'vcf': 'text/x-vcard',
+    'yaml': 'text/yaml',
+    'yml': 'text/yaml',
+    '3gp': 'video/3gpp',
+    '3g2': 'video/3gpp2',
+    'h261': 'video/h261',
+    'h263': 'video/h263',
+    'h264': 'video/h264',
+    'm4s': 'video/iso.segment',
+    'jpgv': 'video/jpeg',
+    'jpgm': 'video/jpm',
+    'mj2': 'video/mj2',
+    'mjp2': 'video/mj2',
+    'ts': 'video/mp2t',
+    'mp4': 'video/mp4',
+    'mp4v': 'video/mp4',
+    'mpg4': 'video/mp4',
+    'mpeg': 'video/mpeg',
+    'mpg': 'video/mpeg',
+    'mpe': 'video/mpeg',
+    'm1v': 'video/mpeg',
+    'm2v': 'video/mpeg',
+    'ogv': 'video/ogg',
+    'qt': 'video/quicktime',
+    'mov': 'video/quicktime',
+    'uvh': 'video/vnd.dece.hd',
+    'uvvh': 'video/vnd.dece.hd',
+    'uvm': 'video/vnd.dece.mobile',
+    'uvvm': 'video/vnd.dece.mobile',
+    'uvp': 'video/vnd.dece.pd',
+    'uvvp': 'video/vnd.dece.pd',
+    'uvs': 'video/vnd.dece.sd',
+    'uvvs': 'video/vnd.dece.sd',
+    'uvv': 'video/vnd.dece.video',
+    'uvvv': 'video/vnd.dece.video',
+    'dvb': 'video/vnd.dvb.file',
+    'fvt': 'video/vnd.fvt',
+    'mxu': 'video/vnd.mpegurl',
+    'm4u': 'video/vnd.mpegurl',
+    'pyv': 'video/vnd.ms-playready.media.pyv',
+    'uvu': 'video/vnd.uvvu.mp4',
+    'uvvu': 'video/vnd.uvvu.mp4',
+    'viv': 'video/vnd.vivo',
+    'webm': 'video/webm',
+    'f4v': 'video/x-f4v',
+    'fli': 'video/x-fli',
+    'flv': 'video/x-flv',
+    'm4v': 'video/x-m4v',
+    'mkv': 'video/x-matroska',
+    'mk3d': 'video/x-matroska',
+    'mks': 'video/x-matroska',
+    'mng': 'video/x-mng',
+    'asf': 'video/x-ms-asf',
+    'asx': 'video/x-ms-asf',
+    'vob': 'video/x-ms-vob',
+    'wm': 'video/x-ms-wm',
+    'wmv': 'video/x-ms-wmv',
+    'wmx': 'video/x-ms-wmx',
+    'wvx': 'video/x-ms-wvx',
+    'avi': 'video/x-msvideo',
+    'movie': 'video/x-sgi-movie',
+    'smv': 'video/x-smv',
+    'ice': 'x-conference/x-cooltalk',
+};
+
+function getMimeType(path, fallback = null) {
+    const ext = (/\.([^.]+)$/.exec(path) || [])[1] || path;
+    return extensions[ext] || fallback;
+}
+
+const { stat, readdir } = promises;
+function statFile(path) {
+    return stat(path);
+}
+async function serveFile(filePath, options = {}) {
+    const { restoreCtx } = useCurrentWooksContext();
+    const { status } = useResponse();
+    const { setHeader, removeHeader } = useSetHeaders();
+    const headers = useHeaders();
+    const { method, url } = useRequest();
+    const { setCacheControl, setExpires, setPragmaNoCache } = useSetCacheControl();
+    const normalizedPath = path.normalize(path.join(process.cwd(), options.baseDir || '', filePath));
+    let fileStats;
+    try {
+        fileStats = await stat(normalizedPath);
+    }
+    catch (e) {
+        if (options.defaultExt) {
+            const ext = path.extname(filePath);
+            if (!ext) {
+                restoreCtx();
+                return serveFile(filePath + '.' + options.defaultExt);
+            }
+        }
+        throw new WooksError(404);
+    }
+    status(200);
+    const etag = `"${[fileStats.ino, fileStats.size, fileStats.mtime.toISOString()].join('-')}"`;
+    const lastModified = new Date(fileStats.mtime);
+    if (isNotModified(etag, lastModified, headers['if-none-match'] || '', headers['if-modified-since'] || '')) {
+        status(304);
+        return '';
+    }
+    setHeader('etag', etag);
+    setHeader('Last-Modified', lastModified.toUTCString());
+    if (options.cacheControl !== undefined) {
+        setCacheControl(options.cacheControl);
+    }
+    if (options.expires) {
+        setExpires(options.expires);
+    }
+    if (options.pragmaNoCache) {
+        setPragmaNoCache(options.pragmaNoCache);
+    }
+    if (fileStats.isDirectory()) {
+        if (options.listDirectory) {
+            restoreCtx();
+            return listDirectory(normalizedPath);
+        }
+        else if (options.index) {
+            if (filePath[filePath.length - 1] !== '/' && url && url[url.length - 1] !== '/') {
+                return new BaseWooksResponse().setStatus(302).setHeader('Location', url + '/');
+            }
+            restoreCtx();
+            return serveFile(path.join(filePath, options.index), {
+                ...options,
+                index: '',
+            });
+        }
+        removeHeader('etag');
+        removeHeader('Last-Modified');
+        throw new WooksError(404);
+    }
+    let range = headers.range;
+    let start, end;
+    let size = fileStats.size;
+    if (range) {
+        const rangeParts = range.trim().replace(/bytes=/, '').split('-');
+        const [s, e] = rangeParts;
+        start = parseInt(s);
+        end = e ? parseInt(e) : (size - 1);
+        end = Math.min(size - 1, end);
+        if (start > end || isNaN(start) || isNaN(end)) {
+            throw new WooksError(416);
+        }
+        size = (end - start) + 1;
+        const ifRange = headers['if-range'] || '';
+        const ifRangeTag = ifRange[0] === '"' ? ifRange : '';
+        const ifRangeDate = ifRangeTag ? '' : ifRange;
+        if (ifRange && !isNotModified(etag, lastModified, ifRangeTag, ifRangeDate)) {
+            status(200);
+            size = fileStats.size;
+            range = '';
+        }
+        else {
+            setHeader('Content-Range', `bytes ${start}-${end}/${fileStats.size}`);
+            status(206);
+        }
+    }
+    setHeader('Accept-Ranges', 'bytes');
+    setHeader('Content-Type', getMimeType(normalizedPath) || 'application/octet-stream');
+    setHeader('Content-Length', size);
+    if (options.headers) {
+        for (const header of Object.keys(options.headers)) {
+            setHeader(header, options.headers[header]);
+        }
+    }
+    return method === 'HEAD' ? '' : createReadStream(normalizedPath, !!range ? { start, end } : undefined);
+}
+function isNotModified(etag, lastModified, clientEtag, clientLM) {
+    if (clientEtag) {
+        const parts = clientEtag.split(',').map(v => v.trim());
+        for (const p of parts) {
+            if (etag === p) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const date = new Date(clientLM);
+    if (date.toString() !== 'Invalid Date' && date.getTime() > lastModified.getTime()) {
+        return true;
+    }
+    return false;
+}
+async function listDirectory(dirPath) {
+    const { setContentType } = useSetHeaders();
+    const { url } = useRequest();
+    const list = await readdir(dirPath);
+    const promises = [];
+    let detailedList = [];
+    for (const item of list) {
+        promises.push({ name: item, promise: stat(path.join(dirPath, item)) });
+    }
+    for (const item of promises) {
+        const data = await item.promise;
+        detailedList.push({
+            name: item.name, size: data.size, mtime: data.mtime, dir: data.isDirectory(),
+        });
+    }
+    detailedList = detailedList.sort((a, b) => a.dir === b.dir ? a.name > b.name ? 1 : -1 : a.dir > b.dir ? -1 : 1);
+    detailedList.unshift({ name: '..', dir: true });
+    setContentType('text/html');
+    const styles = '<style type="text/css">\nhtml { font-family: monospace }\n' +
+        'span { padding: 0px 2px }\n' +
+        '.text { text-overflow: ellipsis; overflow: hidden; white-space: nowrap; }\n' +
+        '.icon { width: 20px; display: inline-block; text-align: center; }\n' +
+        '.name { width: 250px; display: inline-block; }\n' +
+        '.size { width: 80px; display: inline-block; color: grey; text-align: right; }\n' +
+        '.date { width: 200px; display: inline-block; color: grey; text-align: right; }\n' +
+        '\n</style>';
+    return '<html><head><title>Dir</title> ' + styles + ' </head><body><ul>' +
+        detailedList.map(d => `<li> <span class="icon">${d.dir ? '&#128193;' : '&#128462;'}</span>` +
+            `<a href="${path.join(url || '', d.name)}"><span class="name text">${d.name}</span></a>` +
+            `<span class="size text">${d.size && (d.size > 10000 ? (Math.round(d.size / 1024 / 1024).toString() + 'Mb') : (Math.round(d.size / 1024).toString() + 'Kb')) || ''}</span>` +
+            `<span class="date text">${d.mtime && d.mtime.toISOString() || ''}</li>`).join('\n') +
+        '</ul></body></html>';
+}
+
+export { BaseWooksResponse, BaseWooksResponseRenderer, EHttpStatusCode, Wooks, WooksError, WooksErrorRenderer, clearCacheObject, contentTypes, createResponseFrom, httpStatusCodes, registerBodyCompressor, serveFile, setTestHttpContext, statFile, useAccept, useAuthorization, useBody, useCacheObject, useCookies, useCurrentWooksContext, useHeaders, useRequest, useResponse, useRouteParams, useSearchParams, useSetCacheControl, useSetCookies, useSetHeaders };