es-mime-types/dist/index.js

mime-types rewrite in TypeScript with ESM and CommonJS targets

import db from 'mime-db';
import { extname } from 'path';

const EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
const TEXT_TYPE_REGEXP = /^text\//i;
function populateMaps(extensions, types) {
    // source preference (least -> most)
    const preference = ['nginx', 'apache', undefined, 'iana'];
    Object.keys(db).forEach((type) => {
        const mime = db[type];
        const exts = mime.extensions;
        if (!exts || !exts.length) {
            return;
        }
        // mime -> extensions
        extensions[type] = exts;
        // extension -> mime
        for (const extension of exts) {
            if (types[extension]) {
                const from = preference.indexOf(db[types[extension]].source);
                const to = preference.indexOf(mime.source);
                if (types[extension] !== 'application/octet-stream' &&
                    (from > to ||
                        (from === to && types[extension].substr(0, 12) === 'application/'))) {
                    // skip the remapping
                    continue;
                }
            }
            // set the extension -> mime
            types[extension] = type;
        }
    });
}
const extensions = Object.create(null);
const types = Object.create(null);
populateMaps(extensions, types);
/**
 * Get the default charset for a MIME type.
 */
function charset(type) {
    if (!type || typeof type !== 'string') {
        return false;
    }
    // TODO: use media-typer
    const match = EXTRACT_TYPE_REGEXP.exec(type);
    const mime = match && db[match[1].toLowerCase()];
    if (mime && mime.charset) {
        return mime.charset;
    }
    // default text/* to utf-8
    if (match && TEXT_TYPE_REGEXP.test(match[1])) {
        return 'UTF-8';
    }
    return false;
}
/**
 * Create a full Content-Type header given a MIME type or extension.
 */
function contentType(str) {
    // TODO: should this even be in this module?
    if (!str || typeof str !== 'string') {
        return false;
    }
    let mime = str.indexOf('/') === -1 ? exports.lookup(str) : str;
    if (!mime) {
        return false;
    }
    // TODO: use content-type or other module
    if (mime.indexOf('charset') === -1) {
        const charset = exports.charset(mime);
        if (charset)
            mime += '; charset=' + charset.toLowerCase();
    }
    return mime;
}
/**
 * Get the default extension for a MIME type.
 */
function extension(type) {
    if (!type || typeof type !== 'string') {
        return false;
    }
    // TODO: use media-typer
    const match = EXTRACT_TYPE_REGEXP.exec(type);
    // get extensions
    const exts = match && exports.extensions[match[1].toLowerCase()];
    if (!exts || !exts.length) {
        return false;
    }
    return exts[0];
}
/**
 * Lookup the MIME type for a file path/extension.
 */
function lookup(path) {
    if (!path || typeof path !== 'string') {
        return false;
    }
    // get the extension ("ext" or ".ext" or full path)
    const extension = extname('x.' + path)
        .toLowerCase()
        .substr(1);
    if (!extension) {
        return false;
    }
    return exports.types[extension] || false;
}

export { charset, contentType, extension, extensions, lookup, types };