/*
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
*/
|
|
"use strict";
|
|
const { extname } = require("path");
|
const db = require("mime-db");
|
|
/**
|
* RegExp to match type in RFC 6838
|
*
|
* type-name = restricted-name
|
* subtype-name = restricted-name
|
* restricted-name = restricted-name-first *126restricted-name-chars
|
* restricted-name-first = ALPHA / DIGIT
|
* restricted-name-chars = ALPHA / DIGIT / "!" / "#" / "$" / "&" / "-" / "^" / "_"
|
* restricted-name-chars =/ "." ; Characters before first dot always specify a facet name
|
* restricted-name-chars =/ "+" ; Characters after last plus always specify a structured syntax suffix
|
* ALPHA = %x41-5A / %x61-7A ; A-Z / a-z
|
* DIGIT = %x30-39 ; 0-9
|
*/
|
const TYPE_REGEXP =
|
/^ *(([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126})) *(?:;.*)?$/;
|
const extensions = Object.create(null);
|
const types = Object.create(null);
|
|
// Score RFC facets (see https://tools.ietf.org/html/rfc6838#section-3)
|
|
/** @type {Record<string, number>} */
|
const FACET_SCORES = {
|
"prs.": 100,
|
"x-": 200,
|
"x.": 300,
|
"vnd.": 400,
|
default: 900
|
};
|
|
/** @typedef {"nginx" | "apache" | "iana" | "default"} SourceScore */
|
|
// Score mime source (Logic originally from `jshttp/mime-types` module)
|
/** @type {Record<SourceScore, number>} */
|
const SOURCE_SCORES = {
|
nginx: 10,
|
apache: 20,
|
iana: 40,
|
default: 30
|
};
|
|
/** @type {Record<string, number>} */
|
const TYPE_SCORES = {
|
// prefer application/xml over text/xml
|
// prefer application/rtf over text/rtf
|
application: 1,
|
|
// prefer font/woff over application/font-woff
|
font: 2,
|
|
// prefer video/mp4 over audio/mp4 over application/mp4
|
// See https://www.rfc-editor.org/rfc/rfc4337.html#section-2
|
audio: 2,
|
video: 3,
|
|
default: 0
|
};
|
|
/**
|
* @param {string} mimeType mime type
|
* @param {SourceScore=} source source
|
* @returns {number} min score
|
*/
|
function mimeScore(mimeType, source = "default") {
|
if (mimeType === "application/octet-stream") {
|
return 0;
|
}
|
|
const [type, subtype] = mimeType.split("/");
|
|
const facet = subtype.replace(/(\.|x-).*/, "$1");
|
|
const facetScore = FACET_SCORES[facet] || FACET_SCORES.default;
|
const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;
|
const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;
|
|
// All else being equal prefer shorter types
|
const lengthScore = 1 - mimeType.length / 100;
|
|
return facetScore + sourceScore + typeScore + lengthScore;
|
}
|
|
/**
|
* @param {string} ext extension
|
* @param {string} type0 the first type
|
* @param {string} type1 the second type
|
* @returns {string} preferred type
|
*/
|
const preferredType = (ext, type0, type1) => {
|
const score0 = type0 ? mimeScore(type0, db[type0].source) : 0;
|
const score1 = type1 ? mimeScore(type1, db[type1].source) : 0;
|
|
return score0 > score1 ? type0 : type1;
|
};
|
|
/**
|
* @param {Record<string, readonly string[]>} extensions extensions
|
* @param {Record<string, string>} types types
|
*/
|
const populate = (extensions, types) => {
|
for (const type of Object.keys(db)) {
|
const mime = db[type];
|
const foundExtensions = mime.extensions;
|
|
if (!foundExtensions || foundExtensions.length === 0) {
|
continue;
|
}
|
|
// mime -> extensions
|
extensions[type] = foundExtensions;
|
|
// extension -> mime
|
for (let i = 0; i < foundExtensions.length; i++) {
|
const extension = foundExtensions[i];
|
|
types[extension] = preferredType(extension, types[extension], type);
|
}
|
}
|
};
|
|
populate(extensions, types);
|
|
/**
|
* Get the default extension for a MIME type.
|
* @param {string} type type
|
* @returns {undefined | string} resolve extension
|
*/
|
const extension = (type) => {
|
if (!type) {
|
return;
|
}
|
|
const match = TYPE_REGEXP.exec(type);
|
|
if (!match) {
|
return;
|
}
|
|
const possibleExtensions = extensions[match[1].toLowerCase()];
|
|
if (!possibleExtensions || possibleExtensions.length === 0) {
|
return;
|
}
|
|
return possibleExtensions[0];
|
};
|
|
/**
|
* Lookup the MIME type for a file path/extension.
|
* @param {string} path path
|
* @returns {undefined | string} resolved MIME type
|
*/
|
const lookup = (path) => {
|
if (!path) {
|
return;
|
}
|
|
// get the extension ("ext" or ".ext" or full path)
|
const extension = extname(`x.${path}`).toLowerCase().slice(1);
|
|
if (!extension) {
|
return;
|
}
|
|
return types[extension];
|
};
|
|
module.exports = { extension, lookup };
|
