You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14108 lines
241 KiB
14108 lines
241 KiB
'use strict';
|
|
|
|
var require$$0$1 = require('events');
|
|
var build = require('./chunks/dep-1be34a63.js');
|
|
var path = require('path');
|
|
var require$$0$2 = require('tty');
|
|
var require$$0$3 = require('util');
|
|
var fs = require('fs');
|
|
var require$$4 = require('net');
|
|
var require$$0$4 = require('zlib');
|
|
require('os');
|
|
require('url');
|
|
require('http');
|
|
require('stream');
|
|
require('resolve');
|
|
require('module');
|
|
require('https');
|
|
require('tls');
|
|
require('crypto');
|
|
require('assert');
|
|
require('buffer');
|
|
require('querystring');
|
|
require('repl');
|
|
require('vm');
|
|
require('console');
|
|
require('esbuild');
|
|
require('worker_threads');
|
|
require('child_process');
|
|
require('readline');
|
|
|
|
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e['default'] : e; }
|
|
|
|
var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
|
|
var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
|
|
var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
|
|
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
|
|
var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
|
|
var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$4);
|
|
|
|
function toArr(any) {
|
|
return any == null ? [] : Array.isArray(any) ? any : [any];
|
|
}
|
|
|
|
function toVal(out, key, val, opts) {
|
|
var x, old=out[key], nxt=(
|
|
!!~opts.string.indexOf(key) ? (val == null || val === true ? '' : String(val))
|
|
: typeof val === 'boolean' ? val
|
|
: !!~opts.boolean.indexOf(key) ? (val === 'false' ? false : val === 'true' || (out._.push((x = +val,x * 0 === 0) ? x : val),!!val))
|
|
: (x = +val,x * 0 === 0) ? x : val
|
|
);
|
|
out[key] = old == null ? nxt : (Array.isArray(old) ? old.concat(nxt) : [old, nxt]);
|
|
}
|
|
|
|
function mri2 (args, opts) {
|
|
args = args || [];
|
|
opts = opts || {};
|
|
|
|
var k, arr, arg, name, val, out={ _:[] };
|
|
var i=0, j=0, idx=0, len=args.length;
|
|
|
|
const alibi = opts.alias !== void 0;
|
|
const strict = opts.unknown !== void 0;
|
|
const defaults = opts.default !== void 0;
|
|
|
|
opts.alias = opts.alias || {};
|
|
opts.string = toArr(opts.string);
|
|
opts.boolean = toArr(opts.boolean);
|
|
|
|
if (alibi) {
|
|
for (k in opts.alias) {
|
|
arr = opts.alias[k] = toArr(opts.alias[k]);
|
|
for (i=0; i < arr.length; i++) {
|
|
(opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i=opts.boolean.length; i-- > 0;) {
|
|
arr = opts.alias[opts.boolean[i]] || [];
|
|
for (j=arr.length; j-- > 0;) opts.boolean.push(arr[j]);
|
|
}
|
|
|
|
for (i=opts.string.length; i-- > 0;) {
|
|
arr = opts.alias[opts.string[i]] || [];
|
|
for (j=arr.length; j-- > 0;) opts.string.push(arr[j]);
|
|
}
|
|
|
|
if (defaults) {
|
|
for (k in opts.default) {
|
|
name = typeof opts.default[k];
|
|
arr = opts.alias[k] = opts.alias[k] || [];
|
|
if (opts[name] !== void 0) {
|
|
opts[name].push(k);
|
|
for (i=0; i < arr.length; i++) {
|
|
opts[name].push(arr[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const keys = strict ? Object.keys(opts.alias) : [];
|
|
|
|
for (i=0; i < len; i++) {
|
|
arg = args[i];
|
|
|
|
if (arg === '--') {
|
|
out._ = out._.concat(args.slice(++i));
|
|
break;
|
|
}
|
|
|
|
for (j=0; j < arg.length; j++) {
|
|
if (arg.charCodeAt(j) !== 45) break; // "-"
|
|
}
|
|
|
|
if (j === 0) {
|
|
out._.push(arg);
|
|
} else if (arg.substring(j, j + 3) === 'no-') {
|
|
name = arg.substring(j + 3);
|
|
if (strict && !~keys.indexOf(name)) {
|
|
return opts.unknown(arg);
|
|
}
|
|
out[name] = false;
|
|
} else {
|
|
for (idx=j+1; idx < arg.length; idx++) {
|
|
if (arg.charCodeAt(idx) === 61) break; // "="
|
|
}
|
|
|
|
name = arg.substring(j, idx);
|
|
val = arg.substring(++idx) || (i+1 === len || (''+args[i+1]).charCodeAt(0) === 45 || args[++i]);
|
|
arr = (j === 2 ? [name] : name);
|
|
|
|
for (idx=0; idx < arr.length; idx++) {
|
|
name = arr[idx];
|
|
if (strict && !~keys.indexOf(name)) return opts.unknown('-'.repeat(j) + name);
|
|
toVal(out, name, (idx + 1 < arr.length) || val, opts);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (defaults) {
|
|
for (k in opts.default) {
|
|
if (out[k] === void 0) {
|
|
out[k] = opts.default[k];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (alibi) {
|
|
for (k in out) {
|
|
arr = opts.alias[k] || [];
|
|
while (arr.length > 0) {
|
|
out[arr.shift()] = out[k];
|
|
}
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
const removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
|
|
const findAllBrackets = (v) => {
|
|
const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
|
|
const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
|
|
const res = [];
|
|
const parse = (match) => {
|
|
let variadic = false;
|
|
let value = match[1];
|
|
if (value.startsWith("...")) {
|
|
value = value.slice(3);
|
|
variadic = true;
|
|
}
|
|
return {
|
|
required: match[0].startsWith("<"),
|
|
value,
|
|
variadic
|
|
};
|
|
};
|
|
let angledMatch;
|
|
while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
|
|
res.push(parse(angledMatch));
|
|
}
|
|
let squareMatch;
|
|
while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
|
|
res.push(parse(squareMatch));
|
|
}
|
|
return res;
|
|
};
|
|
const getMriOptions = (options) => {
|
|
const result = {alias: {}, boolean: []};
|
|
for (const [index, option] of options.entries()) {
|
|
if (option.names.length > 1) {
|
|
result.alias[option.names[0]] = option.names.slice(1);
|
|
}
|
|
if (option.isBoolean) {
|
|
if (option.negated) {
|
|
const hasStringTypeOption = options.some((o, i) => {
|
|
return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
|
|
});
|
|
if (!hasStringTypeOption) {
|
|
result.boolean.push(option.names[0]);
|
|
}
|
|
} else {
|
|
result.boolean.push(option.names[0]);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
const findLongest = (arr) => {
|
|
return arr.sort((a, b) => {
|
|
return a.length > b.length ? -1 : 1;
|
|
})[0];
|
|
};
|
|
const padRight = (str, length) => {
|
|
return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
|
|
};
|
|
const camelcase = (input) => {
|
|
return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
|
|
return p1 + p2.toUpperCase();
|
|
});
|
|
};
|
|
const setDotProp = (obj, keys, val) => {
|
|
let i = 0;
|
|
let length = keys.length;
|
|
let t = obj;
|
|
let x;
|
|
for (; i < length; ++i) {
|
|
x = t[keys[i]];
|
|
t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
|
|
}
|
|
};
|
|
const setByType = (obj, transforms) => {
|
|
for (const key of Object.keys(transforms)) {
|
|
const transform = transforms[key];
|
|
if (transform.shouldTransform) {
|
|
obj[key] = Array.prototype.concat.call([], obj[key]);
|
|
if (typeof transform.transformFunction === "function") {
|
|
obj[key] = obj[key].map(transform.transformFunction);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const getFileName = (input) => {
|
|
const m = /([^\\\/]+)$/.exec(input);
|
|
return m ? m[1] : "";
|
|
};
|
|
const camelcaseOptionName = (name) => {
|
|
return name.split(".").map((v, i) => {
|
|
return i === 0 ? camelcase(v) : v;
|
|
}).join(".");
|
|
};
|
|
class CACError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = this.constructor.name;
|
|
if (typeof Error.captureStackTrace === "function") {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
} else {
|
|
this.stack = new Error(message).stack;
|
|
}
|
|
}
|
|
}
|
|
|
|
class Option {
|
|
constructor(rawName, description, config) {
|
|
this.rawName = rawName;
|
|
this.description = description;
|
|
this.config = Object.assign({}, config);
|
|
rawName = rawName.replace(/\.\*/g, "");
|
|
this.negated = false;
|
|
this.names = removeBrackets(rawName).split(",").map((v) => {
|
|
let name = v.trim().replace(/^-{1,2}/, "");
|
|
if (name.startsWith("no-")) {
|
|
this.negated = true;
|
|
name = name.replace(/^no-/, "");
|
|
}
|
|
return camelcaseOptionName(name);
|
|
}).sort((a, b) => a.length > b.length ? 1 : -1);
|
|
this.name = this.names[this.names.length - 1];
|
|
if (this.negated && this.config.default == null) {
|
|
this.config.default = true;
|
|
}
|
|
if (rawName.includes("<")) {
|
|
this.required = true;
|
|
} else if (rawName.includes("[")) {
|
|
this.required = false;
|
|
} else {
|
|
this.isBoolean = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
const processArgs = process.argv;
|
|
const platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
|
|
|
|
class Command {
|
|
constructor(rawName, description, config = {}, cli) {
|
|
this.rawName = rawName;
|
|
this.description = description;
|
|
this.config = config;
|
|
this.cli = cli;
|
|
this.options = [];
|
|
this.aliasNames = [];
|
|
this.name = removeBrackets(rawName);
|
|
this.args = findAllBrackets(rawName);
|
|
this.examples = [];
|
|
}
|
|
usage(text) {
|
|
this.usageText = text;
|
|
return this;
|
|
}
|
|
allowUnknownOptions() {
|
|
this.config.allowUnknownOptions = true;
|
|
return this;
|
|
}
|
|
ignoreOptionDefaultValue() {
|
|
this.config.ignoreOptionDefaultValue = true;
|
|
return this;
|
|
}
|
|
version(version, customFlags = "-v, --version") {
|
|
this.versionNumber = version;
|
|
this.option(customFlags, "Display version number");
|
|
return this;
|
|
}
|
|
example(example) {
|
|
this.examples.push(example);
|
|
return this;
|
|
}
|
|
option(rawName, description, config) {
|
|
const option = new Option(rawName, description, config);
|
|
this.options.push(option);
|
|
return this;
|
|
}
|
|
alias(name) {
|
|
this.aliasNames.push(name);
|
|
return this;
|
|
}
|
|
action(callback) {
|
|
this.commandAction = callback;
|
|
return this;
|
|
}
|
|
isMatched(name) {
|
|
return this.name === name || this.aliasNames.includes(name);
|
|
}
|
|
get isDefaultCommand() {
|
|
return this.name === "" || this.aliasNames.includes("!");
|
|
}
|
|
get isGlobalCommand() {
|
|
return this instanceof GlobalCommand;
|
|
}
|
|
hasOption(name) {
|
|
name = name.split(".")[0];
|
|
return this.options.find((option) => {
|
|
return option.names.includes(name);
|
|
});
|
|
}
|
|
outputHelp() {
|
|
const {name, commands} = this.cli;
|
|
const {
|
|
versionNumber,
|
|
options: globalOptions,
|
|
helpCallback
|
|
} = this.cli.globalCommand;
|
|
let sections = [
|
|
{
|
|
body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
|
|
}
|
|
];
|
|
sections.push({
|
|
title: "Usage",
|
|
body: ` $ ${name} ${this.usageText || this.rawName}`
|
|
});
|
|
const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
|
|
if (showCommands) {
|
|
const longestCommandName = findLongest(commands.map((command) => command.rawName));
|
|
sections.push({
|
|
title: "Commands",
|
|
body: commands.map((command) => {
|
|
return ` ${padRight(command.rawName, longestCommandName.length)} ${command.description}`;
|
|
}).join("\n")
|
|
});
|
|
sections.push({
|
|
title: `For more info, run any command with the \`--help\` flag`,
|
|
body: commands.map((command) => ` $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
|
|
});
|
|
}
|
|
const options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
|
|
if (options.length > 0) {
|
|
const longestOptionName = findLongest(options.map((option) => option.rawName));
|
|
sections.push({
|
|
title: "Options",
|
|
body: options.map((option) => {
|
|
return ` ${padRight(option.rawName, longestOptionName.length)} ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
|
|
}).join("\n")
|
|
});
|
|
}
|
|
if (this.examples.length > 0) {
|
|
sections.push({
|
|
title: "Examples",
|
|
body: this.examples.map((example) => {
|
|
if (typeof example === "function") {
|
|
return example(name);
|
|
}
|
|
return example;
|
|
}).join("\n")
|
|
});
|
|
}
|
|
if (helpCallback) {
|
|
sections = helpCallback(sections) || sections;
|
|
}
|
|
console.log(sections.map((section) => {
|
|
return section.title ? `${section.title}:
|
|
${section.body}` : section.body;
|
|
}).join("\n\n"));
|
|
}
|
|
outputVersion() {
|
|
const {name} = this.cli;
|
|
const {versionNumber} = this.cli.globalCommand;
|
|
if (versionNumber) {
|
|
console.log(`${name}/${versionNumber} ${platformInfo}`);
|
|
}
|
|
}
|
|
checkRequiredArgs() {
|
|
const minimalArgsCount = this.args.filter((arg) => arg.required).length;
|
|
if (this.cli.args.length < minimalArgsCount) {
|
|
throw new CACError(`missing required args for command \`${this.rawName}\``);
|
|
}
|
|
}
|
|
checkUnknownOptions() {
|
|
const {options, globalCommand} = this.cli;
|
|
if (!this.config.allowUnknownOptions) {
|
|
for (const name of Object.keys(options)) {
|
|
if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
|
|
throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
checkOptionValue() {
|
|
const {options: parsedOptions, globalCommand} = this.cli;
|
|
const options = [...globalCommand.options, ...this.options];
|
|
for (const option of options) {
|
|
const value = parsedOptions[option.name.split(".")[0]];
|
|
if (option.required) {
|
|
const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
|
|
if (value === true || value === false && !hasNegated) {
|
|
throw new CACError(`option \`${option.rawName}\` value is missing`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
class GlobalCommand extends Command {
|
|
constructor(cli) {
|
|
super("@@global@@", "", {}, cli);
|
|
}
|
|
}
|
|
|
|
var __assign = Object.assign;
|
|
class CAC extends require$$0$1.EventEmitter {
|
|
constructor(name = "") {
|
|
super();
|
|
this.name = name;
|
|
this.commands = [];
|
|
this.rawArgs = [];
|
|
this.args = [];
|
|
this.options = {};
|
|
this.globalCommand = new GlobalCommand(this);
|
|
this.globalCommand.usage("<command> [options]");
|
|
}
|
|
usage(text) {
|
|
this.globalCommand.usage(text);
|
|
return this;
|
|
}
|
|
command(rawName, description, config) {
|
|
const command = new Command(rawName, description || "", config, this);
|
|
command.globalCommand = this.globalCommand;
|
|
this.commands.push(command);
|
|
return command;
|
|
}
|
|
option(rawName, description, config) {
|
|
this.globalCommand.option(rawName, description, config);
|
|
return this;
|
|
}
|
|
help(callback) {
|
|
this.globalCommand.option("-h, --help", "Display this message");
|
|
this.globalCommand.helpCallback = callback;
|
|
this.showHelpOnExit = true;
|
|
return this;
|
|
}
|
|
version(version, customFlags = "-v, --version") {
|
|
this.globalCommand.version(version, customFlags);
|
|
this.showVersionOnExit = true;
|
|
return this;
|
|
}
|
|
example(example) {
|
|
this.globalCommand.example(example);
|
|
return this;
|
|
}
|
|
outputHelp() {
|
|
if (this.matchedCommand) {
|
|
this.matchedCommand.outputHelp();
|
|
} else {
|
|
this.globalCommand.outputHelp();
|
|
}
|
|
}
|
|
outputVersion() {
|
|
this.globalCommand.outputVersion();
|
|
}
|
|
setParsedInfo({args, options}, matchedCommand, matchedCommandName) {
|
|
this.args = args;
|
|
this.options = options;
|
|
if (matchedCommand) {
|
|
this.matchedCommand = matchedCommand;
|
|
}
|
|
if (matchedCommandName) {
|
|
this.matchedCommandName = matchedCommandName;
|
|
}
|
|
return this;
|
|
}
|
|
unsetMatchedCommand() {
|
|
this.matchedCommand = void 0;
|
|
this.matchedCommandName = void 0;
|
|
}
|
|
parse(argv = processArgs, {
|
|
run = true
|
|
} = {}) {
|
|
this.rawArgs = argv;
|
|
if (!this.name) {
|
|
this.name = argv[1] ? getFileName(argv[1]) : "cli";
|
|
}
|
|
let shouldParse = true;
|
|
for (const command of this.commands) {
|
|
const parsed = this.mri(argv.slice(2), command);
|
|
const commandName = parsed.args[0];
|
|
if (command.isMatched(commandName)) {
|
|
shouldParse = false;
|
|
const parsedInfo = __assign(__assign({}, parsed), {
|
|
args: parsed.args.slice(1)
|
|
});
|
|
this.setParsedInfo(parsedInfo, command, commandName);
|
|
this.emit(`command:${commandName}`, command);
|
|
}
|
|
}
|
|
if (shouldParse) {
|
|
for (const command of this.commands) {
|
|
if (command.name === "") {
|
|
shouldParse = false;
|
|
const parsed = this.mri(argv.slice(2), command);
|
|
this.setParsedInfo(parsed, command);
|
|
this.emit(`command:!`, command);
|
|
}
|
|
}
|
|
}
|
|
if (shouldParse) {
|
|
const parsed = this.mri(argv.slice(2));
|
|
this.setParsedInfo(parsed);
|
|
}
|
|
if (this.options.help && this.showHelpOnExit) {
|
|
this.outputHelp();
|
|
run = false;
|
|
this.unsetMatchedCommand();
|
|
}
|
|
if (this.options.version && this.showVersionOnExit) {
|
|
this.outputVersion();
|
|
run = false;
|
|
this.unsetMatchedCommand();
|
|
}
|
|
const parsedArgv = {args: this.args, options: this.options};
|
|
if (run) {
|
|
this.runMatchedCommand();
|
|
}
|
|
if (!this.matchedCommand && this.args[0]) {
|
|
this.emit("command:*");
|
|
}
|
|
return parsedArgv;
|
|
}
|
|
mri(argv, command) {
|
|
const cliOptions = [
|
|
...this.globalCommand.options,
|
|
...command ? command.options : []
|
|
];
|
|
const mriOptions = getMriOptions(cliOptions);
|
|
let argsAfterDoubleDashes = [];
|
|
const doubleDashesIndex = argv.indexOf("--");
|
|
if (doubleDashesIndex > -1) {
|
|
argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
|
|
argv = argv.slice(0, doubleDashesIndex);
|
|
}
|
|
let parsed = mri2(argv, mriOptions);
|
|
parsed = Object.keys(parsed).reduce((res, name) => {
|
|
return __assign(__assign({}, res), {
|
|
[camelcaseOptionName(name)]: parsed[name]
|
|
});
|
|
}, {_: []});
|
|
const args = parsed._;
|
|
const options = {
|
|
"--": argsAfterDoubleDashes
|
|
};
|
|
const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
|
|
let transforms = Object.create(null);
|
|
for (const cliOption of cliOptions) {
|
|
if (!ignoreDefault && cliOption.config.default !== void 0) {
|
|
for (const name of cliOption.names) {
|
|
options[name] = cliOption.config.default;
|
|
}
|
|
}
|
|
if (Array.isArray(cliOption.config.type)) {
|
|
if (transforms[cliOption.name] === void 0) {
|
|
transforms[cliOption.name] = Object.create(null);
|
|
transforms[cliOption.name]["shouldTransform"] = true;
|
|
transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
|
|
}
|
|
}
|
|
}
|
|
for (const key of Object.keys(parsed)) {
|
|
if (key !== "_") {
|
|
const keys = key.split(".");
|
|
setDotProp(options, keys, parsed[key]);
|
|
setByType(options, transforms);
|
|
}
|
|
}
|
|
return {
|
|
args,
|
|
options
|
|
};
|
|
}
|
|
runMatchedCommand() {
|
|
const {args, options, matchedCommand: command} = this;
|
|
if (!command || !command.commandAction)
|
|
return;
|
|
command.checkUnknownOptions();
|
|
command.checkOptionValue();
|
|
command.checkRequiredArgs();
|
|
const actionArgs = [];
|
|
command.args.forEach((arg, index) => {
|
|
if (arg.variadic) {
|
|
actionArgs.push(args.slice(index));
|
|
} else {
|
|
actionArgs.push(args[index]);
|
|
}
|
|
});
|
|
actionArgs.push(options);
|
|
return command.commandAction.apply(this, actionArgs);
|
|
}
|
|
}
|
|
|
|
const cac = (name = "") => new CAC(name);
|
|
|
|
var compression$2 = {exports: {}};
|
|
|
|
var negotiator = {exports: {}};
|
|
|
|
var charset = {exports: {}};
|
|
|
|
/**
|
|
* negotiator
|
|
* Copyright(c) 2012 Isaac Z. Schlueter
|
|
* Copyright(c) 2014 Federico Romero
|
|
* Copyright(c) 2014-2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
charset.exports = preferredCharsets;
|
|
charset.exports.preferredCharsets = preferredCharsets;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
|
|
|
|
/**
|
|
* Parse the Accept-Charset header.
|
|
* @private
|
|
*/
|
|
|
|
function parseAcceptCharset(accept) {
|
|
var accepts = accept.split(',');
|
|
|
|
for (var i = 0, j = 0; i < accepts.length; i++) {
|
|
var charset = parseCharset(accepts[i].trim(), i);
|
|
|
|
if (charset) {
|
|
accepts[j++] = charset;
|
|
}
|
|
}
|
|
|
|
// trim accepts
|
|
accepts.length = j;
|
|
|
|
return accepts;
|
|
}
|
|
|
|
/**
|
|
* Parse a charset from the Accept-Charset header.
|
|
* @private
|
|
*/
|
|
|
|
function parseCharset(str, i) {
|
|
var match = simpleCharsetRegExp.exec(str);
|
|
if (!match) return null;
|
|
|
|
var charset = match[1];
|
|
var q = 1;
|
|
if (match[2]) {
|
|
var params = match[2].split(';');
|
|
for (var j = 0; j < params.length; j++) {
|
|
var p = params[j].trim().split('=');
|
|
if (p[0] === 'q') {
|
|
q = parseFloat(p[1]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
charset: charset,
|
|
q: q,
|
|
i: i
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get the priority of a charset.
|
|
* @private
|
|
*/
|
|
|
|
function getCharsetPriority(charset, accepted, index) {
|
|
var priority = {o: -1, q: 0, s: 0};
|
|
|
|
for (var i = 0; i < accepted.length; i++) {
|
|
var spec = specify$3(charset, accepted[i], index);
|
|
|
|
if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
|
|
priority = spec;
|
|
}
|
|
}
|
|
|
|
return priority;
|
|
}
|
|
|
|
/**
|
|
* Get the specificity of the charset.
|
|
* @private
|
|
*/
|
|
|
|
function specify$3(charset, spec, index) {
|
|
var s = 0;
|
|
if(spec.charset.toLowerCase() === charset.toLowerCase()){
|
|
s |= 1;
|
|
} else if (spec.charset !== '*' ) {
|
|
return null
|
|
}
|
|
|
|
return {
|
|
i: index,
|
|
o: spec.i,
|
|
q: spec.q,
|
|
s: s
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the preferred charsets from an Accept-Charset header.
|
|
* @public
|
|
*/
|
|
|
|
function preferredCharsets(accept, provided) {
|
|
// RFC 2616 sec 14.2: no header = *
|
|
var accepts = parseAcceptCharset(accept === undefined ? '*' : accept || '');
|
|
|
|
if (!provided) {
|
|
// sorted list of all charsets
|
|
return accepts
|
|
.filter(isQuality$3)
|
|
.sort(compareSpecs$3)
|
|
.map(getFullCharset);
|
|
}
|
|
|
|
var priorities = provided.map(function getPriority(type, index) {
|
|
return getCharsetPriority(type, accepts, index);
|
|
});
|
|
|
|
// sorted list of accepted charsets
|
|
return priorities.filter(isQuality$3).sort(compareSpecs$3).map(function getCharset(priority) {
|
|
return provided[priorities.indexOf(priority)];
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Compare two specs.
|
|
* @private
|
|
*/
|
|
|
|
function compareSpecs$3(a, b) {
|
|
return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0;
|
|
}
|
|
|
|
/**
|
|
* Get full charset string.
|
|
* @private
|
|
*/
|
|
|
|
function getFullCharset(spec) {
|
|
return spec.charset;
|
|
}
|
|
|
|
/**
|
|
* Check if a spec has any quality.
|
|
* @private
|
|
*/
|
|
|
|
function isQuality$3(spec) {
|
|
return spec.q > 0;
|
|
}
|
|
|
|
var encoding = {exports: {}};
|
|
|
|
/**
|
|
* negotiator
|
|
* Copyright(c) 2012 Isaac Z. Schlueter
|
|
* Copyright(c) 2014 Federico Romero
|
|
* Copyright(c) 2014-2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
encoding.exports = preferredEncodings;
|
|
encoding.exports.preferredEncodings = preferredEncodings;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
|
|
|
|
/**
|
|
* Parse the Accept-Encoding header.
|
|
* @private
|
|
*/
|
|
|
|
function parseAcceptEncoding(accept) {
|
|
var accepts = accept.split(',');
|
|
var hasIdentity = false;
|
|
var minQuality = 1;
|
|
|
|
for (var i = 0, j = 0; i < accepts.length; i++) {
|
|
var encoding = parseEncoding(accepts[i].trim(), i);
|
|
|
|
if (encoding) {
|
|
accepts[j++] = encoding;
|
|
hasIdentity = hasIdentity || specify$2('identity', encoding);
|
|
minQuality = Math.min(minQuality, encoding.q || 1);
|
|
}
|
|
}
|
|
|
|
if (!hasIdentity) {
|
|
/*
|
|
* If identity doesn't explicitly appear in the accept-encoding header,
|
|
* it's added to the list of acceptable encoding with the lowest q
|
|
*/
|
|
accepts[j++] = {
|
|
encoding: 'identity',
|
|
q: minQuality,
|
|
i: i
|
|
};
|
|
}
|
|
|
|
// trim accepts
|
|
accepts.length = j;
|
|
|
|
return accepts;
|
|
}
|
|
|
|
/**
|
|
* Parse an encoding from the Accept-Encoding header.
|
|
* @private
|
|
*/
|
|
|
|
function parseEncoding(str, i) {
|
|
var match = simpleEncodingRegExp.exec(str);
|
|
if (!match) return null;
|
|
|
|
var encoding = match[1];
|
|
var q = 1;
|
|
if (match[2]) {
|
|
var params = match[2].split(';');
|
|
for (var j = 0; j < params.length; j++) {
|
|
var p = params[j].trim().split('=');
|
|
if (p[0] === 'q') {
|
|
q = parseFloat(p[1]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
encoding: encoding,
|
|
q: q,
|
|
i: i
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get the priority of an encoding.
|
|
* @private
|
|
*/
|
|
|
|
function getEncodingPriority(encoding, accepted, index) {
|
|
var priority = {o: -1, q: 0, s: 0};
|
|
|
|
for (var i = 0; i < accepted.length; i++) {
|
|
var spec = specify$2(encoding, accepted[i], index);
|
|
|
|
if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
|
|
priority = spec;
|
|
}
|
|
}
|
|
|
|
return priority;
|
|
}
|
|
|
|
/**
|
|
* Get the specificity of the encoding.
|
|
* @private
|
|
*/
|
|
|
|
function specify$2(encoding, spec, index) {
|
|
var s = 0;
|
|
if(spec.encoding.toLowerCase() === encoding.toLowerCase()){
|
|
s |= 1;
|
|
} else if (spec.encoding !== '*' ) {
|
|
return null
|
|
}
|
|
|
|
return {
|
|
i: index,
|
|
o: spec.i,
|
|
q: spec.q,
|
|
s: s
|
|
}
|
|
}
|
|
/**
|
|
* Get the preferred encodings from an Accept-Encoding header.
|
|
* @public
|
|
*/
|
|
|
|
function preferredEncodings(accept, provided) {
|
|
var accepts = parseAcceptEncoding(accept || '');
|
|
|
|
if (!provided) {
|
|
// sorted list of all encodings
|
|
return accepts
|
|
.filter(isQuality$2)
|
|
.sort(compareSpecs$2)
|
|
.map(getFullEncoding);
|
|
}
|
|
|
|
var priorities = provided.map(function getPriority(type, index) {
|
|
return getEncodingPriority(type, accepts, index);
|
|
});
|
|
|
|
// sorted list of accepted encodings
|
|
return priorities.filter(isQuality$2).sort(compareSpecs$2).map(function getEncoding(priority) {
|
|
return provided[priorities.indexOf(priority)];
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Compare two specs.
|
|
* @private
|
|
*/
|
|
|
|
function compareSpecs$2(a, b) {
|
|
return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0;
|
|
}
|
|
|
|
/**
|
|
* Get full encoding string.
|
|
* @private
|
|
*/
|
|
|
|
function getFullEncoding(spec) {
|
|
return spec.encoding;
|
|
}
|
|
|
|
/**
|
|
* Check if a spec has any quality.
|
|
* @private
|
|
*/
|
|
|
|
function isQuality$2(spec) {
|
|
return spec.q > 0;
|
|
}
|
|
|
|
var language = {exports: {}};
|
|
|
|
/**
|
|
* negotiator
|
|
* Copyright(c) 2012 Isaac Z. Schlueter
|
|
* Copyright(c) 2014 Federico Romero
|
|
* Copyright(c) 2014-2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
language.exports = preferredLanguages;
|
|
language.exports.preferredLanguages = preferredLanguages;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
|
|
|
|
/**
|
|
* Parse the Accept-Language header.
|
|
* @private
|
|
*/
|
|
|
|
function parseAcceptLanguage(accept) {
|
|
var accepts = accept.split(',');
|
|
|
|
for (var i = 0, j = 0; i < accepts.length; i++) {
|
|
var language = parseLanguage(accepts[i].trim(), i);
|
|
|
|
if (language) {
|
|
accepts[j++] = language;
|
|
}
|
|
}
|
|
|
|
// trim accepts
|
|
accepts.length = j;
|
|
|
|
return accepts;
|
|
}
|
|
|
|
/**
|
|
* Parse a language from the Accept-Language header.
|
|
* @private
|
|
*/
|
|
|
|
function parseLanguage(str, i) {
|
|
var match = simpleLanguageRegExp.exec(str);
|
|
if (!match) return null;
|
|
|
|
var prefix = match[1],
|
|
suffix = match[2],
|
|
full = prefix;
|
|
|
|
if (suffix) full += "-" + suffix;
|
|
|
|
var q = 1;
|
|
if (match[3]) {
|
|
var params = match[3].split(';');
|
|
for (var j = 0; j < params.length; j++) {
|
|
var p = params[j].split('=');
|
|
if (p[0] === 'q') q = parseFloat(p[1]);
|
|
}
|
|
}
|
|
|
|
return {
|
|
prefix: prefix,
|
|
suffix: suffix,
|
|
q: q,
|
|
i: i,
|
|
full: full
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get the priority of a language.
|
|
* @private
|
|
*/
|
|
|
|
function getLanguagePriority(language, accepted, index) {
|
|
var priority = {o: -1, q: 0, s: 0};
|
|
|
|
for (var i = 0; i < accepted.length; i++) {
|
|
var spec = specify$1(language, accepted[i], index);
|
|
|
|
if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
|
|
priority = spec;
|
|
}
|
|
}
|
|
|
|
return priority;
|
|
}
|
|
|
|
/**
|
|
* Get the specificity of the language.
|
|
* @private
|
|
*/
|
|
|
|
function specify$1(language, spec, index) {
|
|
var p = parseLanguage(language);
|
|
if (!p) return null;
|
|
var s = 0;
|
|
if(spec.full.toLowerCase() === p.full.toLowerCase()){
|
|
s |= 4;
|
|
} else if (spec.prefix.toLowerCase() === p.full.toLowerCase()) {
|
|
s |= 2;
|
|
} else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) {
|
|
s |= 1;
|
|
} else if (spec.full !== '*' ) {
|
|
return null
|
|
}
|
|
|
|
return {
|
|
i: index,
|
|
o: spec.i,
|
|
q: spec.q,
|
|
s: s
|
|
}
|
|
}
|
|
/**
|
|
* Get the preferred languages from an Accept-Language header.
|
|
* @public
|
|
*/
|
|
|
|
function preferredLanguages(accept, provided) {
|
|
// RFC 2616 sec 14.4: no header = *
|
|
var accepts = parseAcceptLanguage(accept === undefined ? '*' : accept || '');
|
|
|
|
if (!provided) {
|
|
// sorted list of all languages
|
|
return accepts
|
|
.filter(isQuality$1)
|
|
.sort(compareSpecs$1)
|
|
.map(getFullLanguage);
|
|
}
|
|
|
|
var priorities = provided.map(function getPriority(type, index) {
|
|
return getLanguagePriority(type, accepts, index);
|
|
});
|
|
|
|
// sorted list of accepted languages
|
|
return priorities.filter(isQuality$1).sort(compareSpecs$1).map(function getLanguage(priority) {
|
|
return provided[priorities.indexOf(priority)];
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Compare two specs.
|
|
* @private
|
|
*/
|
|
|
|
function compareSpecs$1(a, b) {
|
|
return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0;
|
|
}
|
|
|
|
/**
|
|
* Get full language string.
|
|
* @private
|
|
*/
|
|
|
|
function getFullLanguage(spec) {
|
|
return spec.full;
|
|
}
|
|
|
|
/**
|
|
* Check if a spec has any quality.
|
|
* @private
|
|
*/
|
|
|
|
function isQuality$1(spec) {
|
|
return spec.q > 0;
|
|
}
|
|
|
|
var mediaType = {exports: {}};
|
|
|
|
/**
|
|
* negotiator
|
|
* Copyright(c) 2012 Isaac Z. Schlueter
|
|
* Copyright(c) 2014 Federico Romero
|
|
* Copyright(c) 2014-2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
mediaType.exports = preferredMediaTypes;
|
|
mediaType.exports.preferredMediaTypes = preferredMediaTypes;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
|
|
|
|
/**
|
|
* Parse the Accept header.
|
|
* @private
|
|
*/
|
|
|
|
function parseAccept(accept) {
|
|
var accepts = splitMediaTypes(accept);
|
|
|
|
for (var i = 0, j = 0; i < accepts.length; i++) {
|
|
var mediaType = parseMediaType(accepts[i].trim(), i);
|
|
|
|
if (mediaType) {
|
|
accepts[j++] = mediaType;
|
|
}
|
|
}
|
|
|
|
// trim accepts
|
|
accepts.length = j;
|
|
|
|
return accepts;
|
|
}
|
|
|
|
/**
|
|
* Parse a media type from the Accept header.
|
|
* @private
|
|
*/
|
|
|
|
function parseMediaType(str, i) {
|
|
var match = simpleMediaTypeRegExp.exec(str);
|
|
if (!match) return null;
|
|
|
|
var params = Object.create(null);
|
|
var q = 1;
|
|
var subtype = match[2];
|
|
var type = match[1];
|
|
|
|
if (match[3]) {
|
|
var kvps = splitParameters(match[3]).map(splitKeyValuePair);
|
|
|
|
for (var j = 0; j < kvps.length; j++) {
|
|
var pair = kvps[j];
|
|
var key = pair[0].toLowerCase();
|
|
var val = pair[1];
|
|
|
|
// get the value, unwrapping quotes
|
|
var value = val && val[0] === '"' && val[val.length - 1] === '"'
|
|
? val.substr(1, val.length - 2)
|
|
: val;
|
|
|
|
if (key === 'q') {
|
|
q = parseFloat(value);
|
|
break;
|
|
}
|
|
|
|
// store parameter
|
|
params[key] = value;
|
|
}
|
|
}
|
|
|
|
return {
|
|
type: type,
|
|
subtype: subtype,
|
|
params: params,
|
|
q: q,
|
|
i: i
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get the priority of a media type.
|
|
* @private
|
|
*/
|
|
|
|
function getMediaTypePriority(type, accepted, index) {
|
|
var priority = {o: -1, q: 0, s: 0};
|
|
|
|
for (var i = 0; i < accepted.length; i++) {
|
|
var spec = specify(type, accepted[i], index);
|
|
|
|
if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
|
|
priority = spec;
|
|
}
|
|
}
|
|
|
|
return priority;
|
|
}
|
|
|
|
/**
|
|
* Get the specificity of the media type.
|
|
* @private
|
|
*/
|
|
|
|
function specify(type, spec, index) {
|
|
var p = parseMediaType(type);
|
|
var s = 0;
|
|
|
|
if (!p) {
|
|
return null;
|
|
}
|
|
|
|
if(spec.type.toLowerCase() == p.type.toLowerCase()) {
|
|
s |= 4;
|
|
} else if(spec.type != '*') {
|
|
return null;
|
|
}
|
|
|
|
if(spec.subtype.toLowerCase() == p.subtype.toLowerCase()) {
|
|
s |= 2;
|
|
} else if(spec.subtype != '*') {
|
|
return null;
|
|
}
|
|
|
|
var keys = Object.keys(spec.params);
|
|
if (keys.length > 0) {
|
|
if (keys.every(function (k) {
|
|
return spec.params[k] == '*' || (spec.params[k] || '').toLowerCase() == (p.params[k] || '').toLowerCase();
|
|
})) {
|
|
s |= 1;
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
|
|
return {
|
|
i: index,
|
|
o: spec.i,
|
|
q: spec.q,
|
|
s: s,
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the preferred media types from an Accept header.
|
|
* @public
|
|
*/
|
|
|
|
function preferredMediaTypes(accept, provided) {
|
|
// RFC 2616 sec 14.2: no header = */*
|
|
var accepts = parseAccept(accept === undefined ? '*/*' : accept || '');
|
|
|
|
if (!provided) {
|
|
// sorted list of all types
|
|
return accepts
|
|
.filter(isQuality)
|
|
.sort(compareSpecs)
|
|
.map(getFullType);
|
|
}
|
|
|
|
var priorities = provided.map(function getPriority(type, index) {
|
|
return getMediaTypePriority(type, accepts, index);
|
|
});
|
|
|
|
// sorted list of accepted types
|
|
return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) {
|
|
return provided[priorities.indexOf(priority)];
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Compare two specs.
|
|
* @private
|
|
*/
|
|
|
|
function compareSpecs(a, b) {
|
|
return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0;
|
|
}
|
|
|
|
/**
|
|
* Get full type string.
|
|
* @private
|
|
*/
|
|
|
|
function getFullType(spec) {
|
|
return spec.type + '/' + spec.subtype;
|
|
}
|
|
|
|
/**
|
|
* Check if a spec has any quality.
|
|
* @private
|
|
*/
|
|
|
|
function isQuality(spec) {
|
|
return spec.q > 0;
|
|
}
|
|
|
|
/**
|
|
* Count the number of quotes in a string.
|
|
* @private
|
|
*/
|
|
|
|
function quoteCount(string) {
|
|
var count = 0;
|
|
var index = 0;
|
|
|
|
while ((index = string.indexOf('"', index)) !== -1) {
|
|
count++;
|
|
index++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Split a key value pair.
|
|
* @private
|
|
*/
|
|
|
|
function splitKeyValuePair(str) {
|
|
var index = str.indexOf('=');
|
|
var key;
|
|
var val;
|
|
|
|
if (index === -1) {
|
|
key = str;
|
|
} else {
|
|
key = str.substr(0, index);
|
|
val = str.substr(index + 1);
|
|
}
|
|
|
|
return [key, val];
|
|
}
|
|
|
|
/**
|
|
* Split an Accept header into media types.
|
|
* @private
|
|
*/
|
|
|
|
function splitMediaTypes(accept) {
|
|
var accepts = accept.split(',');
|
|
|
|
for (var i = 1, j = 0; i < accepts.length; i++) {
|
|
if (quoteCount(accepts[j]) % 2 == 0) {
|
|
accepts[++j] = accepts[i];
|
|
} else {
|
|
accepts[j] += ',' + accepts[i];
|
|
}
|
|
}
|
|
|
|
// trim accepts
|
|
accepts.length = j + 1;
|
|
|
|
return accepts;
|
|
}
|
|
|
|
/**
|
|
* Split a string of parameters.
|
|
* @private
|
|
*/
|
|
|
|
function splitParameters(str) {
|
|
var parameters = str.split(';');
|
|
|
|
for (var i = 1, j = 0; i < parameters.length; i++) {
|
|
if (quoteCount(parameters[j]) % 2 == 0) {
|
|
parameters[++j] = parameters[i];
|
|
} else {
|
|
parameters[j] += ';' + parameters[i];
|
|
}
|
|
}
|
|
|
|
// trim parameters
|
|
parameters.length = j + 1;
|
|
|
|
for (var i = 0; i < parameters.length; i++) {
|
|
parameters[i] = parameters[i].trim();
|
|
}
|
|
|
|
return parameters;
|
|
}
|
|
|
|
/*!
|
|
* negotiator
|
|
* Copyright(c) 2012 Federico Romero
|
|
* Copyright(c) 2012-2014 Isaac Z. Schlueter
|
|
* Copyright(c) 2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Cached loaded submodules.
|
|
* @private
|
|
*/
|
|
|
|
var modules = Object.create(null);
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
negotiator.exports = Negotiator$1;
|
|
negotiator.exports.Negotiator = Negotiator$1;
|
|
|
|
/**
|
|
* Create a Negotiator instance from a request.
|
|
* @param {object} request
|
|
* @public
|
|
*/
|
|
|
|
function Negotiator$1(request) {
|
|
if (!(this instanceof Negotiator$1)) {
|
|
return new Negotiator$1(request);
|
|
}
|
|
|
|
this.request = request;
|
|
}
|
|
|
|
Negotiator$1.prototype.charset = function charset(available) {
|
|
var set = this.charsets(available);
|
|
return set && set[0];
|
|
};
|
|
|
|
Negotiator$1.prototype.charsets = function charsets(available) {
|
|
var preferredCharsets = loadModule('charset').preferredCharsets;
|
|
return preferredCharsets(this.request.headers['accept-charset'], available);
|
|
};
|
|
|
|
Negotiator$1.prototype.encoding = function encoding(available) {
|
|
var set = this.encodings(available);
|
|
return set && set[0];
|
|
};
|
|
|
|
Negotiator$1.prototype.encodings = function encodings(available) {
|
|
var preferredEncodings = loadModule('encoding').preferredEncodings;
|
|
return preferredEncodings(this.request.headers['accept-encoding'], available);
|
|
};
|
|
|
|
Negotiator$1.prototype.language = function language(available) {
|
|
var set = this.languages(available);
|
|
return set && set[0];
|
|
};
|
|
|
|
Negotiator$1.prototype.languages = function languages(available) {
|
|
var preferredLanguages = loadModule('language').preferredLanguages;
|
|
return preferredLanguages(this.request.headers['accept-language'], available);
|
|
};
|
|
|
|
Negotiator$1.prototype.mediaType = function mediaType(available) {
|
|
var set = this.mediaTypes(available);
|
|
return set && set[0];
|
|
};
|
|
|
|
Negotiator$1.prototype.mediaTypes = function mediaTypes(available) {
|
|
var preferredMediaTypes = loadModule('mediaType').preferredMediaTypes;
|
|
return preferredMediaTypes(this.request.headers.accept, available);
|
|
};
|
|
|
|
// Backwards compatibility
|
|
Negotiator$1.prototype.preferredCharset = Negotiator$1.prototype.charset;
|
|
Negotiator$1.prototype.preferredCharsets = Negotiator$1.prototype.charsets;
|
|
Negotiator$1.prototype.preferredEncoding = Negotiator$1.prototype.encoding;
|
|
Negotiator$1.prototype.preferredEncodings = Negotiator$1.prototype.encodings;
|
|
Negotiator$1.prototype.preferredLanguage = Negotiator$1.prototype.language;
|
|
Negotiator$1.prototype.preferredLanguages = Negotiator$1.prototype.languages;
|
|
Negotiator$1.prototype.preferredMediaType = Negotiator$1.prototype.mediaType;
|
|
Negotiator$1.prototype.preferredMediaTypes = Negotiator$1.prototype.mediaTypes;
|
|
|
|
/**
|
|
* Load the given module.
|
|
* @private
|
|
*/
|
|
|
|
function loadModule(moduleName) {
|
|
var module = modules[moduleName];
|
|
|
|
if (module !== undefined) {
|
|
return module;
|
|
}
|
|
|
|
// This uses a switch for static require analysis
|
|
switch (moduleName) {
|
|
case 'charset':
|
|
module = charset.exports;
|
|
break;
|
|
case 'encoding':
|
|
module = encoding.exports;
|
|
break;
|
|
case 'language':
|
|
module = language.exports;
|
|
break;
|
|
case 'mediaType':
|
|
module = mediaType.exports;
|
|
break;
|
|
default:
|
|
throw new Error('Cannot find module \'' + moduleName + '\'');
|
|
}
|
|
|
|
// Store to prevent invoking require()
|
|
modules[moduleName] = module;
|
|
|
|
return module;
|
|
}
|
|
|
|
var mimeTypes = {};
|
|
|
|
var require$$0 = {
|
|
"application/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"application/3gpdash-qoe-report+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/3gpp-ims+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/3gpphal+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/3gpphalforms+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/a2l": {
|
|
source: "iana"
|
|
},
|
|
"application/activemessage": {
|
|
source: "iana"
|
|
},
|
|
"application/activity+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-costmap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-costmapfilter+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-directory+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointcost+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointcostparams+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointprop+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointpropparams+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-error+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-networkmap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-networkmapfilter+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-updatestreamcontrol+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-updatestreamparams+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/aml": {
|
|
source: "iana"
|
|
},
|
|
"application/andrew-inset": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ez"
|
|
]
|
|
},
|
|
"application/applefile": {
|
|
source: "iana"
|
|
},
|
|
"application/applixware": {
|
|
source: "apache",
|
|
extensions: [
|
|
"aw"
|
|
]
|
|
},
|
|
"application/atf": {
|
|
source: "iana"
|
|
},
|
|
"application/atfx": {
|
|
source: "iana"
|
|
},
|
|
"application/atom+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"atom"
|
|
]
|
|
},
|
|
"application/atomcat+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"atomcat"
|
|
]
|
|
},
|
|
"application/atomdeleted+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"atomdeleted"
|
|
]
|
|
},
|
|
"application/atomicmail": {
|
|
source: "iana"
|
|
},
|
|
"application/atomsvc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"atomsvc"
|
|
]
|
|
},
|
|
"application/atsc-dwd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"dwd"
|
|
]
|
|
},
|
|
"application/atsc-dynamic-event-message": {
|
|
source: "iana"
|
|
},
|
|
"application/atsc-held+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"held"
|
|
]
|
|
},
|
|
"application/atsc-rdt+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/atsc-rsat+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rsat"
|
|
]
|
|
},
|
|
"application/atxml": {
|
|
source: "iana"
|
|
},
|
|
"application/auth-policy+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/bacnet-xdd+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/batch-smtp": {
|
|
source: "iana"
|
|
},
|
|
"application/bdoc": {
|
|
compressible: false,
|
|
extensions: [
|
|
"bdoc"
|
|
]
|
|
},
|
|
"application/beep+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/calendar+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/calendar+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xcs"
|
|
]
|
|
},
|
|
"application/call-completion": {
|
|
source: "iana"
|
|
},
|
|
"application/cals-1840": {
|
|
source: "iana"
|
|
},
|
|
"application/captive+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/cbor-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/cccex": {
|
|
source: "iana"
|
|
},
|
|
"application/ccmp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ccxml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"ccxml"
|
|
]
|
|
},
|
|
"application/cdfx+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"cdfx"
|
|
]
|
|
},
|
|
"application/cdmi-capability": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdmia"
|
|
]
|
|
},
|
|
"application/cdmi-container": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdmic"
|
|
]
|
|
},
|
|
"application/cdmi-domain": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdmid"
|
|
]
|
|
},
|
|
"application/cdmi-object": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdmio"
|
|
]
|
|
},
|
|
"application/cdmi-queue": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdmiq"
|
|
]
|
|
},
|
|
"application/cdni": {
|
|
source: "iana"
|
|
},
|
|
"application/cea": {
|
|
source: "iana"
|
|
},
|
|
"application/cea-2018+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cellml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cfw": {
|
|
source: "iana"
|
|
},
|
|
"application/clr": {
|
|
source: "iana"
|
|
},
|
|
"application/clue+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/clue_info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cms": {
|
|
source: "iana"
|
|
},
|
|
"application/cnrp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/coap-group+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/coap-payload": {
|
|
source: "iana"
|
|
},
|
|
"application/commonground": {
|
|
source: "iana"
|
|
},
|
|
"application/conference-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cose": {
|
|
source: "iana"
|
|
},
|
|
"application/cose-key": {
|
|
source: "iana"
|
|
},
|
|
"application/cose-key-set": {
|
|
source: "iana"
|
|
},
|
|
"application/cpl+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/csrattrs": {
|
|
source: "iana"
|
|
},
|
|
"application/csta+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cstadata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/csvm+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cu-seeme": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cu"
|
|
]
|
|
},
|
|
"application/cwt": {
|
|
source: "iana"
|
|
},
|
|
"application/cybercash": {
|
|
source: "iana"
|
|
},
|
|
"application/dart": {
|
|
compressible: true
|
|
},
|
|
"application/dash+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mpd"
|
|
]
|
|
},
|
|
"application/dashdelta": {
|
|
source: "iana"
|
|
},
|
|
"application/davmount+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"davmount"
|
|
]
|
|
},
|
|
"application/dca-rft": {
|
|
source: "iana"
|
|
},
|
|
"application/dcd": {
|
|
source: "iana"
|
|
},
|
|
"application/dec-dx": {
|
|
source: "iana"
|
|
},
|
|
"application/dialog-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dicom": {
|
|
source: "iana"
|
|
},
|
|
"application/dicom+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dicom+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dii": {
|
|
source: "iana"
|
|
},
|
|
"application/dit": {
|
|
source: "iana"
|
|
},
|
|
"application/dns": {
|
|
source: "iana"
|
|
},
|
|
"application/dns+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dns-message": {
|
|
source: "iana"
|
|
},
|
|
"application/docbook+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"dbk"
|
|
]
|
|
},
|
|
"application/dots+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/dskpp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dssc+der": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dssc"
|
|
]
|
|
},
|
|
"application/dssc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xdssc"
|
|
]
|
|
},
|
|
"application/dvcs": {
|
|
source: "iana"
|
|
},
|
|
"application/ecmascript": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"es",
|
|
"ecma"
|
|
]
|
|
},
|
|
"application/edi-consent": {
|
|
source: "iana"
|
|
},
|
|
"application/edi-x12": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/edifact": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/efi": {
|
|
source: "iana"
|
|
},
|
|
"application/elm+json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/elm+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.cap+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.comment+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.control+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.deviceinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.ecall.msd": {
|
|
source: "iana"
|
|
},
|
|
"application/emergencycalldata.providerinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.serviceinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.subscriberinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.veds+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emma+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"emma"
|
|
]
|
|
},
|
|
"application/emotionml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"emotionml"
|
|
]
|
|
},
|
|
"application/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"application/epp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/epub+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"epub"
|
|
]
|
|
},
|
|
"application/eshop": {
|
|
source: "iana"
|
|
},
|
|
"application/exi": {
|
|
source: "iana",
|
|
extensions: [
|
|
"exi"
|
|
]
|
|
},
|
|
"application/expect-ct-report+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/fastinfoset": {
|
|
source: "iana"
|
|
},
|
|
"application/fastsoap": {
|
|
source: "iana"
|
|
},
|
|
"application/fdt+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"fdt"
|
|
]
|
|
},
|
|
"application/fhir+json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/fhir+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/fido.trusted-apps+json": {
|
|
compressible: true
|
|
},
|
|
"application/fits": {
|
|
source: "iana"
|
|
},
|
|
"application/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"application/font-sfnt": {
|
|
source: "iana"
|
|
},
|
|
"application/font-tdpfr": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pfr"
|
|
]
|
|
},
|
|
"application/font-woff": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/framework-attributes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/geo+json": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"geojson"
|
|
]
|
|
},
|
|
"application/geo+json-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/geopackage+sqlite3": {
|
|
source: "iana"
|
|
},
|
|
"application/geoxacml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/gltf-buffer": {
|
|
source: "iana"
|
|
},
|
|
"application/gml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"gml"
|
|
]
|
|
},
|
|
"application/gpx+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"gpx"
|
|
]
|
|
},
|
|
"application/gxf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"gxf"
|
|
]
|
|
},
|
|
"application/gzip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"gz"
|
|
]
|
|
},
|
|
"application/h224": {
|
|
source: "iana"
|
|
},
|
|
"application/held+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/hjson": {
|
|
extensions: [
|
|
"hjson"
|
|
]
|
|
},
|
|
"application/http": {
|
|
source: "iana"
|
|
},
|
|
"application/hyperstudio": {
|
|
source: "iana",
|
|
extensions: [
|
|
"stk"
|
|
]
|
|
},
|
|
"application/ibe-key-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ibe-pkg-reply+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ibe-pp-data": {
|
|
source: "iana"
|
|
},
|
|
"application/iges": {
|
|
source: "iana"
|
|
},
|
|
"application/im-iscomposing+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/index": {
|
|
source: "iana"
|
|
},
|
|
"application/index.cmd": {
|
|
source: "iana"
|
|
},
|
|
"application/index.obj": {
|
|
source: "iana"
|
|
},
|
|
"application/index.response": {
|
|
source: "iana"
|
|
},
|
|
"application/index.vnd": {
|
|
source: "iana"
|
|
},
|
|
"application/inkml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"ink",
|
|
"inkml"
|
|
]
|
|
},
|
|
"application/iotp": {
|
|
source: "iana"
|
|
},
|
|
"application/ipfix": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ipfix"
|
|
]
|
|
},
|
|
"application/ipp": {
|
|
source: "iana"
|
|
},
|
|
"application/isup": {
|
|
source: "iana"
|
|
},
|
|
"application/its+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"its"
|
|
]
|
|
},
|
|
"application/java-archive": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"jar",
|
|
"war",
|
|
"ear"
|
|
]
|
|
},
|
|
"application/java-serialized-object": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"ser"
|
|
]
|
|
},
|
|
"application/java-vm": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"class"
|
|
]
|
|
},
|
|
"application/javascript": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"js",
|
|
"mjs"
|
|
]
|
|
},
|
|
"application/jf2feed+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jose": {
|
|
source: "iana"
|
|
},
|
|
"application/jose+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jrd+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jscalendar+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"json",
|
|
"map"
|
|
]
|
|
},
|
|
"application/json-patch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/json-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/json5": {
|
|
extensions: [
|
|
"json5"
|
|
]
|
|
},
|
|
"application/jsonml+json": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"jsonml"
|
|
]
|
|
},
|
|
"application/jwk+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jwk-set+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/kpml-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/kpml-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ld+json": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"jsonld"
|
|
]
|
|
},
|
|
"application/lgr+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"lgr"
|
|
]
|
|
},
|
|
"application/link-format": {
|
|
source: "iana"
|
|
},
|
|
"application/load-control+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/lost+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"lostxml"
|
|
]
|
|
},
|
|
"application/lostsync+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/lpf+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/lxf": {
|
|
source: "iana"
|
|
},
|
|
"application/mac-binhex40": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hqx"
|
|
]
|
|
},
|
|
"application/mac-compactpro": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cpt"
|
|
]
|
|
},
|
|
"application/macwriteii": {
|
|
source: "iana"
|
|
},
|
|
"application/mads+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mads"
|
|
]
|
|
},
|
|
"application/manifest+json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"webmanifest"
|
|
]
|
|
},
|
|
"application/marc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mrc"
|
|
]
|
|
},
|
|
"application/marcxml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mrcx"
|
|
]
|
|
},
|
|
"application/mathematica": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ma",
|
|
"nb",
|
|
"mb"
|
|
]
|
|
},
|
|
"application/mathml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mathml"
|
|
]
|
|
},
|
|
"application/mathml-content+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mathml-presentation+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-associated-procedure-description+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-deregister+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-envelope+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-msk+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-msk-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-protection-description+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-reception-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-register+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-register-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-schedule+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-user-service-description+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbox": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mbox"
|
|
]
|
|
},
|
|
"application/media-policy-dataset+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/media_control+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mediaservercontrol+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mscml"
|
|
]
|
|
},
|
|
"application/merge-patch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/metalink+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"metalink"
|
|
]
|
|
},
|
|
"application/metalink4+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"meta4"
|
|
]
|
|
},
|
|
"application/mets+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mets"
|
|
]
|
|
},
|
|
"application/mf4": {
|
|
source: "iana"
|
|
},
|
|
"application/mikey": {
|
|
source: "iana"
|
|
},
|
|
"application/mipc": {
|
|
source: "iana"
|
|
},
|
|
"application/missing-blocks+cbor-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/mmt-aei+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"maei"
|
|
]
|
|
},
|
|
"application/mmt-usd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"musd"
|
|
]
|
|
},
|
|
"application/mods+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mods"
|
|
]
|
|
},
|
|
"application/moss-keys": {
|
|
source: "iana"
|
|
},
|
|
"application/moss-signature": {
|
|
source: "iana"
|
|
},
|
|
"application/mosskey-data": {
|
|
source: "iana"
|
|
},
|
|
"application/mosskey-request": {
|
|
source: "iana"
|
|
},
|
|
"application/mp21": {
|
|
source: "iana",
|
|
extensions: [
|
|
"m21",
|
|
"mp21"
|
|
]
|
|
},
|
|
"application/mp4": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mp4s",
|
|
"m4p"
|
|
]
|
|
},
|
|
"application/mpeg4-generic": {
|
|
source: "iana"
|
|
},
|
|
"application/mpeg4-iod": {
|
|
source: "iana"
|
|
},
|
|
"application/mpeg4-iod-xmt": {
|
|
source: "iana"
|
|
},
|
|
"application/mrb-consumer+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mrb-publish+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/msc-ivr+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/msc-mixer+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/msword": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"doc",
|
|
"dot"
|
|
]
|
|
},
|
|
"application/mud+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/multipart-core": {
|
|
source: "iana"
|
|
},
|
|
"application/mxf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mxf"
|
|
]
|
|
},
|
|
"application/n-quads": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nq"
|
|
]
|
|
},
|
|
"application/n-triples": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nt"
|
|
]
|
|
},
|
|
"application/nasdata": {
|
|
source: "iana"
|
|
},
|
|
"application/news-checkgroups": {
|
|
source: "iana",
|
|
charset: "US-ASCII"
|
|
},
|
|
"application/news-groupinfo": {
|
|
source: "iana",
|
|
charset: "US-ASCII"
|
|
},
|
|
"application/news-transmission": {
|
|
source: "iana"
|
|
},
|
|
"application/nlsml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/node": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cjs"
|
|
]
|
|
},
|
|
"application/nss": {
|
|
source: "iana"
|
|
},
|
|
"application/oauth-authz-req+jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/ocsp-request": {
|
|
source: "iana"
|
|
},
|
|
"application/ocsp-response": {
|
|
source: "iana"
|
|
},
|
|
"application/octet-stream": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"bin",
|
|
"dms",
|
|
"lrf",
|
|
"mar",
|
|
"so",
|
|
"dist",
|
|
"distz",
|
|
"pkg",
|
|
"bpk",
|
|
"dump",
|
|
"elc",
|
|
"deploy",
|
|
"exe",
|
|
"dll",
|
|
"deb",
|
|
"dmg",
|
|
"iso",
|
|
"img",
|
|
"msi",
|
|
"msp",
|
|
"msm",
|
|
"buffer"
|
|
]
|
|
},
|
|
"application/oda": {
|
|
source: "iana",
|
|
extensions: [
|
|
"oda"
|
|
]
|
|
},
|
|
"application/odm+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/odx": {
|
|
source: "iana"
|
|
},
|
|
"application/oebps-package+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"opf"
|
|
]
|
|
},
|
|
"application/ogg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"ogx"
|
|
]
|
|
},
|
|
"application/omdoc+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"omdoc"
|
|
]
|
|
},
|
|
"application/onenote": {
|
|
source: "apache",
|
|
extensions: [
|
|
"onetoc",
|
|
"onetoc2",
|
|
"onetmp",
|
|
"onepkg"
|
|
]
|
|
},
|
|
"application/opc-nodeset+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/oscore": {
|
|
source: "iana"
|
|
},
|
|
"application/oxps": {
|
|
source: "iana",
|
|
extensions: [
|
|
"oxps"
|
|
]
|
|
},
|
|
"application/p21+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/p2p-overlay+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"relo"
|
|
]
|
|
},
|
|
"application/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"application/passport": {
|
|
source: "iana"
|
|
},
|
|
"application/patch-ops-error+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xer"
|
|
]
|
|
},
|
|
"application/pdf": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"pdf"
|
|
]
|
|
},
|
|
"application/pdx": {
|
|
source: "iana"
|
|
},
|
|
"application/pem-certificate-chain": {
|
|
source: "iana"
|
|
},
|
|
"application/pgp-encrypted": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"pgp"
|
|
]
|
|
},
|
|
"application/pgp-keys": {
|
|
source: "iana"
|
|
},
|
|
"application/pgp-signature": {
|
|
source: "iana",
|
|
extensions: [
|
|
"asc",
|
|
"sig"
|
|
]
|
|
},
|
|
"application/pics-rules": {
|
|
source: "apache",
|
|
extensions: [
|
|
"prf"
|
|
]
|
|
},
|
|
"application/pidf+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/pidf-diff+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/pkcs10": {
|
|
source: "iana",
|
|
extensions: [
|
|
"p10"
|
|
]
|
|
},
|
|
"application/pkcs12": {
|
|
source: "iana"
|
|
},
|
|
"application/pkcs7-mime": {
|
|
source: "iana",
|
|
extensions: [
|
|
"p7m",
|
|
"p7c"
|
|
]
|
|
},
|
|
"application/pkcs7-signature": {
|
|
source: "iana",
|
|
extensions: [
|
|
"p7s"
|
|
]
|
|
},
|
|
"application/pkcs8": {
|
|
source: "iana",
|
|
extensions: [
|
|
"p8"
|
|
]
|
|
},
|
|
"application/pkcs8-encrypted": {
|
|
source: "iana"
|
|
},
|
|
"application/pkix-attr-cert": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ac"
|
|
]
|
|
},
|
|
"application/pkix-cert": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cer"
|
|
]
|
|
},
|
|
"application/pkix-crl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"crl"
|
|
]
|
|
},
|
|
"application/pkix-pkipath": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pkipath"
|
|
]
|
|
},
|
|
"application/pkixcmp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pki"
|
|
]
|
|
},
|
|
"application/pls+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"pls"
|
|
]
|
|
},
|
|
"application/poc-settings+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/postscript": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"ai",
|
|
"eps",
|
|
"ps"
|
|
]
|
|
},
|
|
"application/ppsp-tracker+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/problem+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/problem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/provenance+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"provx"
|
|
]
|
|
},
|
|
"application/prs.alvestrand.titrax-sheet": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.cww": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cww"
|
|
]
|
|
},
|
|
"application/prs.cyn": {
|
|
source: "iana",
|
|
charset: "7-BIT"
|
|
},
|
|
"application/prs.hpub+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/prs.nprend": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.plucker": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.rdf-xml-crypt": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.xsf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/pskc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"pskcxml"
|
|
]
|
|
},
|
|
"application/pvd+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/qsig": {
|
|
source: "iana"
|
|
},
|
|
"application/raml+yaml": {
|
|
compressible: true,
|
|
extensions: [
|
|
"raml"
|
|
]
|
|
},
|
|
"application/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"application/rdap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/rdf+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rdf",
|
|
"owl"
|
|
]
|
|
},
|
|
"application/reginfo+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rif"
|
|
]
|
|
},
|
|
"application/relax-ng-compact-syntax": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rnc"
|
|
]
|
|
},
|
|
"application/remote-printing": {
|
|
source: "iana"
|
|
},
|
|
"application/reputon+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/resource-lists+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rl"
|
|
]
|
|
},
|
|
"application/resource-lists-diff+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rld"
|
|
]
|
|
},
|
|
"application/rfc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/riscos": {
|
|
source: "iana"
|
|
},
|
|
"application/rlmi+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/rls-services+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rs"
|
|
]
|
|
},
|
|
"application/route-apd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rapd"
|
|
]
|
|
},
|
|
"application/route-s-tsid+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"sls"
|
|
]
|
|
},
|
|
"application/route-usd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rusd"
|
|
]
|
|
},
|
|
"application/rpki-ghostbusters": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gbr"
|
|
]
|
|
},
|
|
"application/rpki-manifest": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mft"
|
|
]
|
|
},
|
|
"application/rpki-publication": {
|
|
source: "iana"
|
|
},
|
|
"application/rpki-roa": {
|
|
source: "iana",
|
|
extensions: [
|
|
"roa"
|
|
]
|
|
},
|
|
"application/rpki-updown": {
|
|
source: "iana"
|
|
},
|
|
"application/rsd+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"rsd"
|
|
]
|
|
},
|
|
"application/rss+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"rss"
|
|
]
|
|
},
|
|
"application/rtf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rtf"
|
|
]
|
|
},
|
|
"application/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"application/rtx": {
|
|
source: "iana"
|
|
},
|
|
"application/samlassertion+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/samlmetadata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sarif+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sarif-external-properties+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sbe": {
|
|
source: "iana"
|
|
},
|
|
"application/sbml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"sbml"
|
|
]
|
|
},
|
|
"application/scaip+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/scim+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/scvp-cv-request": {
|
|
source: "iana",
|
|
extensions: [
|
|
"scq"
|
|
]
|
|
},
|
|
"application/scvp-cv-response": {
|
|
source: "iana",
|
|
extensions: [
|
|
"scs"
|
|
]
|
|
},
|
|
"application/scvp-vp-request": {
|
|
source: "iana",
|
|
extensions: [
|
|
"spq"
|
|
]
|
|
},
|
|
"application/scvp-vp-response": {
|
|
source: "iana",
|
|
extensions: [
|
|
"spp"
|
|
]
|
|
},
|
|
"application/sdp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sdp"
|
|
]
|
|
},
|
|
"application/secevent+jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/senml+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/senml+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/senml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"senmlx"
|
|
]
|
|
},
|
|
"application/senml-etch+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/senml-etch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/senml-exi": {
|
|
source: "iana"
|
|
},
|
|
"application/sensml+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/sensml+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sensml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"sensmlx"
|
|
]
|
|
},
|
|
"application/sensml-exi": {
|
|
source: "iana"
|
|
},
|
|
"application/sep+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sep-exi": {
|
|
source: "iana"
|
|
},
|
|
"application/session-info": {
|
|
source: "iana"
|
|
},
|
|
"application/set-payment": {
|
|
source: "iana"
|
|
},
|
|
"application/set-payment-initiation": {
|
|
source: "iana",
|
|
extensions: [
|
|
"setpay"
|
|
]
|
|
},
|
|
"application/set-registration": {
|
|
source: "iana"
|
|
},
|
|
"application/set-registration-initiation": {
|
|
source: "iana",
|
|
extensions: [
|
|
"setreg"
|
|
]
|
|
},
|
|
"application/sgml": {
|
|
source: "iana"
|
|
},
|
|
"application/sgml-open-catalog": {
|
|
source: "iana"
|
|
},
|
|
"application/shf+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"shf"
|
|
]
|
|
},
|
|
"application/sieve": {
|
|
source: "iana",
|
|
extensions: [
|
|
"siv",
|
|
"sieve"
|
|
]
|
|
},
|
|
"application/simple-filter+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/simple-message-summary": {
|
|
source: "iana"
|
|
},
|
|
"application/simplesymbolcontainer": {
|
|
source: "iana"
|
|
},
|
|
"application/sipc": {
|
|
source: "iana"
|
|
},
|
|
"application/slate": {
|
|
source: "iana"
|
|
},
|
|
"application/smil": {
|
|
source: "iana"
|
|
},
|
|
"application/smil+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"smi",
|
|
"smil"
|
|
]
|
|
},
|
|
"application/smpte336m": {
|
|
source: "iana"
|
|
},
|
|
"application/soap+fastinfoset": {
|
|
source: "iana"
|
|
},
|
|
"application/soap+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sparql-query": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rq"
|
|
]
|
|
},
|
|
"application/sparql-results+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"srx"
|
|
]
|
|
},
|
|
"application/spirits-event+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sql": {
|
|
source: "iana"
|
|
},
|
|
"application/srgs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gram"
|
|
]
|
|
},
|
|
"application/srgs+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"grxml"
|
|
]
|
|
},
|
|
"application/sru+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"sru"
|
|
]
|
|
},
|
|
"application/ssdl+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"ssdl"
|
|
]
|
|
},
|
|
"application/ssml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"ssml"
|
|
]
|
|
},
|
|
"application/stix+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/swid+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"swidtag"
|
|
]
|
|
},
|
|
"application/tamp-apex-update": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-apex-update-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-community-update": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-community-update-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-error": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-sequence-adjust": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-sequence-adjust-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-status-query": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-status-response": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-update": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-update-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tar": {
|
|
compressible: true
|
|
},
|
|
"application/taxii+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/td+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/tei+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"tei",
|
|
"teicorpus"
|
|
]
|
|
},
|
|
"application/tetra_isi": {
|
|
source: "iana"
|
|
},
|
|
"application/thraud+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"tfi"
|
|
]
|
|
},
|
|
"application/timestamp-query": {
|
|
source: "iana"
|
|
},
|
|
"application/timestamp-reply": {
|
|
source: "iana"
|
|
},
|
|
"application/timestamped-data": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tsd"
|
|
]
|
|
},
|
|
"application/tlsrpt+gzip": {
|
|
source: "iana"
|
|
},
|
|
"application/tlsrpt+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/tnauthlist": {
|
|
source: "iana"
|
|
},
|
|
"application/toml": {
|
|
compressible: true,
|
|
extensions: [
|
|
"toml"
|
|
]
|
|
},
|
|
"application/trickle-ice-sdpfrag": {
|
|
source: "iana"
|
|
},
|
|
"application/trig": {
|
|
source: "iana",
|
|
extensions: [
|
|
"trig"
|
|
]
|
|
},
|
|
"application/ttml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"ttml"
|
|
]
|
|
},
|
|
"application/tve-trigger": {
|
|
source: "iana"
|
|
},
|
|
"application/tzif": {
|
|
source: "iana"
|
|
},
|
|
"application/tzif-leap": {
|
|
source: "iana"
|
|
},
|
|
"application/ubjson": {
|
|
compressible: false,
|
|
extensions: [
|
|
"ubj"
|
|
]
|
|
},
|
|
"application/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"application/urc-grpsheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/urc-ressheet+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rsheet"
|
|
]
|
|
},
|
|
"application/urc-targetdesc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"td"
|
|
]
|
|
},
|
|
"application/urc-uisocketdesc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vcard+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vcard+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vemmi": {
|
|
source: "iana"
|
|
},
|
|
"application/vividence.scriptfile": {
|
|
source: "apache"
|
|
},
|
|
"application/vnd.1000minds.decision-model+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"1km"
|
|
]
|
|
},
|
|
"application/vnd.3gpp-prose+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp-prose-pc3ch+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp-v2x-local-service-information": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.5gnas": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.access-transfer-events+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.bsf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.gmop+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.gtpc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.interworking-data": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.lpp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mc-signalling-ear": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-affiliation-command+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-payload": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-service-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-signalling": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-ue-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-user-profile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-affiliation-command+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-floor-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-location-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-mbms-usage-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-service-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-signed+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-ue-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-ue-init-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-user-profile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-affiliation-command+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-affiliation-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-location-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-mbms-usage-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-service-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-transmission-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-ue-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-user-profile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mid-call+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.ngap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.pfcp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.pic-bw-large": {
|
|
source: "iana",
|
|
extensions: [
|
|
"plb"
|
|
]
|
|
},
|
|
"application/vnd.3gpp.pic-bw-small": {
|
|
source: "iana",
|
|
extensions: [
|
|
"psb"
|
|
]
|
|
},
|
|
"application/vnd.3gpp.pic-bw-var": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pvb"
|
|
]
|
|
},
|
|
"application/vnd.3gpp.s1ap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.sms": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.sms+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.srvcc-ext+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.srvcc-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.state-and-event-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.ussd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp2.bcmcsinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp2.sms": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp2.tcap": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tcap"
|
|
]
|
|
},
|
|
"application/vnd.3lightssoftware.imagescal": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3m.post-it-notes": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pwn"
|
|
]
|
|
},
|
|
"application/vnd.accpac.simply.aso": {
|
|
source: "iana",
|
|
extensions: [
|
|
"aso"
|
|
]
|
|
},
|
|
"application/vnd.accpac.simply.imp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"imp"
|
|
]
|
|
},
|
|
"application/vnd.acucobol": {
|
|
source: "iana",
|
|
extensions: [
|
|
"acu"
|
|
]
|
|
},
|
|
"application/vnd.acucorp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"atc",
|
|
"acutc"
|
|
]
|
|
},
|
|
"application/vnd.adobe.air-application-installer-package+zip": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"air"
|
|
]
|
|
},
|
|
"application/vnd.adobe.flash.movie": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.adobe.formscentral.fcdt": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fcdt"
|
|
]
|
|
},
|
|
"application/vnd.adobe.fxp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fxp",
|
|
"fxpl"
|
|
]
|
|
},
|
|
"application/vnd.adobe.partial-upload": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.adobe.xdp+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xdp"
|
|
]
|
|
},
|
|
"application/vnd.adobe.xfdf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xfdf"
|
|
]
|
|
},
|
|
"application/vnd.aether.imp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.afplinedata": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.afplinedata-pagedef": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.cmoca-cmresource": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.foca-charset": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.foca-codedfont": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.foca-codepage": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-cmtable": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-formdef": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-mediummap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-objectcontainer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-overlay": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-pagesegment": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ah-barcode": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ahead.space": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ahead"
|
|
]
|
|
},
|
|
"application/vnd.airzip.filesecure.azf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"azf"
|
|
]
|
|
},
|
|
"application/vnd.airzip.filesecure.azs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"azs"
|
|
]
|
|
},
|
|
"application/vnd.amadeus+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.amazon.ebook": {
|
|
source: "apache",
|
|
extensions: [
|
|
"azw"
|
|
]
|
|
},
|
|
"application/vnd.amazon.mobi8-ebook": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.americandynamics.acc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"acc"
|
|
]
|
|
},
|
|
"application/vnd.amiga.ami": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ami"
|
|
]
|
|
},
|
|
"application/vnd.amundsen.maze+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.android.ota": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.android.package-archive": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"apk"
|
|
]
|
|
},
|
|
"application/vnd.anki": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.anser-web-certificate-issue-initiation": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cii"
|
|
]
|
|
},
|
|
"application/vnd.anser-web-funds-transfer-initiation": {
|
|
source: "apache",
|
|
extensions: [
|
|
"fti"
|
|
]
|
|
},
|
|
"application/vnd.antix.game-component": {
|
|
source: "iana",
|
|
extensions: [
|
|
"atx"
|
|
]
|
|
},
|
|
"application/vnd.apache.arrow.file": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.arrow.stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.thrift.binary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.thrift.compact": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.thrift.json": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.api+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.aplextor.warrp+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.apothekende.reservation+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.apple.installer+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mpkg"
|
|
]
|
|
},
|
|
"application/vnd.apple.keynote": {
|
|
source: "iana",
|
|
extensions: [
|
|
"key"
|
|
]
|
|
},
|
|
"application/vnd.apple.mpegurl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"m3u8"
|
|
]
|
|
},
|
|
"application/vnd.apple.numbers": {
|
|
source: "iana",
|
|
extensions: [
|
|
"numbers"
|
|
]
|
|
},
|
|
"application/vnd.apple.pages": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pages"
|
|
]
|
|
},
|
|
"application/vnd.apple.pkpass": {
|
|
compressible: false,
|
|
extensions: [
|
|
"pkpass"
|
|
]
|
|
},
|
|
"application/vnd.arastra.swi": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.aristanetworks.swi": {
|
|
source: "iana",
|
|
extensions: [
|
|
"swi"
|
|
]
|
|
},
|
|
"application/vnd.artisan+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.artsquare": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.astraea-software.iota": {
|
|
source: "iana",
|
|
extensions: [
|
|
"iota"
|
|
]
|
|
},
|
|
"application/vnd.audiograph": {
|
|
source: "iana",
|
|
extensions: [
|
|
"aep"
|
|
]
|
|
},
|
|
"application/vnd.autopackage": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.avalon+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.avistar+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.balsamiq.bmml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"bmml"
|
|
]
|
|
},
|
|
"application/vnd.balsamiq.bmpr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.banana-accounting": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bbf.usp.error": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bbf.usp.msg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bbf.usp.msg+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.bekitzur-stech+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.bint.med-content": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.biopax.rdf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.blink-idb-value-wrapper": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.blueice.multipass": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mpm"
|
|
]
|
|
},
|
|
"application/vnd.bluetooth.ep.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bluetooth.le.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bmi": {
|
|
source: "iana",
|
|
extensions: [
|
|
"bmi"
|
|
]
|
|
},
|
|
"application/vnd.bpf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bpf3": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.businessobjects": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rep"
|
|
]
|
|
},
|
|
"application/vnd.byu.uapi+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cab-jscript": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.canon-cpdl": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.canon-lips": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.capasystems-pg+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cendio.thinlinc.clientconf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.century-systems.tcp_stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.chemdraw+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"cdxml"
|
|
]
|
|
},
|
|
"application/vnd.chess-pgn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.chipnuts.karaoke-mmd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mmd"
|
|
]
|
|
},
|
|
"application/vnd.ciedi": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cinderella": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdy"
|
|
]
|
|
},
|
|
"application/vnd.cirpack.isdn-ext": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.citationstyles.style+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"csl"
|
|
]
|
|
},
|
|
"application/vnd.claymore": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cla"
|
|
]
|
|
},
|
|
"application/vnd.cloanto.rp9": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rp9"
|
|
]
|
|
},
|
|
"application/vnd.clonk.c4group": {
|
|
source: "iana",
|
|
extensions: [
|
|
"c4g",
|
|
"c4d",
|
|
"c4f",
|
|
"c4p",
|
|
"c4u"
|
|
]
|
|
},
|
|
"application/vnd.cluetrust.cartomobile-config": {
|
|
source: "iana",
|
|
extensions: [
|
|
"c11amc"
|
|
]
|
|
},
|
|
"application/vnd.cluetrust.cartomobile-config-pkg": {
|
|
source: "iana",
|
|
extensions: [
|
|
"c11amz"
|
|
]
|
|
},
|
|
"application/vnd.coffeescript": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.document": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.document-template": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.presentation": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.presentation-template": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.spreadsheet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.spreadsheet-template": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collection+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.collection.doc+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.collection.next+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.comicbook+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.comicbook-rar": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.commerce-battelle": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.commonspace": {
|
|
source: "iana",
|
|
extensions: [
|
|
"csp"
|
|
]
|
|
},
|
|
"application/vnd.contact.cmsg": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdbcmsg"
|
|
]
|
|
},
|
|
"application/vnd.coreos.ignition+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cosmocaller": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cmc"
|
|
]
|
|
},
|
|
"application/vnd.crick.clicker": {
|
|
source: "iana",
|
|
extensions: [
|
|
"clkx"
|
|
]
|
|
},
|
|
"application/vnd.crick.clicker.keyboard": {
|
|
source: "iana",
|
|
extensions: [
|
|
"clkk"
|
|
]
|
|
},
|
|
"application/vnd.crick.clicker.palette": {
|
|
source: "iana",
|
|
extensions: [
|
|
"clkp"
|
|
]
|
|
},
|
|
"application/vnd.crick.clicker.template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"clkt"
|
|
]
|
|
},
|
|
"application/vnd.crick.clicker.wordbank": {
|
|
source: "iana",
|
|
extensions: [
|
|
"clkw"
|
|
]
|
|
},
|
|
"application/vnd.criticaltools.wbs+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"wbs"
|
|
]
|
|
},
|
|
"application/vnd.cryptii.pipe+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.crypto-shade-file": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cryptomator.encrypted": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cryptomator.vault": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ctc-posml": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pml"
|
|
]
|
|
},
|
|
"application/vnd.ctct.ws+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cups-pdf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cups-postscript": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cups-ppd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ppd"
|
|
]
|
|
},
|
|
"application/vnd.cups-raster": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cups-raw": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.curl": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.curl.car": {
|
|
source: "apache",
|
|
extensions: [
|
|
"car"
|
|
]
|
|
},
|
|
"application/vnd.curl.pcurl": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pcurl"
|
|
]
|
|
},
|
|
"application/vnd.cyan.dean.root+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cybank": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cyclonedx+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cyclonedx+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.d2l.coursepackage1p0+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.d3m-dataset": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.d3m-problem": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dart": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"dart"
|
|
]
|
|
},
|
|
"application/vnd.data-vision.rdz": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rdz"
|
|
]
|
|
},
|
|
"application/vnd.datapackage+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dataresource+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dbf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dbf"
|
|
]
|
|
},
|
|
"application/vnd.debian.binary-package": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dece.data": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvf",
|
|
"uvvf",
|
|
"uvd",
|
|
"uvvd"
|
|
]
|
|
},
|
|
"application/vnd.dece.ttml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"uvt",
|
|
"uvvt"
|
|
]
|
|
},
|
|
"application/vnd.dece.unspecified": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvx",
|
|
"uvvx"
|
|
]
|
|
},
|
|
"application/vnd.dece.zip": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvz",
|
|
"uvvz"
|
|
]
|
|
},
|
|
"application/vnd.denovo.fcselayout-link": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fe_launch"
|
|
]
|
|
},
|
|
"application/vnd.desmume.movie": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dir-bi.plate-dl-nosuffix": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dm.delegation+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dna": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dna"
|
|
]
|
|
},
|
|
"application/vnd.document+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dolby.mlp": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mlp"
|
|
]
|
|
},
|
|
"application/vnd.dolby.mobile.1": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dolby.mobile.2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.doremir.scorecloud-binary-document": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dpgraph": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dpg"
|
|
]
|
|
},
|
|
"application/vnd.dreamfactory": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dfac"
|
|
]
|
|
},
|
|
"application/vnd.drive+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ds-keypoint": {
|
|
source: "apache",
|
|
extensions: [
|
|
"kpxx"
|
|
]
|
|
},
|
|
"application/vnd.dtg.local": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dtg.local.flash": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dtg.local.html": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ait": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ait"
|
|
]
|
|
},
|
|
"application/vnd.dvb.dvbisl+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.dvbj": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.esgcontainer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcdftnotifaccess": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgaccess": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgaccess2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgpdd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcroaming": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.iptv.alfec-base": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.iptv.alfec-enhancement": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.notif-aggregate-root+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-container+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-generic+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-ia-msglist+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-ia-registration-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-ia-registration-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-init+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.pfr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.service": {
|
|
source: "iana",
|
|
extensions: [
|
|
"svc"
|
|
]
|
|
},
|
|
"application/vnd.dxr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dynageo": {
|
|
source: "iana",
|
|
extensions: [
|
|
"geo"
|
|
]
|
|
},
|
|
"application/vnd.dzr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.easykaraoke.cdgdownload": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecdis-update": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecip.rlp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.chart": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mag"
|
|
]
|
|
},
|
|
"application/vnd.ecowin.filerequest": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.fileupdate": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.series": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.seriesrequest": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.seriesupdate": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.efi.img": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.efi.iso": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.emclient.accessrequest+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.enliven": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nml"
|
|
]
|
|
},
|
|
"application/vnd.enphase.envoy": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.eprints.data+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.epson.esf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"esf"
|
|
]
|
|
},
|
|
"application/vnd.epson.msf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"msf"
|
|
]
|
|
},
|
|
"application/vnd.epson.quickanime": {
|
|
source: "iana",
|
|
extensions: [
|
|
"qam"
|
|
]
|
|
},
|
|
"application/vnd.epson.salt": {
|
|
source: "iana",
|
|
extensions: [
|
|
"slt"
|
|
]
|
|
},
|
|
"application/vnd.epson.ssf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ssf"
|
|
]
|
|
},
|
|
"application/vnd.ericsson.quickcall": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.espass-espass+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.eszigno3+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"es3",
|
|
"et3"
|
|
]
|
|
},
|
|
"application/vnd.etsi.aoc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.asic-e+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.etsi.asic-s+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.etsi.cug+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvcommand+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvdiscovery+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsad-bc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsad-cod+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsad-npvr+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvservice+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsync+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvueprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.mcid+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.mheg5": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.etsi.overload-control-policy-dataset+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.pstn+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.sci+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.simservs+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.timestamp-token": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.etsi.tsl+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.tsl.der": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.eudora.data": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.profile": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.settings": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.theme": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.exstream-empower+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.exstream-package": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ezpix-album": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ez2"
|
|
]
|
|
},
|
|
"application/vnd.ezpix-package": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ez3"
|
|
]
|
|
},
|
|
"application/vnd.f-secure.mobile": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fastcopy-disk-image": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fdf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fdf"
|
|
]
|
|
},
|
|
"application/vnd.fdsn.mseed": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mseed"
|
|
]
|
|
},
|
|
"application/vnd.fdsn.seed": {
|
|
source: "iana",
|
|
extensions: [
|
|
"seed",
|
|
"dataless"
|
|
]
|
|
},
|
|
"application/vnd.ffsns": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ficlab.flb+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.filmit.zfc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fints": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.firemonkeys.cloudcell": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.flographit": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gph"
|
|
]
|
|
},
|
|
"application/vnd.fluxtime.clip": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ftc"
|
|
]
|
|
},
|
|
"application/vnd.font-fontforge-sfd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.framemaker": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fm",
|
|
"frame",
|
|
"maker",
|
|
"book"
|
|
]
|
|
},
|
|
"application/vnd.frogans.fnc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fnc"
|
|
]
|
|
},
|
|
"application/vnd.frogans.ltf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ltf"
|
|
]
|
|
},
|
|
"application/vnd.fsc.weblaunch": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fsc"
|
|
]
|
|
},
|
|
"application/vnd.fujifilm.fb.docuworks": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujifilm.fb.docuworks.binder": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujifilm.fb.docuworks.container": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujifilm.fb.jfi+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.fujitsu.oasys": {
|
|
source: "iana",
|
|
extensions: [
|
|
"oas"
|
|
]
|
|
},
|
|
"application/vnd.fujitsu.oasys2": {
|
|
source: "iana",
|
|
extensions: [
|
|
"oa2"
|
|
]
|
|
},
|
|
"application/vnd.fujitsu.oasys3": {
|
|
source: "iana",
|
|
extensions: [
|
|
"oa3"
|
|
]
|
|
},
|
|
"application/vnd.fujitsu.oasysgp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fg5"
|
|
]
|
|
},
|
|
"application/vnd.fujitsu.oasysprs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"bh2"
|
|
]
|
|
},
|
|
"application/vnd.fujixerox.art-ex": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujixerox.art4": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujixerox.ddd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ddd"
|
|
]
|
|
},
|
|
"application/vnd.fujixerox.docuworks": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xdw"
|
|
]
|
|
},
|
|
"application/vnd.fujixerox.docuworks.binder": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xbd"
|
|
]
|
|
},
|
|
"application/vnd.fujixerox.docuworks.container": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujixerox.hbpl": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fut-misnet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.futoin+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.futoin+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.fuzzysheet": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fzs"
|
|
]
|
|
},
|
|
"application/vnd.genomatix.tuxedo": {
|
|
source: "iana",
|
|
extensions: [
|
|
"txd"
|
|
]
|
|
},
|
|
"application/vnd.gentics.grd+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.geo+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.geocube+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.geogebra.file": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ggb"
|
|
]
|
|
},
|
|
"application/vnd.geogebra.slides": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.geogebra.tool": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ggt"
|
|
]
|
|
},
|
|
"application/vnd.geometry-explorer": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gex",
|
|
"gre"
|
|
]
|
|
},
|
|
"application/vnd.geonext": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gxt"
|
|
]
|
|
},
|
|
"application/vnd.geoplan": {
|
|
source: "iana",
|
|
extensions: [
|
|
"g2w"
|
|
]
|
|
},
|
|
"application/vnd.geospace": {
|
|
source: "iana",
|
|
extensions: [
|
|
"g3w"
|
|
]
|
|
},
|
|
"application/vnd.gerber": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.globalplatform.card-content-mgt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.globalplatform.card-content-mgt-response": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.gmx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gmx"
|
|
]
|
|
},
|
|
"application/vnd.google-apps.document": {
|
|
compressible: false,
|
|
extensions: [
|
|
"gdoc"
|
|
]
|
|
},
|
|
"application/vnd.google-apps.presentation": {
|
|
compressible: false,
|
|
extensions: [
|
|
"gslides"
|
|
]
|
|
},
|
|
"application/vnd.google-apps.spreadsheet": {
|
|
compressible: false,
|
|
extensions: [
|
|
"gsheet"
|
|
]
|
|
},
|
|
"application/vnd.google-earth.kml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"kml"
|
|
]
|
|
},
|
|
"application/vnd.google-earth.kmz": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"kmz"
|
|
]
|
|
},
|
|
"application/vnd.gov.sk.e-form+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.gov.sk.e-form+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.gov.sk.xmldatacontainer+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.grafeq": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gqf",
|
|
"gqs"
|
|
]
|
|
},
|
|
"application/vnd.gridmp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.groove-account": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gac"
|
|
]
|
|
},
|
|
"application/vnd.groove-help": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ghf"
|
|
]
|
|
},
|
|
"application/vnd.groove-identity-message": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gim"
|
|
]
|
|
},
|
|
"application/vnd.groove-injector": {
|
|
source: "iana",
|
|
extensions: [
|
|
"grv"
|
|
]
|
|
},
|
|
"application/vnd.groove-tool-message": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gtm"
|
|
]
|
|
},
|
|
"application/vnd.groove-tool-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tpl"
|
|
]
|
|
},
|
|
"application/vnd.groove-vcard": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vcg"
|
|
]
|
|
},
|
|
"application/vnd.hal+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hal+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"hal"
|
|
]
|
|
},
|
|
"application/vnd.handheld-entertainment+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"zmm"
|
|
]
|
|
},
|
|
"application/vnd.hbci": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hbci"
|
|
]
|
|
},
|
|
"application/vnd.hc+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hcl-bireports": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.hdt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.heroku+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hhe.lesson-player": {
|
|
source: "iana",
|
|
extensions: [
|
|
"les"
|
|
]
|
|
},
|
|
"application/vnd.hp-hpgl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hpgl"
|
|
]
|
|
},
|
|
"application/vnd.hp-hpid": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hpid"
|
|
]
|
|
},
|
|
"application/vnd.hp-hps": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hps"
|
|
]
|
|
},
|
|
"application/vnd.hp-jlyt": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jlt"
|
|
]
|
|
},
|
|
"application/vnd.hp-pcl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pcl"
|
|
]
|
|
},
|
|
"application/vnd.hp-pclxl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pclxl"
|
|
]
|
|
},
|
|
"application/vnd.httphone": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.hydrostatix.sof-data": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sfd-hdstx"
|
|
]
|
|
},
|
|
"application/vnd.hyper+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hyper-item+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hyperdrive+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hzn-3d-crossword": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ibm.afplinedata": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ibm.electronic-media": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ibm.minipay": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mpy"
|
|
]
|
|
},
|
|
"application/vnd.ibm.modcap": {
|
|
source: "iana",
|
|
extensions: [
|
|
"afp",
|
|
"listafp",
|
|
"list3820"
|
|
]
|
|
},
|
|
"application/vnd.ibm.rights-management": {
|
|
source: "iana",
|
|
extensions: [
|
|
"irm"
|
|
]
|
|
},
|
|
"application/vnd.ibm.secure-container": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sc"
|
|
]
|
|
},
|
|
"application/vnd.iccprofile": {
|
|
source: "iana",
|
|
extensions: [
|
|
"icc",
|
|
"icm"
|
|
]
|
|
},
|
|
"application/vnd.ieee.1905": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.igloader": {
|
|
source: "iana",
|
|
extensions: [
|
|
"igl"
|
|
]
|
|
},
|
|
"application/vnd.imagemeter.folder+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.imagemeter.image+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.immervision-ivp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ivp"
|
|
]
|
|
},
|
|
"application/vnd.immervision-ivu": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ivu"
|
|
]
|
|
},
|
|
"application/vnd.ims.imsccv1p1": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ims.imsccv1p2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ims.imsccv1p3": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ims.lis.v2.result+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolconsumerprofile+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolproxy+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolproxy.id+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolsettings+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolsettings.simple+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.informedcontrol.rms+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.informix-visionary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.infotech.project": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.infotech.project+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.innopath.wamp.notification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.insors.igm": {
|
|
source: "iana",
|
|
extensions: [
|
|
"igm"
|
|
]
|
|
},
|
|
"application/vnd.intercon.formnet": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xpw",
|
|
"xpx"
|
|
]
|
|
},
|
|
"application/vnd.intergeo": {
|
|
source: "iana",
|
|
extensions: [
|
|
"i2g"
|
|
]
|
|
},
|
|
"application/vnd.intertrust.digibox": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.intertrust.nncp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.intu.qbo": {
|
|
source: "iana",
|
|
extensions: [
|
|
"qbo"
|
|
]
|
|
},
|
|
"application/vnd.intu.qfx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"qfx"
|
|
]
|
|
},
|
|
"application/vnd.iptc.g2.catalogitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.conceptitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.knowledgeitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.newsitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.newsmessage+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.packageitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.planningitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ipunplugged.rcprofile": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rcprofile"
|
|
]
|
|
},
|
|
"application/vnd.irepository.package+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"irp"
|
|
]
|
|
},
|
|
"application/vnd.is-xpr": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xpr"
|
|
]
|
|
},
|
|
"application/vnd.isac.fcs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fcs"
|
|
]
|
|
},
|
|
"application/vnd.iso11783-10+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.jam": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jam"
|
|
]
|
|
},
|
|
"application/vnd.japannet-directory-service": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-jpnstore-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-payment-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-registration": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-registration-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-setstore-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-verification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-verification-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.jcp.javame.midlet-rms": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rms"
|
|
]
|
|
},
|
|
"application/vnd.jisp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jisp"
|
|
]
|
|
},
|
|
"application/vnd.joost.joda-archive": {
|
|
source: "iana",
|
|
extensions: [
|
|
"joda"
|
|
]
|
|
},
|
|
"application/vnd.jsk.isdn-ngn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.kahootz": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ktz",
|
|
"ktr"
|
|
]
|
|
},
|
|
"application/vnd.kde.karbon": {
|
|
source: "iana",
|
|
extensions: [
|
|
"karbon"
|
|
]
|
|
},
|
|
"application/vnd.kde.kchart": {
|
|
source: "iana",
|
|
extensions: [
|
|
"chrt"
|
|
]
|
|
},
|
|
"application/vnd.kde.kformula": {
|
|
source: "iana",
|
|
extensions: [
|
|
"kfo"
|
|
]
|
|
},
|
|
"application/vnd.kde.kivio": {
|
|
source: "iana",
|
|
extensions: [
|
|
"flw"
|
|
]
|
|
},
|
|
"application/vnd.kde.kontour": {
|
|
source: "iana",
|
|
extensions: [
|
|
"kon"
|
|
]
|
|
},
|
|
"application/vnd.kde.kpresenter": {
|
|
source: "iana",
|
|
extensions: [
|
|
"kpr",
|
|
"kpt"
|
|
]
|
|
},
|
|
"application/vnd.kde.kspread": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ksp"
|
|
]
|
|
},
|
|
"application/vnd.kde.kword": {
|
|
source: "iana",
|
|
extensions: [
|
|
"kwd",
|
|
"kwt"
|
|
]
|
|
},
|
|
"application/vnd.kenameaapp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"htke"
|
|
]
|
|
},
|
|
"application/vnd.kidspiration": {
|
|
source: "iana",
|
|
extensions: [
|
|
"kia"
|
|
]
|
|
},
|
|
"application/vnd.kinar": {
|
|
source: "iana",
|
|
extensions: [
|
|
"kne",
|
|
"knp"
|
|
]
|
|
},
|
|
"application/vnd.koan": {
|
|
source: "iana",
|
|
extensions: [
|
|
"skp",
|
|
"skd",
|
|
"skt",
|
|
"skm"
|
|
]
|
|
},
|
|
"application/vnd.kodak-descriptor": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sse"
|
|
]
|
|
},
|
|
"application/vnd.las": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.las.las+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.las.las+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"lasxml"
|
|
]
|
|
},
|
|
"application/vnd.laszip": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.leap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.liberty-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.llamagraphics.life-balance.desktop": {
|
|
source: "iana",
|
|
extensions: [
|
|
"lbd"
|
|
]
|
|
},
|
|
"application/vnd.llamagraphics.life-balance.exchange+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"lbe"
|
|
]
|
|
},
|
|
"application/vnd.logipipe.circuit+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.loom": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.lotus-1-2-3": {
|
|
source: "iana",
|
|
extensions: [
|
|
"123"
|
|
]
|
|
},
|
|
"application/vnd.lotus-approach": {
|
|
source: "iana",
|
|
extensions: [
|
|
"apr"
|
|
]
|
|
},
|
|
"application/vnd.lotus-freelance": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pre"
|
|
]
|
|
},
|
|
"application/vnd.lotus-notes": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nsf"
|
|
]
|
|
},
|
|
"application/vnd.lotus-organizer": {
|
|
source: "iana",
|
|
extensions: [
|
|
"org"
|
|
]
|
|
},
|
|
"application/vnd.lotus-screencam": {
|
|
source: "iana",
|
|
extensions: [
|
|
"scm"
|
|
]
|
|
},
|
|
"application/vnd.lotus-wordpro": {
|
|
source: "iana",
|
|
extensions: [
|
|
"lwp"
|
|
]
|
|
},
|
|
"application/vnd.macports.portpkg": {
|
|
source: "iana",
|
|
extensions: [
|
|
"portpkg"
|
|
]
|
|
},
|
|
"application/vnd.mapbox-vector-tile": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mvt"
|
|
]
|
|
},
|
|
"application/vnd.marlin.drm.actiontoken+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.marlin.drm.conftoken+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.marlin.drm.license+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.marlin.drm.mdcf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mason+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.maxmind.maxmind-db": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mcd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mcd"
|
|
]
|
|
},
|
|
"application/vnd.medcalcdata": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mc1"
|
|
]
|
|
},
|
|
"application/vnd.mediastation.cdkey": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cdkey"
|
|
]
|
|
},
|
|
"application/vnd.meridian-slingshot": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mfer": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mwf"
|
|
]
|
|
},
|
|
"application/vnd.mfmp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mfm"
|
|
]
|
|
},
|
|
"application/vnd.micro+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.micrografx.flo": {
|
|
source: "iana",
|
|
extensions: [
|
|
"flo"
|
|
]
|
|
},
|
|
"application/vnd.micrografx.igx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"igx"
|
|
]
|
|
},
|
|
"application/vnd.microsoft.portable-executable": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.microsoft.windows.thumbnail-cache": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.miele+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.mif": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mif"
|
|
]
|
|
},
|
|
"application/vnd.minisoft-hp3000-save": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mitsubishi.misty-guard.trustweb": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mobius.daf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"daf"
|
|
]
|
|
},
|
|
"application/vnd.mobius.dis": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dis"
|
|
]
|
|
},
|
|
"application/vnd.mobius.mbk": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mbk"
|
|
]
|
|
},
|
|
"application/vnd.mobius.mqy": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mqy"
|
|
]
|
|
},
|
|
"application/vnd.mobius.msl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"msl"
|
|
]
|
|
},
|
|
"application/vnd.mobius.plc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"plc"
|
|
]
|
|
},
|
|
"application/vnd.mobius.txf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"txf"
|
|
]
|
|
},
|
|
"application/vnd.mophun.application": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mpn"
|
|
]
|
|
},
|
|
"application/vnd.mophun.certificate": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mpc"
|
|
]
|
|
},
|
|
"application/vnd.motorola.flexsuite": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.adsi": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.fis": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.gotap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.kmr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.ttc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.wem": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.iprm": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mozilla.xul+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xul"
|
|
]
|
|
},
|
|
"application/vnd.ms-3mfdocument": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-artgalry": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cil"
|
|
]
|
|
},
|
|
"application/vnd.ms-asf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-cab-compressed": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cab"
|
|
]
|
|
},
|
|
"application/vnd.ms-color.iccprofile": {
|
|
source: "apache"
|
|
},
|
|
"application/vnd.ms-excel": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"xls",
|
|
"xlm",
|
|
"xla",
|
|
"xlc",
|
|
"xlt",
|
|
"xlw"
|
|
]
|
|
},
|
|
"application/vnd.ms-excel.addin.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xlam"
|
|
]
|
|
},
|
|
"application/vnd.ms-excel.sheet.binary.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xlsb"
|
|
]
|
|
},
|
|
"application/vnd.ms-excel.sheet.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xlsm"
|
|
]
|
|
},
|
|
"application/vnd.ms-excel.template.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xltm"
|
|
]
|
|
},
|
|
"application/vnd.ms-fontobject": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"eot"
|
|
]
|
|
},
|
|
"application/vnd.ms-htmlhelp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"chm"
|
|
]
|
|
},
|
|
"application/vnd.ms-ims": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ims"
|
|
]
|
|
},
|
|
"application/vnd.ms-lrm": {
|
|
source: "iana",
|
|
extensions: [
|
|
"lrm"
|
|
]
|
|
},
|
|
"application/vnd.ms-office.activex+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-officetheme": {
|
|
source: "iana",
|
|
extensions: [
|
|
"thmx"
|
|
]
|
|
},
|
|
"application/vnd.ms-opentype": {
|
|
source: "apache",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-outlook": {
|
|
compressible: false,
|
|
extensions: [
|
|
"msg"
|
|
]
|
|
},
|
|
"application/vnd.ms-package.obfuscated-opentype": {
|
|
source: "apache"
|
|
},
|
|
"application/vnd.ms-pki.seccat": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cat"
|
|
]
|
|
},
|
|
"application/vnd.ms-pki.stl": {
|
|
source: "apache",
|
|
extensions: [
|
|
"stl"
|
|
]
|
|
},
|
|
"application/vnd.ms-playready.initiator+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-powerpoint": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"ppt",
|
|
"pps",
|
|
"pot"
|
|
]
|
|
},
|
|
"application/vnd.ms-powerpoint.addin.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ppam"
|
|
]
|
|
},
|
|
"application/vnd.ms-powerpoint.presentation.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pptm"
|
|
]
|
|
},
|
|
"application/vnd.ms-powerpoint.slide.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sldm"
|
|
]
|
|
},
|
|
"application/vnd.ms-powerpoint.slideshow.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ppsm"
|
|
]
|
|
},
|
|
"application/vnd.ms-powerpoint.template.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"potm"
|
|
]
|
|
},
|
|
"application/vnd.ms-printdevicecapabilities+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-printing.printticket+xml": {
|
|
source: "apache",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-printschematicket+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-project": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mpp",
|
|
"mpt"
|
|
]
|
|
},
|
|
"application/vnd.ms-tnef": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.devicepairing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.nwprinting.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.printerpairing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.wsd.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.lic-chlg-req": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.lic-resp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.meter-chlg-req": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.meter-resp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-word.document.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"docm"
|
|
]
|
|
},
|
|
"application/vnd.ms-word.template.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dotm"
|
|
]
|
|
},
|
|
"application/vnd.ms-works": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wps",
|
|
"wks",
|
|
"wcm",
|
|
"wdb"
|
|
]
|
|
},
|
|
"application/vnd.ms-wpl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wpl"
|
|
]
|
|
},
|
|
"application/vnd.ms-xpsdocument": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"xps"
|
|
]
|
|
},
|
|
"application/vnd.msa-disk-image": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mseq": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mseq"
|
|
]
|
|
},
|
|
"application/vnd.msign": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.multiad.creator": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.multiad.creator.cif": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.music-niff": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.musician": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mus"
|
|
]
|
|
},
|
|
"application/vnd.muvee.style": {
|
|
source: "iana",
|
|
extensions: [
|
|
"msty"
|
|
]
|
|
},
|
|
"application/vnd.mynfc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"taglet"
|
|
]
|
|
},
|
|
"application/vnd.ncd.control": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ncd.reference": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nearst.inv+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nebumind.line": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nervana": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.netfpx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.neurolanguage.nlu": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nlu"
|
|
]
|
|
},
|
|
"application/vnd.nimn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nintendo.nitro.rom": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nintendo.snes.rom": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nitf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ntf",
|
|
"nitf"
|
|
]
|
|
},
|
|
"application/vnd.noblenet-directory": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nnd"
|
|
]
|
|
},
|
|
"application/vnd.noblenet-sealer": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nns"
|
|
]
|
|
},
|
|
"application/vnd.noblenet-web": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nnw"
|
|
]
|
|
},
|
|
"application/vnd.nokia.catalogs": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.conml+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.conml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.iptv.config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.isds-radio-presets": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.landmark+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.landmark+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.landmarkcollection+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.n-gage.ac+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"ac"
|
|
]
|
|
},
|
|
"application/vnd.nokia.n-gage.data": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ngdat"
|
|
]
|
|
},
|
|
"application/vnd.nokia.n-gage.symbian.install": {
|
|
source: "iana",
|
|
extensions: [
|
|
"n-gage"
|
|
]
|
|
},
|
|
"application/vnd.nokia.ncd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.pcd+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.pcd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.radio-preset": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rpst"
|
|
]
|
|
},
|
|
"application/vnd.nokia.radio-presets": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rpss"
|
|
]
|
|
},
|
|
"application/vnd.novadigm.edm": {
|
|
source: "iana",
|
|
extensions: [
|
|
"edm"
|
|
]
|
|
},
|
|
"application/vnd.novadigm.edx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"edx"
|
|
]
|
|
},
|
|
"application/vnd.novadigm.ext": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ext"
|
|
]
|
|
},
|
|
"application/vnd.ntt-local.content-share": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.file-transfer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.ogw_remote-access": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.sip-ta_remote": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.sip-ta_tcp_stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oasis.opendocument.chart": {
|
|
source: "iana",
|
|
extensions: [
|
|
"odc"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.chart-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"otc"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.database": {
|
|
source: "iana",
|
|
extensions: [
|
|
"odb"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.formula": {
|
|
source: "iana",
|
|
extensions: [
|
|
"odf"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.formula-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"odft"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.graphics": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"odg"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.graphics-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"otg"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.image": {
|
|
source: "iana",
|
|
extensions: [
|
|
"odi"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.image-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"oti"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.presentation": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"odp"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.presentation-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"otp"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.spreadsheet": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"ods"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.spreadsheet-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ots"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.text": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"odt"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-master": {
|
|
source: "iana",
|
|
extensions: [
|
|
"odm"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ott"
|
|
]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-web": {
|
|
source: "iana",
|
|
extensions: [
|
|
"oth"
|
|
]
|
|
},
|
|
"application/vnd.obn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ocf+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oci.image.manifest.v1+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oftn.l10n+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.contentaccessdownload+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.contentaccessstreaming+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.cspg-hexbinary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oipf.dae.svg+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.dae.xhtml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.mippvcontrolmessage+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.pae.gem": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oipf.spdiscovery+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.spdlist+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.ueprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.userprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.olpc-sugar": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xo"
|
|
]
|
|
},
|
|
"application/vnd.oma-scws-config": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma-scws-http-request": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma-scws-http-response": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.associated-procedure-parameter+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.drm-trigger+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.imd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.ltkm": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.notification+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.provisioningtrigger": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.sgboot": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.sgdd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.sgdu": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.simple-symbol-container": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.smartcard-trigger+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.sprov+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.stkm": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.cab-address-book+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-feature-handler+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-pcc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-subs-invite+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-user-prefs+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.dcd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.dcdc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.dd2+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"dd2"
|
|
]
|
|
},
|
|
"application/vnd.oma.drm.risd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.group-usage-list+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.lwm2m+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.lwm2m+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.lwm2m+tlv": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.pal+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.detailed-progress-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.final-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.groups+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.invocation-descriptor+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.optimized-progress-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.push": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.scidm.messages+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.xcap-directory+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omads-email+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omads-file+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omads-folder+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omaloc-supl-init": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepager": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertamp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertamx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertat": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertatp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertatx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openblox.game+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"obgx"
|
|
]
|
|
},
|
|
"application/vnd.openblox.game-binary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openeye.oeb": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openofficeorg.extension": {
|
|
source: "apache",
|
|
extensions: [
|
|
"oxt"
|
|
]
|
|
},
|
|
"application/vnd.openstreetmap.data+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"osm"
|
|
]
|
|
},
|
|
"application/vnd.opentimestamps.ots": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.custom-properties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.customxmlproperties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawing+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.chart+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.extended-properties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.comments+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presentation": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"pptx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slide": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sldx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slide+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideshow": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ppsx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.tags+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"potx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"xlsx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xltx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.theme+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.themeoverride+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.vmldrawing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"docx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.template": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dotx"
|
|
]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-package.core-properties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-package.relationships+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oracle.resource+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.orange.indata": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.osa.netdeploy": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.osgeo.mapguide.package": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mgp"
|
|
]
|
|
},
|
|
"application/vnd.osgi.bundle": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.osgi.dp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dp"
|
|
]
|
|
},
|
|
"application/vnd.osgi.subsystem": {
|
|
source: "iana",
|
|
extensions: [
|
|
"esa"
|
|
]
|
|
},
|
|
"application/vnd.otps.ct-kip+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oxli.countgraph": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pagerduty+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.palm": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pdb",
|
|
"pqa",
|
|
"oprc"
|
|
]
|
|
},
|
|
"application/vnd.panoply": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.paos.xml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.patentdive": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.patientecommsdoc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pawaafile": {
|
|
source: "iana",
|
|
extensions: [
|
|
"paw"
|
|
]
|
|
},
|
|
"application/vnd.pcos": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pg.format": {
|
|
source: "iana",
|
|
extensions: [
|
|
"str"
|
|
]
|
|
},
|
|
"application/vnd.pg.osasli": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ei6"
|
|
]
|
|
},
|
|
"application/vnd.piaccess.application-licence": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.picsel": {
|
|
source: "iana",
|
|
extensions: [
|
|
"efif"
|
|
]
|
|
},
|
|
"application/vnd.pmi.widget": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wg"
|
|
]
|
|
},
|
|
"application/vnd.poc.group-advertisement+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.pocketlearn": {
|
|
source: "iana",
|
|
extensions: [
|
|
"plf"
|
|
]
|
|
},
|
|
"application/vnd.powerbuilder6": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pbd"
|
|
]
|
|
},
|
|
"application/vnd.powerbuilder6-s": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder7": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder7-s": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder75": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder75-s": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.preminet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.previewsystems.box": {
|
|
source: "iana",
|
|
extensions: [
|
|
"box"
|
|
]
|
|
},
|
|
"application/vnd.proteus.magazine": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mgz"
|
|
]
|
|
},
|
|
"application/vnd.psfs": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.publishare-delta-tree": {
|
|
source: "iana",
|
|
extensions: [
|
|
"qps"
|
|
]
|
|
},
|
|
"application/vnd.pvi.ptid1": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ptid"
|
|
]
|
|
},
|
|
"application/vnd.pwg-multiplexed": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pwg-xhtml-print+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.qualcomm.brew-app-res": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.quarantainenet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.quark.quarkxpress": {
|
|
source: "iana",
|
|
extensions: [
|
|
"qxd",
|
|
"qxt",
|
|
"qwd",
|
|
"qwt",
|
|
"qxl",
|
|
"qxb"
|
|
]
|
|
},
|
|
"application/vnd.quobject-quoxdocument": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.radisys.moml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-conf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-conn+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-dialog+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-stream+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-conf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-base+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-fax-detect+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-fax-sendrecv+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-group+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-speech+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-transform+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.rainstor.data": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.rapid": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.rar": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rar"
|
|
]
|
|
},
|
|
"application/vnd.realvnc.bed": {
|
|
source: "iana",
|
|
extensions: [
|
|
"bed"
|
|
]
|
|
},
|
|
"application/vnd.recordare.musicxml": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mxl"
|
|
]
|
|
},
|
|
"application/vnd.recordare.musicxml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"musicxml"
|
|
]
|
|
},
|
|
"application/vnd.renlearn.rlprint": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.resilient.logic": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.restful+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.rig.cryptonote": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cryptonote"
|
|
]
|
|
},
|
|
"application/vnd.rim.cod": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cod"
|
|
]
|
|
},
|
|
"application/vnd.rn-realmedia": {
|
|
source: "apache",
|
|
extensions: [
|
|
"rm"
|
|
]
|
|
},
|
|
"application/vnd.rn-realmedia-vbr": {
|
|
source: "apache",
|
|
extensions: [
|
|
"rmvb"
|
|
]
|
|
},
|
|
"application/vnd.route66.link66+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"link66"
|
|
]
|
|
},
|
|
"application/vnd.rs-274x": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ruckus.download": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.s3sms": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sailingtracker.track": {
|
|
source: "iana",
|
|
extensions: [
|
|
"st"
|
|
]
|
|
},
|
|
"application/vnd.sar": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sbm.cid": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sbm.mid2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.scribus": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.3df": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.csf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.doc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.eml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.mht": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.net": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.ppt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.tiff": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.xls": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealedmedia.softseal.html": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealedmedia.softseal.pdf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.seemail": {
|
|
source: "iana",
|
|
extensions: [
|
|
"see"
|
|
]
|
|
},
|
|
"application/vnd.seis+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.sema": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sema"
|
|
]
|
|
},
|
|
"application/vnd.semd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"semd"
|
|
]
|
|
},
|
|
"application/vnd.semf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"semf"
|
|
]
|
|
},
|
|
"application/vnd.shade-save-file": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.shana.informed.formdata": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ifm"
|
|
]
|
|
},
|
|
"application/vnd.shana.informed.formtemplate": {
|
|
source: "iana",
|
|
extensions: [
|
|
"itp"
|
|
]
|
|
},
|
|
"application/vnd.shana.informed.interchange": {
|
|
source: "iana",
|
|
extensions: [
|
|
"iif"
|
|
]
|
|
},
|
|
"application/vnd.shana.informed.package": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ipk"
|
|
]
|
|
},
|
|
"application/vnd.shootproof+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.shopkick+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.shp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.shx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sigrok.session": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.simtech-mindmapper": {
|
|
source: "iana",
|
|
extensions: [
|
|
"twd",
|
|
"twds"
|
|
]
|
|
},
|
|
"application/vnd.siren+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.smaf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mmf"
|
|
]
|
|
},
|
|
"application/vnd.smart.notebook": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.smart.teacher": {
|
|
source: "iana",
|
|
extensions: [
|
|
"teacher"
|
|
]
|
|
},
|
|
"application/vnd.snesdev-page-table": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.software602.filler.form+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"fo"
|
|
]
|
|
},
|
|
"application/vnd.software602.filler.form-xml-zip": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.solent.sdkm+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"sdkm",
|
|
"sdkd"
|
|
]
|
|
},
|
|
"application/vnd.spotfire.dxp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dxp"
|
|
]
|
|
},
|
|
"application/vnd.spotfire.sfs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sfs"
|
|
]
|
|
},
|
|
"application/vnd.sqlite3": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sss-cod": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sss-dtf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sss-ntf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.stardivision.calc": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sdc"
|
|
]
|
|
},
|
|
"application/vnd.stardivision.draw": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sda"
|
|
]
|
|
},
|
|
"application/vnd.stardivision.impress": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sdd"
|
|
]
|
|
},
|
|
"application/vnd.stardivision.math": {
|
|
source: "apache",
|
|
extensions: [
|
|
"smf"
|
|
]
|
|
},
|
|
"application/vnd.stardivision.writer": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sdw",
|
|
"vor"
|
|
]
|
|
},
|
|
"application/vnd.stardivision.writer-global": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sgl"
|
|
]
|
|
},
|
|
"application/vnd.stepmania.package": {
|
|
source: "iana",
|
|
extensions: [
|
|
"smzip"
|
|
]
|
|
},
|
|
"application/vnd.stepmania.stepchart": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sm"
|
|
]
|
|
},
|
|
"application/vnd.street-stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sun.wadl+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"wadl"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.calc": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sxc"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.calc.template": {
|
|
source: "apache",
|
|
extensions: [
|
|
"stc"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.draw": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sxd"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.draw.template": {
|
|
source: "apache",
|
|
extensions: [
|
|
"std"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.impress": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sxi"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.impress.template": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sti"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.math": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sxm"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.writer": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sxw"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.writer.global": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sxg"
|
|
]
|
|
},
|
|
"application/vnd.sun.xml.writer.template": {
|
|
source: "apache",
|
|
extensions: [
|
|
"stw"
|
|
]
|
|
},
|
|
"application/vnd.sus-calendar": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sus",
|
|
"susp"
|
|
]
|
|
},
|
|
"application/vnd.svd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"svd"
|
|
]
|
|
},
|
|
"application/vnd.swiftview-ics": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sycle+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.symbian.install": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sis",
|
|
"sisx"
|
|
]
|
|
},
|
|
"application/vnd.syncml+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"xsm"
|
|
]
|
|
},
|
|
"application/vnd.syncml.dm+wbxml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: [
|
|
"bdm"
|
|
]
|
|
},
|
|
"application/vnd.syncml.dm+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"xdm"
|
|
]
|
|
},
|
|
"application/vnd.syncml.dm.notification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.syncml.dmddf+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.syncml.dmddf+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"ddf"
|
|
]
|
|
},
|
|
"application/vnd.syncml.dmtnds+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.syncml.dmtnds+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.syncml.ds.notification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.tableschema+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.tao.intent-module-archive": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tao"
|
|
]
|
|
},
|
|
"application/vnd.tcpdump.pcap": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pcap",
|
|
"cap",
|
|
"dmp"
|
|
]
|
|
},
|
|
"application/vnd.think-cell.ppttc+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.tmd.mediaflex.api+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.tml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.tmobile-livetv": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tmo"
|
|
]
|
|
},
|
|
"application/vnd.tri.onesource": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.trid.tpt": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tpt"
|
|
]
|
|
},
|
|
"application/vnd.triscape.mxs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mxs"
|
|
]
|
|
},
|
|
"application/vnd.trueapp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tra"
|
|
]
|
|
},
|
|
"application/vnd.truedoc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ubisoft.webplayer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ufdl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ufd",
|
|
"ufdl"
|
|
]
|
|
},
|
|
"application/vnd.uiq.theme": {
|
|
source: "iana",
|
|
extensions: [
|
|
"utz"
|
|
]
|
|
},
|
|
"application/vnd.umajin": {
|
|
source: "iana",
|
|
extensions: [
|
|
"umj"
|
|
]
|
|
},
|
|
"application/vnd.unity": {
|
|
source: "iana",
|
|
extensions: [
|
|
"unityweb"
|
|
]
|
|
},
|
|
"application/vnd.uoml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"uoml"
|
|
]
|
|
},
|
|
"application/vnd.uplanet.alert": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.alert-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.bearer-choice": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.bearer-choice-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.cacheop": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.cacheop-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.channel": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.channel-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.list": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.list-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.listcmd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.listcmd-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.signal": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uri-map": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.valve.source.material": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vcx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vcx"
|
|
]
|
|
},
|
|
"application/vnd.vd-study": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vectorworks": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vel+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.verimatrix.vcas": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.veritone.aion+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.veryant.thin": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ves.encrypted": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vidsoft.vidconference": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.visio": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vsd",
|
|
"vst",
|
|
"vss",
|
|
"vsw"
|
|
]
|
|
},
|
|
"application/vnd.visionary": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vis"
|
|
]
|
|
},
|
|
"application/vnd.vividence.scriptfile": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vsf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vsf"
|
|
]
|
|
},
|
|
"application/vnd.wap.sic": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wap.slc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wap.wbxml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: [
|
|
"wbxml"
|
|
]
|
|
},
|
|
"application/vnd.wap.wmlc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wmlc"
|
|
]
|
|
},
|
|
"application/vnd.wap.wmlscriptc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wmlsc"
|
|
]
|
|
},
|
|
"application/vnd.webturbo": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wtb"
|
|
]
|
|
},
|
|
"application/vnd.wfa.dpp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wfa.p2p": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wfa.wsc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.windows.devicepairing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wmc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wmf.bootstrap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wolfram.mathematica": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wolfram.mathematica.package": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wolfram.player": {
|
|
source: "iana",
|
|
extensions: [
|
|
"nbp"
|
|
]
|
|
},
|
|
"application/vnd.wordperfect": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wpd"
|
|
]
|
|
},
|
|
"application/vnd.wqd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wqd"
|
|
]
|
|
},
|
|
"application/vnd.wrq-hp3000-labelled": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wt.stf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"stf"
|
|
]
|
|
},
|
|
"application/vnd.wv.csp+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wv.csp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.wv.ssp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.xacml+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.xara": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xar"
|
|
]
|
|
},
|
|
"application/vnd.xfdl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xfdl"
|
|
]
|
|
},
|
|
"application/vnd.xfdl.webform": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmi+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.xmpie.cpkg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.dpkg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.plan": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.ppkg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.xlim": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yamaha.hv-dic": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hvd"
|
|
]
|
|
},
|
|
"application/vnd.yamaha.hv-script": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hvs"
|
|
]
|
|
},
|
|
"application/vnd.yamaha.hv-voice": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hvp"
|
|
]
|
|
},
|
|
"application/vnd.yamaha.openscoreformat": {
|
|
source: "iana",
|
|
extensions: [
|
|
"osf"
|
|
]
|
|
},
|
|
"application/vnd.yamaha.openscoreformat.osfpvg+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"osfpvg"
|
|
]
|
|
},
|
|
"application/vnd.yamaha.remote-setup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yamaha.smaf-audio": {
|
|
source: "iana",
|
|
extensions: [
|
|
"saf"
|
|
]
|
|
},
|
|
"application/vnd.yamaha.smaf-phrase": {
|
|
source: "iana",
|
|
extensions: [
|
|
"spf"
|
|
]
|
|
},
|
|
"application/vnd.yamaha.through-ngn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yamaha.tunnel-udpencap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yaoweme": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yellowriver-custom-menu": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cmp"
|
|
]
|
|
},
|
|
"application/vnd.youtube.yt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.zul": {
|
|
source: "iana",
|
|
extensions: [
|
|
"zir",
|
|
"zirz"
|
|
]
|
|
},
|
|
"application/vnd.zzazz.deck+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"zaz"
|
|
]
|
|
},
|
|
"application/voicexml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"vxml"
|
|
]
|
|
},
|
|
"application/voucher-cms+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vq-rtcpxr": {
|
|
source: "iana"
|
|
},
|
|
"application/wasm": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"wasm"
|
|
]
|
|
},
|
|
"application/watcherinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/webpush-options+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/whoispp-query": {
|
|
source: "iana"
|
|
},
|
|
"application/whoispp-response": {
|
|
source: "iana"
|
|
},
|
|
"application/widget": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wgt"
|
|
]
|
|
},
|
|
"application/winhlp": {
|
|
source: "apache",
|
|
extensions: [
|
|
"hlp"
|
|
]
|
|
},
|
|
"application/wita": {
|
|
source: "iana"
|
|
},
|
|
"application/wordperfect5.1": {
|
|
source: "iana"
|
|
},
|
|
"application/wsdl+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"wsdl"
|
|
]
|
|
},
|
|
"application/wspolicy+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"wspolicy"
|
|
]
|
|
},
|
|
"application/x-7z-compressed": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"7z"
|
|
]
|
|
},
|
|
"application/x-abiword": {
|
|
source: "apache",
|
|
extensions: [
|
|
"abw"
|
|
]
|
|
},
|
|
"application/x-ace-compressed": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ace"
|
|
]
|
|
},
|
|
"application/x-amf": {
|
|
source: "apache"
|
|
},
|
|
"application/x-apple-diskimage": {
|
|
source: "apache",
|
|
extensions: [
|
|
"dmg"
|
|
]
|
|
},
|
|
"application/x-arj": {
|
|
compressible: false,
|
|
extensions: [
|
|
"arj"
|
|
]
|
|
},
|
|
"application/x-authorware-bin": {
|
|
source: "apache",
|
|
extensions: [
|
|
"aab",
|
|
"x32",
|
|
"u32",
|
|
"vox"
|
|
]
|
|
},
|
|
"application/x-authorware-map": {
|
|
source: "apache",
|
|
extensions: [
|
|
"aam"
|
|
]
|
|
},
|
|
"application/x-authorware-seg": {
|
|
source: "apache",
|
|
extensions: [
|
|
"aas"
|
|
]
|
|
},
|
|
"application/x-bcpio": {
|
|
source: "apache",
|
|
extensions: [
|
|
"bcpio"
|
|
]
|
|
},
|
|
"application/x-bdoc": {
|
|
compressible: false,
|
|
extensions: [
|
|
"bdoc"
|
|
]
|
|
},
|
|
"application/x-bittorrent": {
|
|
source: "apache",
|
|
extensions: [
|
|
"torrent"
|
|
]
|
|
},
|
|
"application/x-blorb": {
|
|
source: "apache",
|
|
extensions: [
|
|
"blb",
|
|
"blorb"
|
|
]
|
|
},
|
|
"application/x-bzip": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"bz"
|
|
]
|
|
},
|
|
"application/x-bzip2": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"bz2",
|
|
"boz"
|
|
]
|
|
},
|
|
"application/x-cbr": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cbr",
|
|
"cba",
|
|
"cbt",
|
|
"cbz",
|
|
"cb7"
|
|
]
|
|
},
|
|
"application/x-cdlink": {
|
|
source: "apache",
|
|
extensions: [
|
|
"vcd"
|
|
]
|
|
},
|
|
"application/x-cfs-compressed": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cfs"
|
|
]
|
|
},
|
|
"application/x-chat": {
|
|
source: "apache",
|
|
extensions: [
|
|
"chat"
|
|
]
|
|
},
|
|
"application/x-chess-pgn": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pgn"
|
|
]
|
|
},
|
|
"application/x-chrome-extension": {
|
|
extensions: [
|
|
"crx"
|
|
]
|
|
},
|
|
"application/x-cocoa": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"cco"
|
|
]
|
|
},
|
|
"application/x-compress": {
|
|
source: "apache"
|
|
},
|
|
"application/x-conference": {
|
|
source: "apache",
|
|
extensions: [
|
|
"nsc"
|
|
]
|
|
},
|
|
"application/x-cpio": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cpio"
|
|
]
|
|
},
|
|
"application/x-csh": {
|
|
source: "apache",
|
|
extensions: [
|
|
"csh"
|
|
]
|
|
},
|
|
"application/x-deb": {
|
|
compressible: false
|
|
},
|
|
"application/x-debian-package": {
|
|
source: "apache",
|
|
extensions: [
|
|
"deb",
|
|
"udeb"
|
|
]
|
|
},
|
|
"application/x-dgc-compressed": {
|
|
source: "apache",
|
|
extensions: [
|
|
"dgc"
|
|
]
|
|
},
|
|
"application/x-director": {
|
|
source: "apache",
|
|
extensions: [
|
|
"dir",
|
|
"dcr",
|
|
"dxr",
|
|
"cst",
|
|
"cct",
|
|
"cxt",
|
|
"w3d",
|
|
"fgd",
|
|
"swa"
|
|
]
|
|
},
|
|
"application/x-doom": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wad"
|
|
]
|
|
},
|
|
"application/x-dtbncx+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"ncx"
|
|
]
|
|
},
|
|
"application/x-dtbook+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"dtb"
|
|
]
|
|
},
|
|
"application/x-dtbresource+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"res"
|
|
]
|
|
},
|
|
"application/x-dvi": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"dvi"
|
|
]
|
|
},
|
|
"application/x-envoy": {
|
|
source: "apache",
|
|
extensions: [
|
|
"evy"
|
|
]
|
|
},
|
|
"application/x-eva": {
|
|
source: "apache",
|
|
extensions: [
|
|
"eva"
|
|
]
|
|
},
|
|
"application/x-font-bdf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"bdf"
|
|
]
|
|
},
|
|
"application/x-font-dos": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-framemaker": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-ghostscript": {
|
|
source: "apache",
|
|
extensions: [
|
|
"gsf"
|
|
]
|
|
},
|
|
"application/x-font-libgrx": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-linux-psf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"psf"
|
|
]
|
|
},
|
|
"application/x-font-pcf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pcf"
|
|
]
|
|
},
|
|
"application/x-font-snf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"snf"
|
|
]
|
|
},
|
|
"application/x-font-speedo": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-sunos-news": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-type1": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pfa",
|
|
"pfb",
|
|
"pfm",
|
|
"afm"
|
|
]
|
|
},
|
|
"application/x-font-vfont": {
|
|
source: "apache"
|
|
},
|
|
"application/x-freearc": {
|
|
source: "apache",
|
|
extensions: [
|
|
"arc"
|
|
]
|
|
},
|
|
"application/x-futuresplash": {
|
|
source: "apache",
|
|
extensions: [
|
|
"spl"
|
|
]
|
|
},
|
|
"application/x-gca-compressed": {
|
|
source: "apache",
|
|
extensions: [
|
|
"gca"
|
|
]
|
|
},
|
|
"application/x-glulx": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ulx"
|
|
]
|
|
},
|
|
"application/x-gnumeric": {
|
|
source: "apache",
|
|
extensions: [
|
|
"gnumeric"
|
|
]
|
|
},
|
|
"application/x-gramps-xml": {
|
|
source: "apache",
|
|
extensions: [
|
|
"gramps"
|
|
]
|
|
},
|
|
"application/x-gtar": {
|
|
source: "apache",
|
|
extensions: [
|
|
"gtar"
|
|
]
|
|
},
|
|
"application/x-gzip": {
|
|
source: "apache"
|
|
},
|
|
"application/x-hdf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"hdf"
|
|
]
|
|
},
|
|
"application/x-httpd-php": {
|
|
compressible: true,
|
|
extensions: [
|
|
"php"
|
|
]
|
|
},
|
|
"application/x-install-instructions": {
|
|
source: "apache",
|
|
extensions: [
|
|
"install"
|
|
]
|
|
},
|
|
"application/x-iso9660-image": {
|
|
source: "apache",
|
|
extensions: [
|
|
"iso"
|
|
]
|
|
},
|
|
"application/x-java-archive-diff": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"jardiff"
|
|
]
|
|
},
|
|
"application/x-java-jnlp-file": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"jnlp"
|
|
]
|
|
},
|
|
"application/x-javascript": {
|
|
compressible: true
|
|
},
|
|
"application/x-keepass2": {
|
|
extensions: [
|
|
"kdbx"
|
|
]
|
|
},
|
|
"application/x-latex": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"latex"
|
|
]
|
|
},
|
|
"application/x-lua-bytecode": {
|
|
extensions: [
|
|
"luac"
|
|
]
|
|
},
|
|
"application/x-lzh-compressed": {
|
|
source: "apache",
|
|
extensions: [
|
|
"lzh",
|
|
"lha"
|
|
]
|
|
},
|
|
"application/x-makeself": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"run"
|
|
]
|
|
},
|
|
"application/x-mie": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mie"
|
|
]
|
|
},
|
|
"application/x-mobipocket-ebook": {
|
|
source: "apache",
|
|
extensions: [
|
|
"prc",
|
|
"mobi"
|
|
]
|
|
},
|
|
"application/x-mpegurl": {
|
|
compressible: false
|
|
},
|
|
"application/x-ms-application": {
|
|
source: "apache",
|
|
extensions: [
|
|
"application"
|
|
]
|
|
},
|
|
"application/x-ms-shortcut": {
|
|
source: "apache",
|
|
extensions: [
|
|
"lnk"
|
|
]
|
|
},
|
|
"application/x-ms-wmd": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wmd"
|
|
]
|
|
},
|
|
"application/x-ms-wmz": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wmz"
|
|
]
|
|
},
|
|
"application/x-ms-xbap": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xbap"
|
|
]
|
|
},
|
|
"application/x-msaccess": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mdb"
|
|
]
|
|
},
|
|
"application/x-msbinder": {
|
|
source: "apache",
|
|
extensions: [
|
|
"obd"
|
|
]
|
|
},
|
|
"application/x-mscardfile": {
|
|
source: "apache",
|
|
extensions: [
|
|
"crd"
|
|
]
|
|
},
|
|
"application/x-msclip": {
|
|
source: "apache",
|
|
extensions: [
|
|
"clp"
|
|
]
|
|
},
|
|
"application/x-msdos-program": {
|
|
extensions: [
|
|
"exe"
|
|
]
|
|
},
|
|
"application/x-msdownload": {
|
|
source: "apache",
|
|
extensions: [
|
|
"exe",
|
|
"dll",
|
|
"com",
|
|
"bat",
|
|
"msi"
|
|
]
|
|
},
|
|
"application/x-msmediaview": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mvb",
|
|
"m13",
|
|
"m14"
|
|
]
|
|
},
|
|
"application/x-msmetafile": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wmf",
|
|
"wmz",
|
|
"emf",
|
|
"emz"
|
|
]
|
|
},
|
|
"application/x-msmoney": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mny"
|
|
]
|
|
},
|
|
"application/x-mspublisher": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pub"
|
|
]
|
|
},
|
|
"application/x-msschedule": {
|
|
source: "apache",
|
|
extensions: [
|
|
"scd"
|
|
]
|
|
},
|
|
"application/x-msterminal": {
|
|
source: "apache",
|
|
extensions: [
|
|
"trm"
|
|
]
|
|
},
|
|
"application/x-mswrite": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wri"
|
|
]
|
|
},
|
|
"application/x-netcdf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"nc",
|
|
"cdf"
|
|
]
|
|
},
|
|
"application/x-ns-proxy-autoconfig": {
|
|
compressible: true,
|
|
extensions: [
|
|
"pac"
|
|
]
|
|
},
|
|
"application/x-nzb": {
|
|
source: "apache",
|
|
extensions: [
|
|
"nzb"
|
|
]
|
|
},
|
|
"application/x-perl": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"pl",
|
|
"pm"
|
|
]
|
|
},
|
|
"application/x-pilot": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"prc",
|
|
"pdb"
|
|
]
|
|
},
|
|
"application/x-pkcs12": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"p12",
|
|
"pfx"
|
|
]
|
|
},
|
|
"application/x-pkcs7-certificates": {
|
|
source: "apache",
|
|
extensions: [
|
|
"p7b",
|
|
"spc"
|
|
]
|
|
},
|
|
"application/x-pkcs7-certreqresp": {
|
|
source: "apache",
|
|
extensions: [
|
|
"p7r"
|
|
]
|
|
},
|
|
"application/x-pki-message": {
|
|
source: "iana"
|
|
},
|
|
"application/x-rar-compressed": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"rar"
|
|
]
|
|
},
|
|
"application/x-redhat-package-manager": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"rpm"
|
|
]
|
|
},
|
|
"application/x-research-info-systems": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ris"
|
|
]
|
|
},
|
|
"application/x-sea": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"sea"
|
|
]
|
|
},
|
|
"application/x-sh": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"sh"
|
|
]
|
|
},
|
|
"application/x-shar": {
|
|
source: "apache",
|
|
extensions: [
|
|
"shar"
|
|
]
|
|
},
|
|
"application/x-shockwave-flash": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"swf"
|
|
]
|
|
},
|
|
"application/x-silverlight-app": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xap"
|
|
]
|
|
},
|
|
"application/x-sql": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sql"
|
|
]
|
|
},
|
|
"application/x-stuffit": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"sit"
|
|
]
|
|
},
|
|
"application/x-stuffitx": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sitx"
|
|
]
|
|
},
|
|
"application/x-subrip": {
|
|
source: "apache",
|
|
extensions: [
|
|
"srt"
|
|
]
|
|
},
|
|
"application/x-sv4cpio": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sv4cpio"
|
|
]
|
|
},
|
|
"application/x-sv4crc": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sv4crc"
|
|
]
|
|
},
|
|
"application/x-t3vm-image": {
|
|
source: "apache",
|
|
extensions: [
|
|
"t3"
|
|
]
|
|
},
|
|
"application/x-tads": {
|
|
source: "apache",
|
|
extensions: [
|
|
"gam"
|
|
]
|
|
},
|
|
"application/x-tar": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"tar"
|
|
]
|
|
},
|
|
"application/x-tcl": {
|
|
source: "apache",
|
|
extensions: [
|
|
"tcl",
|
|
"tk"
|
|
]
|
|
},
|
|
"application/x-tex": {
|
|
source: "apache",
|
|
extensions: [
|
|
"tex"
|
|
]
|
|
},
|
|
"application/x-tex-tfm": {
|
|
source: "apache",
|
|
extensions: [
|
|
"tfm"
|
|
]
|
|
},
|
|
"application/x-texinfo": {
|
|
source: "apache",
|
|
extensions: [
|
|
"texinfo",
|
|
"texi"
|
|
]
|
|
},
|
|
"application/x-tgif": {
|
|
source: "apache",
|
|
extensions: [
|
|
"obj"
|
|
]
|
|
},
|
|
"application/x-ustar": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ustar"
|
|
]
|
|
},
|
|
"application/x-virtualbox-hdd": {
|
|
compressible: true,
|
|
extensions: [
|
|
"hdd"
|
|
]
|
|
},
|
|
"application/x-virtualbox-ova": {
|
|
compressible: true,
|
|
extensions: [
|
|
"ova"
|
|
]
|
|
},
|
|
"application/x-virtualbox-ovf": {
|
|
compressible: true,
|
|
extensions: [
|
|
"ovf"
|
|
]
|
|
},
|
|
"application/x-virtualbox-vbox": {
|
|
compressible: true,
|
|
extensions: [
|
|
"vbox"
|
|
]
|
|
},
|
|
"application/x-virtualbox-vbox-extpack": {
|
|
compressible: false,
|
|
extensions: [
|
|
"vbox-extpack"
|
|
]
|
|
},
|
|
"application/x-virtualbox-vdi": {
|
|
compressible: true,
|
|
extensions: [
|
|
"vdi"
|
|
]
|
|
},
|
|
"application/x-virtualbox-vhd": {
|
|
compressible: true,
|
|
extensions: [
|
|
"vhd"
|
|
]
|
|
},
|
|
"application/x-virtualbox-vmdk": {
|
|
compressible: true,
|
|
extensions: [
|
|
"vmdk"
|
|
]
|
|
},
|
|
"application/x-wais-source": {
|
|
source: "apache",
|
|
extensions: [
|
|
"src"
|
|
]
|
|
},
|
|
"application/x-web-app-manifest+json": {
|
|
compressible: true,
|
|
extensions: [
|
|
"webapp"
|
|
]
|
|
},
|
|
"application/x-www-form-urlencoded": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/x-x509-ca-cert": {
|
|
source: "iana",
|
|
extensions: [
|
|
"der",
|
|
"crt",
|
|
"pem"
|
|
]
|
|
},
|
|
"application/x-x509-ca-ra-cert": {
|
|
source: "iana"
|
|
},
|
|
"application/x-x509-next-ca-cert": {
|
|
source: "iana"
|
|
},
|
|
"application/x-xfig": {
|
|
source: "apache",
|
|
extensions: [
|
|
"fig"
|
|
]
|
|
},
|
|
"application/x-xliff+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"xlf"
|
|
]
|
|
},
|
|
"application/x-xpinstall": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"xpi"
|
|
]
|
|
},
|
|
"application/x-xz": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xz"
|
|
]
|
|
},
|
|
"application/x-zmachine": {
|
|
source: "apache",
|
|
extensions: [
|
|
"z1",
|
|
"z2",
|
|
"z3",
|
|
"z4",
|
|
"z5",
|
|
"z6",
|
|
"z7",
|
|
"z8"
|
|
]
|
|
},
|
|
"application/x400-bp": {
|
|
source: "iana"
|
|
},
|
|
"application/xacml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xaml+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"xaml"
|
|
]
|
|
},
|
|
"application/xcap-att+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xav"
|
|
]
|
|
},
|
|
"application/xcap-caps+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xca"
|
|
]
|
|
},
|
|
"application/xcap-diff+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xdf"
|
|
]
|
|
},
|
|
"application/xcap-el+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xel"
|
|
]
|
|
},
|
|
"application/xcap-error+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xcap-ns+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xns"
|
|
]
|
|
},
|
|
"application/xcon-conference-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xcon-conference-info-diff+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xenc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xenc"
|
|
]
|
|
},
|
|
"application/xhtml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xhtml",
|
|
"xht"
|
|
]
|
|
},
|
|
"application/xhtml-voice+xml": {
|
|
source: "apache",
|
|
compressible: true
|
|
},
|
|
"application/xliff+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xlf"
|
|
]
|
|
},
|
|
"application/xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xml",
|
|
"xsl",
|
|
"xsd",
|
|
"rng"
|
|
]
|
|
},
|
|
"application/xml-dtd": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"dtd"
|
|
]
|
|
},
|
|
"application/xml-external-parsed-entity": {
|
|
source: "iana"
|
|
},
|
|
"application/xml-patch+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xmpp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xop+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xop"
|
|
]
|
|
},
|
|
"application/xproc+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"xpl"
|
|
]
|
|
},
|
|
"application/xslt+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xsl",
|
|
"xslt"
|
|
]
|
|
},
|
|
"application/xspf+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"xspf"
|
|
]
|
|
},
|
|
"application/xv+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"mxml",
|
|
"xhvml",
|
|
"xvml",
|
|
"xvm"
|
|
]
|
|
},
|
|
"application/yang": {
|
|
source: "iana",
|
|
extensions: [
|
|
"yang"
|
|
]
|
|
},
|
|
"application/yang-data+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yang-data+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yang-patch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yang-patch+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yin+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"yin"
|
|
]
|
|
},
|
|
"application/zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"zip"
|
|
]
|
|
},
|
|
"application/zlib": {
|
|
source: "iana"
|
|
},
|
|
"application/zstd": {
|
|
source: "iana"
|
|
},
|
|
"audio/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/32kadpcm": {
|
|
source: "iana"
|
|
},
|
|
"audio/3gpp": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"3gpp"
|
|
]
|
|
},
|
|
"audio/3gpp2": {
|
|
source: "iana"
|
|
},
|
|
"audio/aac": {
|
|
source: "iana"
|
|
},
|
|
"audio/ac3": {
|
|
source: "iana"
|
|
},
|
|
"audio/adpcm": {
|
|
source: "apache",
|
|
extensions: [
|
|
"adp"
|
|
]
|
|
},
|
|
"audio/amr": {
|
|
source: "iana",
|
|
extensions: [
|
|
"amr"
|
|
]
|
|
},
|
|
"audio/amr-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/amr-wb+": {
|
|
source: "iana"
|
|
},
|
|
"audio/aptx": {
|
|
source: "iana"
|
|
},
|
|
"audio/asc": {
|
|
source: "iana"
|
|
},
|
|
"audio/atrac-advanced-lossless": {
|
|
source: "iana"
|
|
},
|
|
"audio/atrac-x": {
|
|
source: "iana"
|
|
},
|
|
"audio/atrac3": {
|
|
source: "iana"
|
|
},
|
|
"audio/basic": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"au",
|
|
"snd"
|
|
]
|
|
},
|
|
"audio/bv16": {
|
|
source: "iana"
|
|
},
|
|
"audio/bv32": {
|
|
source: "iana"
|
|
},
|
|
"audio/clearmode": {
|
|
source: "iana"
|
|
},
|
|
"audio/cn": {
|
|
source: "iana"
|
|
},
|
|
"audio/dat12": {
|
|
source: "iana"
|
|
},
|
|
"audio/dls": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es201108": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es202050": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es202211": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es202212": {
|
|
source: "iana"
|
|
},
|
|
"audio/dv": {
|
|
source: "iana"
|
|
},
|
|
"audio/dvi4": {
|
|
source: "iana"
|
|
},
|
|
"audio/eac3": {
|
|
source: "iana"
|
|
},
|
|
"audio/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc-qcp": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcb": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcb0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcb1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcnw": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcnw0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcnw1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcwb": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcwb0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcwb1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evs": {
|
|
source: "iana"
|
|
},
|
|
"audio/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/fwdred": {
|
|
source: "iana"
|
|
},
|
|
"audio/g711-0": {
|
|
source: "iana"
|
|
},
|
|
"audio/g719": {
|
|
source: "iana"
|
|
},
|
|
"audio/g722": {
|
|
source: "iana"
|
|
},
|
|
"audio/g7221": {
|
|
source: "iana"
|
|
},
|
|
"audio/g723": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-16": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-24": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-32": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-40": {
|
|
source: "iana"
|
|
},
|
|
"audio/g728": {
|
|
source: "iana"
|
|
},
|
|
"audio/g729": {
|
|
source: "iana"
|
|
},
|
|
"audio/g7291": {
|
|
source: "iana"
|
|
},
|
|
"audio/g729d": {
|
|
source: "iana"
|
|
},
|
|
"audio/g729e": {
|
|
source: "iana"
|
|
},
|
|
"audio/gsm": {
|
|
source: "iana"
|
|
},
|
|
"audio/gsm-efr": {
|
|
source: "iana"
|
|
},
|
|
"audio/gsm-hr-08": {
|
|
source: "iana"
|
|
},
|
|
"audio/ilbc": {
|
|
source: "iana"
|
|
},
|
|
"audio/ip-mr_v2.5": {
|
|
source: "iana"
|
|
},
|
|
"audio/isac": {
|
|
source: "apache"
|
|
},
|
|
"audio/l16": {
|
|
source: "iana"
|
|
},
|
|
"audio/l20": {
|
|
source: "iana"
|
|
},
|
|
"audio/l24": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"audio/l8": {
|
|
source: "iana"
|
|
},
|
|
"audio/lpc": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp1200": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp2400": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp600": {
|
|
source: "iana"
|
|
},
|
|
"audio/mhas": {
|
|
source: "iana"
|
|
},
|
|
"audio/midi": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mid",
|
|
"midi",
|
|
"kar",
|
|
"rmi"
|
|
]
|
|
},
|
|
"audio/mobile-xmf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mxmf"
|
|
]
|
|
},
|
|
"audio/mp3": {
|
|
compressible: false,
|
|
extensions: [
|
|
"mp3"
|
|
]
|
|
},
|
|
"audio/mp4": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"m4a",
|
|
"mp4a"
|
|
]
|
|
},
|
|
"audio/mp4a-latm": {
|
|
source: "iana"
|
|
},
|
|
"audio/mpa": {
|
|
source: "iana"
|
|
},
|
|
"audio/mpa-robust": {
|
|
source: "iana"
|
|
},
|
|
"audio/mpeg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"mpga",
|
|
"mp2",
|
|
"mp2a",
|
|
"mp3",
|
|
"m2a",
|
|
"m3a"
|
|
]
|
|
},
|
|
"audio/mpeg4-generic": {
|
|
source: "iana"
|
|
},
|
|
"audio/musepack": {
|
|
source: "apache"
|
|
},
|
|
"audio/ogg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"oga",
|
|
"ogg",
|
|
"spx",
|
|
"opus"
|
|
]
|
|
},
|
|
"audio/opus": {
|
|
source: "iana"
|
|
},
|
|
"audio/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcma": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcma-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcmu": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcmu-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/prs.sid": {
|
|
source: "iana"
|
|
},
|
|
"audio/qcelp": {
|
|
source: "iana"
|
|
},
|
|
"audio/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/red": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtp-enc-aescm128": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtp-midi": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtx": {
|
|
source: "iana"
|
|
},
|
|
"audio/s3m": {
|
|
source: "apache",
|
|
extensions: [
|
|
"s3m"
|
|
]
|
|
},
|
|
"audio/scip": {
|
|
source: "iana"
|
|
},
|
|
"audio/silk": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sil"
|
|
]
|
|
},
|
|
"audio/smv": {
|
|
source: "iana"
|
|
},
|
|
"audio/smv-qcp": {
|
|
source: "iana"
|
|
},
|
|
"audio/smv0": {
|
|
source: "iana"
|
|
},
|
|
"audio/sofa": {
|
|
source: "iana"
|
|
},
|
|
"audio/sp-midi": {
|
|
source: "iana"
|
|
},
|
|
"audio/speex": {
|
|
source: "iana"
|
|
},
|
|
"audio/t140c": {
|
|
source: "iana"
|
|
},
|
|
"audio/t38": {
|
|
source: "iana"
|
|
},
|
|
"audio/telephone-event": {
|
|
source: "iana"
|
|
},
|
|
"audio/tetra_acelp": {
|
|
source: "iana"
|
|
},
|
|
"audio/tetra_acelp_bb": {
|
|
source: "iana"
|
|
},
|
|
"audio/tone": {
|
|
source: "iana"
|
|
},
|
|
"audio/tsvcis": {
|
|
source: "iana"
|
|
},
|
|
"audio/uemclip": {
|
|
source: "iana"
|
|
},
|
|
"audio/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/usac": {
|
|
source: "iana"
|
|
},
|
|
"audio/vdvi": {
|
|
source: "iana"
|
|
},
|
|
"audio/vmr-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.3gpp.iufp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.4sb": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.audiokoz": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.celp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cisco.nse": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cmles.radio-events": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cns.anp1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cns.inf1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dece.audio": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uva",
|
|
"uvva"
|
|
]
|
|
},
|
|
"audio/vnd.digital-winds": {
|
|
source: "iana",
|
|
extensions: [
|
|
"eol"
|
|
]
|
|
},
|
|
"audio/vnd.dlna.adts": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.heaac.1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.heaac.2": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.mlp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.mps": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2x": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2z": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pulse.1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dra": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dra"
|
|
]
|
|
},
|
|
"audio/vnd.dts": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dts"
|
|
]
|
|
},
|
|
"audio/vnd.dts.hd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dtshd"
|
|
]
|
|
},
|
|
"audio/vnd.dts.uhd": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dvb.file": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.everad.plj": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.hns.audio": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.lucent.voice": {
|
|
source: "iana",
|
|
extensions: [
|
|
"lvp"
|
|
]
|
|
},
|
|
"audio/vnd.ms-playready.media.pya": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pya"
|
|
]
|
|
},
|
|
"audio/vnd.nokia.mobile-xmf": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.nortel.vbk": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.nuera.ecelp4800": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ecelp4800"
|
|
]
|
|
},
|
|
"audio/vnd.nuera.ecelp7470": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ecelp7470"
|
|
]
|
|
},
|
|
"audio/vnd.nuera.ecelp9600": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ecelp9600"
|
|
]
|
|
},
|
|
"audio/vnd.octel.sbc": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.presonus.multitrack": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.qcelp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.rhetorex.32kadpcm": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.rip": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rip"
|
|
]
|
|
},
|
|
"audio/vnd.rn-realaudio": {
|
|
compressible: false
|
|
},
|
|
"audio/vnd.sealedmedia.softseal.mpeg": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.vmx.cvsd": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.wave": {
|
|
compressible: false
|
|
},
|
|
"audio/vorbis": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"audio/vorbis-config": {
|
|
source: "iana"
|
|
},
|
|
"audio/wav": {
|
|
compressible: false,
|
|
extensions: [
|
|
"wav"
|
|
]
|
|
},
|
|
"audio/wave": {
|
|
compressible: false,
|
|
extensions: [
|
|
"wav"
|
|
]
|
|
},
|
|
"audio/webm": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"weba"
|
|
]
|
|
},
|
|
"audio/x-aac": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"aac"
|
|
]
|
|
},
|
|
"audio/x-aiff": {
|
|
source: "apache",
|
|
extensions: [
|
|
"aif",
|
|
"aiff",
|
|
"aifc"
|
|
]
|
|
},
|
|
"audio/x-caf": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"caf"
|
|
]
|
|
},
|
|
"audio/x-flac": {
|
|
source: "apache",
|
|
extensions: [
|
|
"flac"
|
|
]
|
|
},
|
|
"audio/x-m4a": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"m4a"
|
|
]
|
|
},
|
|
"audio/x-matroska": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mka"
|
|
]
|
|
},
|
|
"audio/x-mpegurl": {
|
|
source: "apache",
|
|
extensions: [
|
|
"m3u"
|
|
]
|
|
},
|
|
"audio/x-ms-wax": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wax"
|
|
]
|
|
},
|
|
"audio/x-ms-wma": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wma"
|
|
]
|
|
},
|
|
"audio/x-pn-realaudio": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ram",
|
|
"ra"
|
|
]
|
|
},
|
|
"audio/x-pn-realaudio-plugin": {
|
|
source: "apache",
|
|
extensions: [
|
|
"rmp"
|
|
]
|
|
},
|
|
"audio/x-realaudio": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"ra"
|
|
]
|
|
},
|
|
"audio/x-tta": {
|
|
source: "apache"
|
|
},
|
|
"audio/x-wav": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wav"
|
|
]
|
|
},
|
|
"audio/xm": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xm"
|
|
]
|
|
},
|
|
"chemical/x-cdx": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cdx"
|
|
]
|
|
},
|
|
"chemical/x-cif": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cif"
|
|
]
|
|
},
|
|
"chemical/x-cmdf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cmdf"
|
|
]
|
|
},
|
|
"chemical/x-cml": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cml"
|
|
]
|
|
},
|
|
"chemical/x-csml": {
|
|
source: "apache",
|
|
extensions: [
|
|
"csml"
|
|
]
|
|
},
|
|
"chemical/x-pdb": {
|
|
source: "apache"
|
|
},
|
|
"chemical/x-xyz": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xyz"
|
|
]
|
|
},
|
|
"font/collection": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ttc"
|
|
]
|
|
},
|
|
"font/otf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"otf"
|
|
]
|
|
},
|
|
"font/sfnt": {
|
|
source: "iana"
|
|
},
|
|
"font/ttf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"ttf"
|
|
]
|
|
},
|
|
"font/woff": {
|
|
source: "iana",
|
|
extensions: [
|
|
"woff"
|
|
]
|
|
},
|
|
"font/woff2": {
|
|
source: "iana",
|
|
extensions: [
|
|
"woff2"
|
|
]
|
|
},
|
|
"image/aces": {
|
|
source: "iana",
|
|
extensions: [
|
|
"exr"
|
|
]
|
|
},
|
|
"image/apng": {
|
|
compressible: false,
|
|
extensions: [
|
|
"apng"
|
|
]
|
|
},
|
|
"image/avci": {
|
|
source: "iana"
|
|
},
|
|
"image/avcs": {
|
|
source: "iana"
|
|
},
|
|
"image/avif": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"avif"
|
|
]
|
|
},
|
|
"image/bmp": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"bmp"
|
|
]
|
|
},
|
|
"image/cgm": {
|
|
source: "iana",
|
|
extensions: [
|
|
"cgm"
|
|
]
|
|
},
|
|
"image/dicom-rle": {
|
|
source: "iana",
|
|
extensions: [
|
|
"drle"
|
|
]
|
|
},
|
|
"image/emf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"emf"
|
|
]
|
|
},
|
|
"image/fits": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fits"
|
|
]
|
|
},
|
|
"image/g3fax": {
|
|
source: "iana",
|
|
extensions: [
|
|
"g3"
|
|
]
|
|
},
|
|
"image/gif": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"gif"
|
|
]
|
|
},
|
|
"image/heic": {
|
|
source: "iana",
|
|
extensions: [
|
|
"heic"
|
|
]
|
|
},
|
|
"image/heic-sequence": {
|
|
source: "iana",
|
|
extensions: [
|
|
"heics"
|
|
]
|
|
},
|
|
"image/heif": {
|
|
source: "iana",
|
|
extensions: [
|
|
"heif"
|
|
]
|
|
},
|
|
"image/heif-sequence": {
|
|
source: "iana",
|
|
extensions: [
|
|
"heifs"
|
|
]
|
|
},
|
|
"image/hej2k": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hej2"
|
|
]
|
|
},
|
|
"image/hsj2": {
|
|
source: "iana",
|
|
extensions: [
|
|
"hsj2"
|
|
]
|
|
},
|
|
"image/ief": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ief"
|
|
]
|
|
},
|
|
"image/jls": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jls"
|
|
]
|
|
},
|
|
"image/jp2": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"jp2",
|
|
"jpg2"
|
|
]
|
|
},
|
|
"image/jpeg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"jpeg",
|
|
"jpg",
|
|
"jpe"
|
|
]
|
|
},
|
|
"image/jph": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jph"
|
|
]
|
|
},
|
|
"image/jphc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jhc"
|
|
]
|
|
},
|
|
"image/jpm": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"jpm"
|
|
]
|
|
},
|
|
"image/jpx": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"jpx",
|
|
"jpf"
|
|
]
|
|
},
|
|
"image/jxr": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jxr"
|
|
]
|
|
},
|
|
"image/jxra": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jxra"
|
|
]
|
|
},
|
|
"image/jxrs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jxrs"
|
|
]
|
|
},
|
|
"image/jxs": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jxs"
|
|
]
|
|
},
|
|
"image/jxsc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jxsc"
|
|
]
|
|
},
|
|
"image/jxsi": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jxsi"
|
|
]
|
|
},
|
|
"image/jxss": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jxss"
|
|
]
|
|
},
|
|
"image/ktx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ktx"
|
|
]
|
|
},
|
|
"image/ktx2": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ktx2"
|
|
]
|
|
},
|
|
"image/naplps": {
|
|
source: "iana"
|
|
},
|
|
"image/pjpeg": {
|
|
compressible: false
|
|
},
|
|
"image/png": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"png"
|
|
]
|
|
},
|
|
"image/prs.btif": {
|
|
source: "iana",
|
|
extensions: [
|
|
"btif"
|
|
]
|
|
},
|
|
"image/prs.pti": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pti"
|
|
]
|
|
},
|
|
"image/pwg-raster": {
|
|
source: "iana"
|
|
},
|
|
"image/sgi": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sgi"
|
|
]
|
|
},
|
|
"image/svg+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"svg",
|
|
"svgz"
|
|
]
|
|
},
|
|
"image/t38": {
|
|
source: "iana",
|
|
extensions: [
|
|
"t38"
|
|
]
|
|
},
|
|
"image/tiff": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"tif",
|
|
"tiff"
|
|
]
|
|
},
|
|
"image/tiff-fx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tfx"
|
|
]
|
|
},
|
|
"image/vnd.adobe.photoshop": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"psd"
|
|
]
|
|
},
|
|
"image/vnd.airzip.accelerator.azv": {
|
|
source: "iana",
|
|
extensions: [
|
|
"azv"
|
|
]
|
|
},
|
|
"image/vnd.cns.inf2": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.dece.graphic": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvi",
|
|
"uvvi",
|
|
"uvg",
|
|
"uvvg"
|
|
]
|
|
},
|
|
"image/vnd.djvu": {
|
|
source: "iana",
|
|
extensions: [
|
|
"djvu",
|
|
"djv"
|
|
]
|
|
},
|
|
"image/vnd.dvb.subtitle": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sub"
|
|
]
|
|
},
|
|
"image/vnd.dwg": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dwg"
|
|
]
|
|
},
|
|
"image/vnd.dxf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dxf"
|
|
]
|
|
},
|
|
"image/vnd.fastbidsheet": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fbs"
|
|
]
|
|
},
|
|
"image/vnd.fpx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fpx"
|
|
]
|
|
},
|
|
"image/vnd.fst": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fst"
|
|
]
|
|
},
|
|
"image/vnd.fujixerox.edmics-mmr": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mmr"
|
|
]
|
|
},
|
|
"image/vnd.fujixerox.edmics-rlc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"rlc"
|
|
]
|
|
},
|
|
"image/vnd.globalgraphics.pgb": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.microsoft.icon": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ico"
|
|
]
|
|
},
|
|
"image/vnd.mix": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.mozilla.apng": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.ms-dds": {
|
|
extensions: [
|
|
"dds"
|
|
]
|
|
},
|
|
"image/vnd.ms-modi": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mdi"
|
|
]
|
|
},
|
|
"image/vnd.ms-photo": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wdp"
|
|
]
|
|
},
|
|
"image/vnd.net-fpx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"npx"
|
|
]
|
|
},
|
|
"image/vnd.pco.b16": {
|
|
source: "iana",
|
|
extensions: [
|
|
"b16"
|
|
]
|
|
},
|
|
"image/vnd.radiance": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.sealed.png": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.sealedmedia.softseal.gif": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.sealedmedia.softseal.jpg": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.svf": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.tencent.tap": {
|
|
source: "iana",
|
|
extensions: [
|
|
"tap"
|
|
]
|
|
},
|
|
"image/vnd.valve.source.texture": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vtf"
|
|
]
|
|
},
|
|
"image/vnd.wap.wbmp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wbmp"
|
|
]
|
|
},
|
|
"image/vnd.xiff": {
|
|
source: "iana",
|
|
extensions: [
|
|
"xif"
|
|
]
|
|
},
|
|
"image/vnd.zbrush.pcx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pcx"
|
|
]
|
|
},
|
|
"image/webp": {
|
|
source: "apache",
|
|
extensions: [
|
|
"webp"
|
|
]
|
|
},
|
|
"image/wmf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wmf"
|
|
]
|
|
},
|
|
"image/x-3ds": {
|
|
source: "apache",
|
|
extensions: [
|
|
"3ds"
|
|
]
|
|
},
|
|
"image/x-cmu-raster": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ras"
|
|
]
|
|
},
|
|
"image/x-cmx": {
|
|
source: "apache",
|
|
extensions: [
|
|
"cmx"
|
|
]
|
|
},
|
|
"image/x-freehand": {
|
|
source: "apache",
|
|
extensions: [
|
|
"fh",
|
|
"fhc",
|
|
"fh4",
|
|
"fh5",
|
|
"fh7"
|
|
]
|
|
},
|
|
"image/x-icon": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: [
|
|
"ico"
|
|
]
|
|
},
|
|
"image/x-jng": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"jng"
|
|
]
|
|
},
|
|
"image/x-mrsid-image": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sid"
|
|
]
|
|
},
|
|
"image/x-ms-bmp": {
|
|
source: "nginx",
|
|
compressible: true,
|
|
extensions: [
|
|
"bmp"
|
|
]
|
|
},
|
|
"image/x-pcx": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pcx"
|
|
]
|
|
},
|
|
"image/x-pict": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pic",
|
|
"pct"
|
|
]
|
|
},
|
|
"image/x-portable-anymap": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pnm"
|
|
]
|
|
},
|
|
"image/x-portable-bitmap": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pbm"
|
|
]
|
|
},
|
|
"image/x-portable-graymap": {
|
|
source: "apache",
|
|
extensions: [
|
|
"pgm"
|
|
]
|
|
},
|
|
"image/x-portable-pixmap": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ppm"
|
|
]
|
|
},
|
|
"image/x-rgb": {
|
|
source: "apache",
|
|
extensions: [
|
|
"rgb"
|
|
]
|
|
},
|
|
"image/x-tga": {
|
|
source: "apache",
|
|
extensions: [
|
|
"tga"
|
|
]
|
|
},
|
|
"image/x-xbitmap": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xbm"
|
|
]
|
|
},
|
|
"image/x-xcf": {
|
|
compressible: false
|
|
},
|
|
"image/x-xpixmap": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xpm"
|
|
]
|
|
},
|
|
"image/x-xwindowdump": {
|
|
source: "apache",
|
|
extensions: [
|
|
"xwd"
|
|
]
|
|
},
|
|
"message/cpim": {
|
|
source: "iana"
|
|
},
|
|
"message/delivery-status": {
|
|
source: "iana"
|
|
},
|
|
"message/disposition-notification": {
|
|
source: "iana",
|
|
extensions: [
|
|
"disposition-notification"
|
|
]
|
|
},
|
|
"message/external-body": {
|
|
source: "iana"
|
|
},
|
|
"message/feedback-report": {
|
|
source: "iana"
|
|
},
|
|
"message/global": {
|
|
source: "iana",
|
|
extensions: [
|
|
"u8msg"
|
|
]
|
|
},
|
|
"message/global-delivery-status": {
|
|
source: "iana",
|
|
extensions: [
|
|
"u8dsn"
|
|
]
|
|
},
|
|
"message/global-disposition-notification": {
|
|
source: "iana",
|
|
extensions: [
|
|
"u8mdn"
|
|
]
|
|
},
|
|
"message/global-headers": {
|
|
source: "iana",
|
|
extensions: [
|
|
"u8hdr"
|
|
]
|
|
},
|
|
"message/http": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"message/imdn+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"message/news": {
|
|
source: "iana"
|
|
},
|
|
"message/partial": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"message/rfc822": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"eml",
|
|
"mime"
|
|
]
|
|
},
|
|
"message/s-http": {
|
|
source: "iana"
|
|
},
|
|
"message/sip": {
|
|
source: "iana"
|
|
},
|
|
"message/sipfrag": {
|
|
source: "iana"
|
|
},
|
|
"message/tracking-status": {
|
|
source: "iana"
|
|
},
|
|
"message/vnd.si.simp": {
|
|
source: "iana"
|
|
},
|
|
"message/vnd.wfa.wsc": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wsc"
|
|
]
|
|
},
|
|
"model/3mf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"3mf"
|
|
]
|
|
},
|
|
"model/e57": {
|
|
source: "iana"
|
|
},
|
|
"model/gltf+json": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"gltf"
|
|
]
|
|
},
|
|
"model/gltf-binary": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"glb"
|
|
]
|
|
},
|
|
"model/iges": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"igs",
|
|
"iges"
|
|
]
|
|
},
|
|
"model/mesh": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"msh",
|
|
"mesh",
|
|
"silo"
|
|
]
|
|
},
|
|
"model/mtl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mtl"
|
|
]
|
|
},
|
|
"model/obj": {
|
|
source: "iana",
|
|
extensions: [
|
|
"obj"
|
|
]
|
|
},
|
|
"model/step+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"stpz"
|
|
]
|
|
},
|
|
"model/step-xml+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"stpxz"
|
|
]
|
|
},
|
|
"model/stl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"stl"
|
|
]
|
|
},
|
|
"model/vnd.collada+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"dae"
|
|
]
|
|
},
|
|
"model/vnd.dwf": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dwf"
|
|
]
|
|
},
|
|
"model/vnd.flatland.3dml": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.gdl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gdl"
|
|
]
|
|
},
|
|
"model/vnd.gs-gdl": {
|
|
source: "apache"
|
|
},
|
|
"model/vnd.gs.gdl": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.gtw": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gtw"
|
|
]
|
|
},
|
|
"model/vnd.moml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"model/vnd.mts": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mts"
|
|
]
|
|
},
|
|
"model/vnd.opengex": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ogex"
|
|
]
|
|
},
|
|
"model/vnd.parasolid.transmit.binary": {
|
|
source: "iana",
|
|
extensions: [
|
|
"x_b"
|
|
]
|
|
},
|
|
"model/vnd.parasolid.transmit.text": {
|
|
source: "iana",
|
|
extensions: [
|
|
"x_t"
|
|
]
|
|
},
|
|
"model/vnd.pytha.pyox": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.rosette.annotated-data-model": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.sap.vds": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vds"
|
|
]
|
|
},
|
|
"model/vnd.usdz+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"usdz"
|
|
]
|
|
},
|
|
"model/vnd.valve.source.compiled-map": {
|
|
source: "iana",
|
|
extensions: [
|
|
"bsp"
|
|
]
|
|
},
|
|
"model/vnd.vtu": {
|
|
source: "iana",
|
|
extensions: [
|
|
"vtu"
|
|
]
|
|
},
|
|
"model/vrml": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"wrl",
|
|
"vrml"
|
|
]
|
|
},
|
|
"model/x3d+binary": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"x3db",
|
|
"x3dbz"
|
|
]
|
|
},
|
|
"model/x3d+fastinfoset": {
|
|
source: "iana",
|
|
extensions: [
|
|
"x3db"
|
|
]
|
|
},
|
|
"model/x3d+vrml": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"x3dv",
|
|
"x3dvz"
|
|
]
|
|
},
|
|
"model/x3d+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"x3d",
|
|
"x3dz"
|
|
]
|
|
},
|
|
"model/x3d-vrml": {
|
|
source: "iana",
|
|
extensions: [
|
|
"x3dv"
|
|
]
|
|
},
|
|
"multipart/alternative": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/appledouble": {
|
|
source: "iana"
|
|
},
|
|
"multipart/byteranges": {
|
|
source: "iana"
|
|
},
|
|
"multipart/digest": {
|
|
source: "iana"
|
|
},
|
|
"multipart/encrypted": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/form-data": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/header-set": {
|
|
source: "iana"
|
|
},
|
|
"multipart/mixed": {
|
|
source: "iana"
|
|
},
|
|
"multipart/multilingual": {
|
|
source: "iana"
|
|
},
|
|
"multipart/parallel": {
|
|
source: "iana"
|
|
},
|
|
"multipart/related": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/report": {
|
|
source: "iana"
|
|
},
|
|
"multipart/signed": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/vnd.bint.med-plus": {
|
|
source: "iana"
|
|
},
|
|
"multipart/voice-message": {
|
|
source: "iana"
|
|
},
|
|
"multipart/x-mixed-replace": {
|
|
source: "iana"
|
|
},
|
|
"text/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"text/cache-manifest": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"appcache",
|
|
"manifest"
|
|
]
|
|
},
|
|
"text/calendar": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ics",
|
|
"ifb"
|
|
]
|
|
},
|
|
"text/calender": {
|
|
compressible: true
|
|
},
|
|
"text/cmd": {
|
|
compressible: true
|
|
},
|
|
"text/coffeescript": {
|
|
extensions: [
|
|
"coffee",
|
|
"litcoffee"
|
|
]
|
|
},
|
|
"text/cql": {
|
|
source: "iana"
|
|
},
|
|
"text/cql-expression": {
|
|
source: "iana"
|
|
},
|
|
"text/cql-identifier": {
|
|
source: "iana"
|
|
},
|
|
"text/css": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"css"
|
|
]
|
|
},
|
|
"text/csv": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"csv"
|
|
]
|
|
},
|
|
"text/csv-schema": {
|
|
source: "iana"
|
|
},
|
|
"text/directory": {
|
|
source: "iana"
|
|
},
|
|
"text/dns": {
|
|
source: "iana"
|
|
},
|
|
"text/ecmascript": {
|
|
source: "iana"
|
|
},
|
|
"text/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"text/enriched": {
|
|
source: "iana"
|
|
},
|
|
"text/fhirpath": {
|
|
source: "iana"
|
|
},
|
|
"text/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"text/fwdred": {
|
|
source: "iana"
|
|
},
|
|
"text/gff3": {
|
|
source: "iana"
|
|
},
|
|
"text/grammar-ref-list": {
|
|
source: "iana"
|
|
},
|
|
"text/html": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"html",
|
|
"htm",
|
|
"shtml"
|
|
]
|
|
},
|
|
"text/jade": {
|
|
extensions: [
|
|
"jade"
|
|
]
|
|
},
|
|
"text/javascript": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"text/jcr-cnd": {
|
|
source: "iana"
|
|
},
|
|
"text/jsx": {
|
|
compressible: true,
|
|
extensions: [
|
|
"jsx"
|
|
]
|
|
},
|
|
"text/less": {
|
|
compressible: true,
|
|
extensions: [
|
|
"less"
|
|
]
|
|
},
|
|
"text/markdown": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"markdown",
|
|
"md"
|
|
]
|
|
},
|
|
"text/mathml": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"mml"
|
|
]
|
|
},
|
|
"text/mdx": {
|
|
compressible: true,
|
|
extensions: [
|
|
"mdx"
|
|
]
|
|
},
|
|
"text/mizar": {
|
|
source: "iana"
|
|
},
|
|
"text/n3": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"n3"
|
|
]
|
|
},
|
|
"text/parameters": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"text/plain": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"txt",
|
|
"text",
|
|
"conf",
|
|
"def",
|
|
"list",
|
|
"log",
|
|
"in",
|
|
"ini"
|
|
]
|
|
},
|
|
"text/provenance-notation": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/prs.fallenstein.rst": {
|
|
source: "iana"
|
|
},
|
|
"text/prs.lines.tag": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dsc"
|
|
]
|
|
},
|
|
"text/prs.prop.logic": {
|
|
source: "iana"
|
|
},
|
|
"text/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"text/red": {
|
|
source: "iana"
|
|
},
|
|
"text/rfc822-headers": {
|
|
source: "iana"
|
|
},
|
|
"text/richtext": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rtx"
|
|
]
|
|
},
|
|
"text/rtf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"rtf"
|
|
]
|
|
},
|
|
"text/rtp-enc-aescm128": {
|
|
source: "iana"
|
|
},
|
|
"text/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"text/rtx": {
|
|
source: "iana"
|
|
},
|
|
"text/sgml": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sgml",
|
|
"sgm"
|
|
]
|
|
},
|
|
"text/shaclc": {
|
|
source: "iana"
|
|
},
|
|
"text/shex": {
|
|
source: "iana",
|
|
extensions: [
|
|
"shex"
|
|
]
|
|
},
|
|
"text/slim": {
|
|
extensions: [
|
|
"slim",
|
|
"slm"
|
|
]
|
|
},
|
|
"text/spdx": {
|
|
source: "iana",
|
|
extensions: [
|
|
"spdx"
|
|
]
|
|
},
|
|
"text/strings": {
|
|
source: "iana"
|
|
},
|
|
"text/stylus": {
|
|
extensions: [
|
|
"stylus",
|
|
"styl"
|
|
]
|
|
},
|
|
"text/t140": {
|
|
source: "iana"
|
|
},
|
|
"text/tab-separated-values": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"tsv"
|
|
]
|
|
},
|
|
"text/troff": {
|
|
source: "iana",
|
|
extensions: [
|
|
"t",
|
|
"tr",
|
|
"roff",
|
|
"man",
|
|
"me",
|
|
"ms"
|
|
]
|
|
},
|
|
"text/turtle": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: [
|
|
"ttl"
|
|
]
|
|
},
|
|
"text/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"text/uri-list": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"uri",
|
|
"uris",
|
|
"urls"
|
|
]
|
|
},
|
|
"text/vcard": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"vcard"
|
|
]
|
|
},
|
|
"text/vnd.a": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.abc": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.ascii-art": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.curl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"curl"
|
|
]
|
|
},
|
|
"text/vnd.curl.dcurl": {
|
|
source: "apache",
|
|
extensions: [
|
|
"dcurl"
|
|
]
|
|
},
|
|
"text/vnd.curl.mcurl": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mcurl"
|
|
]
|
|
},
|
|
"text/vnd.curl.scurl": {
|
|
source: "apache",
|
|
extensions: [
|
|
"scurl"
|
|
]
|
|
},
|
|
"text/vnd.debian.copyright": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/vnd.dmclientscript": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.dvb.subtitle": {
|
|
source: "iana",
|
|
extensions: [
|
|
"sub"
|
|
]
|
|
},
|
|
"text/vnd.esmertec.theme-descriptor": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/vnd.ficlab.flt": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.fly": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fly"
|
|
]
|
|
},
|
|
"text/vnd.fmi.flexstor": {
|
|
source: "iana",
|
|
extensions: [
|
|
"flx"
|
|
]
|
|
},
|
|
"text/vnd.gml": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.graphviz": {
|
|
source: "iana",
|
|
extensions: [
|
|
"gv"
|
|
]
|
|
},
|
|
"text/vnd.hans": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.hgl": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.in3d.3dml": {
|
|
source: "iana",
|
|
extensions: [
|
|
"3dml"
|
|
]
|
|
},
|
|
"text/vnd.in3d.spot": {
|
|
source: "iana",
|
|
extensions: [
|
|
"spot"
|
|
]
|
|
},
|
|
"text/vnd.iptc.newsml": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.iptc.nitf": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.latex-z": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.motorola.reflex": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.ms-mediapackage": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.net2phone.commcenter.command": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.radisys.msml-basic-layout": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.senx.warpscript": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.si.uricatalogue": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.sosi": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.sun.j2me.app-descriptor": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: [
|
|
"jad"
|
|
]
|
|
},
|
|
"text/vnd.trolltech.linguist": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/vnd.wap.si": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.wap.sl": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.wap.wml": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wml"
|
|
]
|
|
},
|
|
"text/vnd.wap.wmlscript": {
|
|
source: "iana",
|
|
extensions: [
|
|
"wmls"
|
|
]
|
|
},
|
|
"text/vtt": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: [
|
|
"vtt"
|
|
]
|
|
},
|
|
"text/x-asm": {
|
|
source: "apache",
|
|
extensions: [
|
|
"s",
|
|
"asm"
|
|
]
|
|
},
|
|
"text/x-c": {
|
|
source: "apache",
|
|
extensions: [
|
|
"c",
|
|
"cc",
|
|
"cxx",
|
|
"cpp",
|
|
"h",
|
|
"hh",
|
|
"dic"
|
|
]
|
|
},
|
|
"text/x-component": {
|
|
source: "nginx",
|
|
extensions: [
|
|
"htc"
|
|
]
|
|
},
|
|
"text/x-fortran": {
|
|
source: "apache",
|
|
extensions: [
|
|
"f",
|
|
"for",
|
|
"f77",
|
|
"f90"
|
|
]
|
|
},
|
|
"text/x-gwt-rpc": {
|
|
compressible: true
|
|
},
|
|
"text/x-handlebars-template": {
|
|
extensions: [
|
|
"hbs"
|
|
]
|
|
},
|
|
"text/x-java-source": {
|
|
source: "apache",
|
|
extensions: [
|
|
"java"
|
|
]
|
|
},
|
|
"text/x-jquery-tmpl": {
|
|
compressible: true
|
|
},
|
|
"text/x-lua": {
|
|
extensions: [
|
|
"lua"
|
|
]
|
|
},
|
|
"text/x-markdown": {
|
|
compressible: true,
|
|
extensions: [
|
|
"mkd"
|
|
]
|
|
},
|
|
"text/x-nfo": {
|
|
source: "apache",
|
|
extensions: [
|
|
"nfo"
|
|
]
|
|
},
|
|
"text/x-opml": {
|
|
source: "apache",
|
|
extensions: [
|
|
"opml"
|
|
]
|
|
},
|
|
"text/x-org": {
|
|
compressible: true,
|
|
extensions: [
|
|
"org"
|
|
]
|
|
},
|
|
"text/x-pascal": {
|
|
source: "apache",
|
|
extensions: [
|
|
"p",
|
|
"pas"
|
|
]
|
|
},
|
|
"text/x-processing": {
|
|
compressible: true,
|
|
extensions: [
|
|
"pde"
|
|
]
|
|
},
|
|
"text/x-sass": {
|
|
extensions: [
|
|
"sass"
|
|
]
|
|
},
|
|
"text/x-scss": {
|
|
extensions: [
|
|
"scss"
|
|
]
|
|
},
|
|
"text/x-setext": {
|
|
source: "apache",
|
|
extensions: [
|
|
"etx"
|
|
]
|
|
},
|
|
"text/x-sfv": {
|
|
source: "apache",
|
|
extensions: [
|
|
"sfv"
|
|
]
|
|
},
|
|
"text/x-suse-ymp": {
|
|
compressible: true,
|
|
extensions: [
|
|
"ymp"
|
|
]
|
|
},
|
|
"text/x-uuencode": {
|
|
source: "apache",
|
|
extensions: [
|
|
"uu"
|
|
]
|
|
},
|
|
"text/x-vcalendar": {
|
|
source: "apache",
|
|
extensions: [
|
|
"vcs"
|
|
]
|
|
},
|
|
"text/x-vcard": {
|
|
source: "apache",
|
|
extensions: [
|
|
"vcf"
|
|
]
|
|
},
|
|
"text/xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: [
|
|
"xml"
|
|
]
|
|
},
|
|
"text/xml-external-parsed-entity": {
|
|
source: "iana"
|
|
},
|
|
"text/yaml": {
|
|
compressible: true,
|
|
extensions: [
|
|
"yaml",
|
|
"yml"
|
|
]
|
|
},
|
|
"video/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"video/3gpp": {
|
|
source: "iana",
|
|
extensions: [
|
|
"3gp",
|
|
"3gpp"
|
|
]
|
|
},
|
|
"video/3gpp-tt": {
|
|
source: "iana"
|
|
},
|
|
"video/3gpp2": {
|
|
source: "iana",
|
|
extensions: [
|
|
"3g2"
|
|
]
|
|
},
|
|
"video/av1": {
|
|
source: "iana"
|
|
},
|
|
"video/bmpeg": {
|
|
source: "iana"
|
|
},
|
|
"video/bt656": {
|
|
source: "iana"
|
|
},
|
|
"video/celb": {
|
|
source: "iana"
|
|
},
|
|
"video/dv": {
|
|
source: "iana"
|
|
},
|
|
"video/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"video/ffv1": {
|
|
source: "iana"
|
|
},
|
|
"video/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"video/h261": {
|
|
source: "iana",
|
|
extensions: [
|
|
"h261"
|
|
]
|
|
},
|
|
"video/h263": {
|
|
source: "iana",
|
|
extensions: [
|
|
"h263"
|
|
]
|
|
},
|
|
"video/h263-1998": {
|
|
source: "iana"
|
|
},
|
|
"video/h263-2000": {
|
|
source: "iana"
|
|
},
|
|
"video/h264": {
|
|
source: "iana",
|
|
extensions: [
|
|
"h264"
|
|
]
|
|
},
|
|
"video/h264-rcdo": {
|
|
source: "iana"
|
|
},
|
|
"video/h264-svc": {
|
|
source: "iana"
|
|
},
|
|
"video/h265": {
|
|
source: "iana"
|
|
},
|
|
"video/iso.segment": {
|
|
source: "iana",
|
|
extensions: [
|
|
"m4s"
|
|
]
|
|
},
|
|
"video/jpeg": {
|
|
source: "iana",
|
|
extensions: [
|
|
"jpgv"
|
|
]
|
|
},
|
|
"video/jpeg2000": {
|
|
source: "iana"
|
|
},
|
|
"video/jpm": {
|
|
source: "apache",
|
|
extensions: [
|
|
"jpm",
|
|
"jpgm"
|
|
]
|
|
},
|
|
"video/mj2": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mj2",
|
|
"mjp2"
|
|
]
|
|
},
|
|
"video/mp1s": {
|
|
source: "iana"
|
|
},
|
|
"video/mp2p": {
|
|
source: "iana"
|
|
},
|
|
"video/mp2t": {
|
|
source: "iana",
|
|
extensions: [
|
|
"ts"
|
|
]
|
|
},
|
|
"video/mp4": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"mp4",
|
|
"mp4v",
|
|
"mpg4"
|
|
]
|
|
},
|
|
"video/mp4v-es": {
|
|
source: "iana"
|
|
},
|
|
"video/mpeg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"mpeg",
|
|
"mpg",
|
|
"mpe",
|
|
"m1v",
|
|
"m2v"
|
|
]
|
|
},
|
|
"video/mpeg4-generic": {
|
|
source: "iana"
|
|
},
|
|
"video/mpv": {
|
|
source: "iana"
|
|
},
|
|
"video/nv": {
|
|
source: "iana"
|
|
},
|
|
"video/ogg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"ogv"
|
|
]
|
|
},
|
|
"video/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"video/pointer": {
|
|
source: "iana"
|
|
},
|
|
"video/quicktime": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: [
|
|
"qt",
|
|
"mov"
|
|
]
|
|
},
|
|
"video/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"video/raw": {
|
|
source: "iana"
|
|
},
|
|
"video/rtp-enc-aescm128": {
|
|
source: "iana"
|
|
},
|
|
"video/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"video/rtx": {
|
|
source: "iana"
|
|
},
|
|
"video/scip": {
|
|
source: "iana"
|
|
},
|
|
"video/smpte291": {
|
|
source: "iana"
|
|
},
|
|
"video/smpte292m": {
|
|
source: "iana"
|
|
},
|
|
"video/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"video/vc1": {
|
|
source: "iana"
|
|
},
|
|
"video/vc2": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.cctv": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dece.hd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvh",
|
|
"uvvh"
|
|
]
|
|
},
|
|
"video/vnd.dece.mobile": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvm",
|
|
"uvvm"
|
|
]
|
|
},
|
|
"video/vnd.dece.mp4": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dece.pd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvp",
|
|
"uvvp"
|
|
]
|
|
},
|
|
"video/vnd.dece.sd": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvs",
|
|
"uvvs"
|
|
]
|
|
},
|
|
"video/vnd.dece.video": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvv",
|
|
"uvvv"
|
|
]
|
|
},
|
|
"video/vnd.directv.mpeg": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.directv.mpeg-tts": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dlna.mpeg-tts": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dvb.file": {
|
|
source: "iana",
|
|
extensions: [
|
|
"dvb"
|
|
]
|
|
},
|
|
"video/vnd.fvt": {
|
|
source: "iana",
|
|
extensions: [
|
|
"fvt"
|
|
]
|
|
},
|
|
"video/vnd.hns.video": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.1dparityfec-1010": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.1dparityfec-2005": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.2dparityfec-1010": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.2dparityfec-2005": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.ttsavc": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.ttsmpeg2": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.motorola.video": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.motorola.videop": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.mpegurl": {
|
|
source: "iana",
|
|
extensions: [
|
|
"mxu",
|
|
"m4u"
|
|
]
|
|
},
|
|
"video/vnd.ms-playready.media.pyv": {
|
|
source: "iana",
|
|
extensions: [
|
|
"pyv"
|
|
]
|
|
},
|
|
"video/vnd.nokia.interleaved-multimedia": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.nokia.mp4vr": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.nokia.videovoip": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.objectvideo": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.radgamettools.bink": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.radgamettools.smacker": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealed.mpeg1": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealed.mpeg4": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealed.swf": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealedmedia.softseal.mov": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.uvvu.mp4": {
|
|
source: "iana",
|
|
extensions: [
|
|
"uvu",
|
|
"uvvu"
|
|
]
|
|
},
|
|
"video/vnd.vivo": {
|
|
source: "iana",
|
|
extensions: [
|
|
"viv"
|
|
]
|
|
},
|
|
"video/vnd.youtube.yt": {
|
|
source: "iana"
|
|
},
|
|
"video/vp8": {
|
|
source: "iana"
|
|
},
|
|
"video/vp9": {
|
|
source: "iana"
|
|
},
|
|
"video/webm": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"webm"
|
|
]
|
|
},
|
|
"video/x-f4v": {
|
|
source: "apache",
|
|
extensions: [
|
|
"f4v"
|
|
]
|
|
},
|
|
"video/x-fli": {
|
|
source: "apache",
|
|
extensions: [
|
|
"fli"
|
|
]
|
|
},
|
|
"video/x-flv": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"flv"
|
|
]
|
|
},
|
|
"video/x-m4v": {
|
|
source: "apache",
|
|
extensions: [
|
|
"m4v"
|
|
]
|
|
},
|
|
"video/x-matroska": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"mkv",
|
|
"mk3d",
|
|
"mks"
|
|
]
|
|
},
|
|
"video/x-mng": {
|
|
source: "apache",
|
|
extensions: [
|
|
"mng"
|
|
]
|
|
},
|
|
"video/x-ms-asf": {
|
|
source: "apache",
|
|
extensions: [
|
|
"asf",
|
|
"asx"
|
|
]
|
|
},
|
|
"video/x-ms-vob": {
|
|
source: "apache",
|
|
extensions: [
|
|
"vob"
|
|
]
|
|
},
|
|
"video/x-ms-wm": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wm"
|
|
]
|
|
},
|
|
"video/x-ms-wmv": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: [
|
|
"wmv"
|
|
]
|
|
},
|
|
"video/x-ms-wmx": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wmx"
|
|
]
|
|
},
|
|
"video/x-ms-wvx": {
|
|
source: "apache",
|
|
extensions: [
|
|
"wvx"
|
|
]
|
|
},
|
|
"video/x-msvideo": {
|
|
source: "apache",
|
|
extensions: [
|
|
"avi"
|
|
]
|
|
},
|
|
"video/x-sgi-movie": {
|
|
source: "apache",
|
|
extensions: [
|
|
"movie"
|
|
]
|
|
},
|
|
"video/x-smv": {
|
|
source: "apache",
|
|
extensions: [
|
|
"smv"
|
|
]
|
|
},
|
|
"x-conference/x-cooltalk": {
|
|
source: "apache",
|
|
extensions: [
|
|
"ice"
|
|
]
|
|
},
|
|
"x-shader/x-fragment": {
|
|
compressible: true
|
|
},
|
|
"x-shader/x-vertex": {
|
|
compressible: true
|
|
}
|
|
};
|
|
|
|
/*!
|
|
* mime-db
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
*/
|
|
|
|
var mimeDb = require$$0;
|
|
|
|
/*!
|
|
* mime-types
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* Copyright(c) 2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
(function (exports) {
|
|
|
|
/**
|
|
* Module dependencies.
|
|
* @private
|
|
*/
|
|
|
|
var db = mimeDb;
|
|
var extname = path__default.extname;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
|
|
var TEXT_TYPE_REGEXP = /^text\//i;
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
exports.charset = charset;
|
|
exports.charsets = { lookup: charset };
|
|
exports.contentType = contentType;
|
|
exports.extension = extension;
|
|
exports.extensions = Object.create(null);
|
|
exports.lookup = lookup;
|
|
exports.types = Object.create(null);
|
|
|
|
// Populate the extensions/types maps
|
|
populateMaps(exports.extensions, exports.types);
|
|
|
|
/**
|
|
* Get the default charset for a MIME type.
|
|
*
|
|
* @param {string} type
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function charset (type) {
|
|
if (!type || typeof type !== 'string') {
|
|
return false
|
|
}
|
|
|
|
// TODO: use media-typer
|
|
var match = EXTRACT_TYPE_REGEXP.exec(type);
|
|
var 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.
|
|
*
|
|
* @param {string} str
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function contentType (str) {
|
|
// TODO: should this even be in this module?
|
|
if (!str || typeof str !== 'string') {
|
|
return false
|
|
}
|
|
|
|
var mime = str.indexOf('/') === -1
|
|
? exports.lookup(str)
|
|
: str;
|
|
|
|
if (!mime) {
|
|
return false
|
|
}
|
|
|
|
// TODO: use content-type or other module
|
|
if (mime.indexOf('charset') === -1) {
|
|
var charset = exports.charset(mime);
|
|
if (charset) mime += '; charset=' + charset.toLowerCase();
|
|
}
|
|
|
|
return mime
|
|
}
|
|
|
|
/**
|
|
* Get the default extension for a MIME type.
|
|
*
|
|
* @param {string} type
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function extension (type) {
|
|
if (!type || typeof type !== 'string') {
|
|
return false
|
|
}
|
|
|
|
// TODO: use media-typer
|
|
var match = EXTRACT_TYPE_REGEXP.exec(type);
|
|
|
|
// get extensions
|
|
var 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.
|
|
*
|
|
* @param {string} path
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function lookup (path) {
|
|
if (!path || typeof path !== 'string') {
|
|
return false
|
|
}
|
|
|
|
// get the extension ("ext" or ".ext" or full path)
|
|
var extension = extname('x.' + path)
|
|
.toLowerCase()
|
|
.substr(1);
|
|
|
|
if (!extension) {
|
|
return false
|
|
}
|
|
|
|
return exports.types[extension] || false
|
|
}
|
|
|
|
/**
|
|
* Populate the extensions and types maps.
|
|
* @private
|
|
*/
|
|
|
|
function populateMaps (extensions, types) {
|
|
// source preference (least -> most)
|
|
var preference = ['nginx', 'apache', undefined, 'iana'];
|
|
|
|
Object.keys(db).forEach(function forEachMimeType (type) {
|
|
var mime = db[type];
|
|
var exts = mime.extensions;
|
|
|
|
if (!exts || !exts.length) {
|
|
return
|
|
}
|
|
|
|
// mime -> extensions
|
|
extensions[type] = exts;
|
|
|
|
// extension -> mime
|
|
for (var i = 0; i < exts.length; i++) {
|
|
var extension = exts[i];
|
|
|
|
if (types[extension]) {
|
|
var from = preference.indexOf(db[types[extension]].source);
|
|
var 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;
|
|
}
|
|
});
|
|
}
|
|
}(mimeTypes));
|
|
|
|
/*!
|
|
* accepts
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* Copyright(c) 2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module dependencies.
|
|
* @private
|
|
*/
|
|
|
|
var Negotiator = negotiator.exports;
|
|
var mime = mimeTypes;
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
var accepts$1 = Accepts;
|
|
|
|
/**
|
|
* Create a new Accepts object for the given req.
|
|
*
|
|
* @param {object} req
|
|
* @public
|
|
*/
|
|
|
|
function Accepts (req) {
|
|
if (!(this instanceof Accepts)) {
|
|
return new Accepts(req)
|
|
}
|
|
|
|
this.headers = req.headers;
|
|
this.negotiator = new Negotiator(req);
|
|
}
|
|
|
|
/**
|
|
* Check if the given `type(s)` is acceptable, returning
|
|
* the best match when true, otherwise `undefined`, in which
|
|
* case you should respond with 406 "Not Acceptable".
|
|
*
|
|
* The `type` value may be a single mime type string
|
|
* such as "application/json", the extension name
|
|
* such as "json" or an array `["json", "html", "text/plain"]`. When a list
|
|
* or array is given the _best_ match, if any is returned.
|
|
*
|
|
* Examples:
|
|
*
|
|
* // Accept: text/html
|
|
* this.types('html');
|
|
* // => "html"
|
|
*
|
|
* // Accept: text/*, application/json
|
|
* this.types('html');
|
|
* // => "html"
|
|
* this.types('text/html');
|
|
* // => "text/html"
|
|
* this.types('json', 'text');
|
|
* // => "json"
|
|
* this.types('application/json');
|
|
* // => "application/json"
|
|
*
|
|
* // Accept: text/*, application/json
|
|
* this.types('image/png');
|
|
* this.types('png');
|
|
* // => undefined
|
|
*
|
|
* // Accept: text/*;q=.5, application/json
|
|
* this.types(['html', 'json']);
|
|
* this.types('html', 'json');
|
|
* // => "json"
|
|
*
|
|
* @param {String|Array} types...
|
|
* @return {String|Array|Boolean}
|
|
* @public
|
|
*/
|
|
|
|
Accepts.prototype.type =
|
|
Accepts.prototype.types = function (types_) {
|
|
var types = types_;
|
|
|
|
// support flattened arguments
|
|
if (types && !Array.isArray(types)) {
|
|
types = new Array(arguments.length);
|
|
for (var i = 0; i < types.length; i++) {
|
|
types[i] = arguments[i];
|
|
}
|
|
}
|
|
|
|
// no types, return all requested types
|
|
if (!types || types.length === 0) {
|
|
return this.negotiator.mediaTypes()
|
|
}
|
|
|
|
// no accept header, return first given type
|
|
if (!this.headers.accept) {
|
|
return types[0]
|
|
}
|
|
|
|
var mimes = types.map(extToMime);
|
|
var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));
|
|
var first = accepts[0];
|
|
|
|
return first
|
|
? types[mimes.indexOf(first)]
|
|
: false
|
|
};
|
|
|
|
/**
|
|
* Return accepted encodings or best fit based on `encodings`.
|
|
*
|
|
* Given `Accept-Encoding: gzip, deflate`
|
|
* an array sorted by quality is returned:
|
|
*
|
|
* ['gzip', 'deflate']
|
|
*
|
|
* @param {String|Array} encodings...
|
|
* @return {String|Array}
|
|
* @public
|
|
*/
|
|
|
|
Accepts.prototype.encoding =
|
|
Accepts.prototype.encodings = function (encodings_) {
|
|
var encodings = encodings_;
|
|
|
|
// support flattened arguments
|
|
if (encodings && !Array.isArray(encodings)) {
|
|
encodings = new Array(arguments.length);
|
|
for (var i = 0; i < encodings.length; i++) {
|
|
encodings[i] = arguments[i];
|
|
}
|
|
}
|
|
|
|
// no encodings, return all requested encodings
|
|
if (!encodings || encodings.length === 0) {
|
|
return this.negotiator.encodings()
|
|
}
|
|
|
|
return this.negotiator.encodings(encodings)[0] || false
|
|
};
|
|
|
|
/**
|
|
* Return accepted charsets or best fit based on `charsets`.
|
|
*
|
|
* Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
|
|
* an array sorted by quality is returned:
|
|
*
|
|
* ['utf-8', 'utf-7', 'iso-8859-1']
|
|
*
|
|
* @param {String|Array} charsets...
|
|
* @return {String|Array}
|
|
* @public
|
|
*/
|
|
|
|
Accepts.prototype.charset =
|
|
Accepts.prototype.charsets = function (charsets_) {
|
|
var charsets = charsets_;
|
|
|
|
// support flattened arguments
|
|
if (charsets && !Array.isArray(charsets)) {
|
|
charsets = new Array(arguments.length);
|
|
for (var i = 0; i < charsets.length; i++) {
|
|
charsets[i] = arguments[i];
|
|
}
|
|
}
|
|
|
|
// no charsets, return all requested charsets
|
|
if (!charsets || charsets.length === 0) {
|
|
return this.negotiator.charsets()
|
|
}
|
|
|
|
return this.negotiator.charsets(charsets)[0] || false
|
|
};
|
|
|
|
/**
|
|
* Return accepted languages or best fit based on `langs`.
|
|
*
|
|
* Given `Accept-Language: en;q=0.8, es, pt`
|
|
* an array sorted by quality is returned:
|
|
*
|
|
* ['es', 'pt', 'en']
|
|
*
|
|
* @param {String|Array} langs...
|
|
* @return {Array|String}
|
|
* @public
|
|
*/
|
|
|
|
Accepts.prototype.lang =
|
|
Accepts.prototype.langs =
|
|
Accepts.prototype.language =
|
|
Accepts.prototype.languages = function (languages_) {
|
|
var languages = languages_;
|
|
|
|
// support flattened arguments
|
|
if (languages && !Array.isArray(languages)) {
|
|
languages = new Array(arguments.length);
|
|
for (var i = 0; i < languages.length; i++) {
|
|
languages[i] = arguments[i];
|
|
}
|
|
}
|
|
|
|
// no languages, return all requested languages
|
|
if (!languages || languages.length === 0) {
|
|
return this.negotiator.languages()
|
|
}
|
|
|
|
return this.negotiator.languages(languages)[0] || false
|
|
};
|
|
|
|
/**
|
|
* Convert extnames to mime.
|
|
*
|
|
* @param {String} type
|
|
* @return {String}
|
|
* @private
|
|
*/
|
|
|
|
function extToMime (type) {
|
|
return type.indexOf('/') === -1
|
|
? mime.lookup(type)
|
|
: type
|
|
}
|
|
|
|
/**
|
|
* Check if mime is valid.
|
|
*
|
|
* @param {String} type
|
|
* @return {String}
|
|
* @private
|
|
*/
|
|
|
|
function validMime (type) {
|
|
return typeof type === 'string'
|
|
}
|
|
|
|
var bytes$2 = {exports: {}};
|
|
|
|
/*!
|
|
* bytes
|
|
* Copyright(c) 2012-2014 TJ Holowaychuk
|
|
* Copyright(c) 2015 Jed Watson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
bytes$2.exports = bytes$1;
|
|
bytes$2.exports.format = format;
|
|
bytes$2.exports.parse = parse;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
|
|
|
|
var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
|
|
|
|
var map = {
|
|
b: 1,
|
|
kb: 1 << 10,
|
|
mb: 1 << 20,
|
|
gb: 1 << 30,
|
|
tb: ((1 << 30) * 1024)
|
|
};
|
|
|
|
var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb)$/i;
|
|
|
|
/**
|
|
* Convert the given value in bytes into a string or parse to string to an integer in bytes.
|
|
*
|
|
* @param {string|number} value
|
|
* @param {{
|
|
* case: [string],
|
|
* decimalPlaces: [number]
|
|
* fixedDecimals: [boolean]
|
|
* thousandsSeparator: [string]
|
|
* unitSeparator: [string]
|
|
* }} [options] bytes options.
|
|
*
|
|
* @returns {string|number|null}
|
|
*/
|
|
|
|
function bytes$1(value, options) {
|
|
if (typeof value === 'string') {
|
|
return parse(value);
|
|
}
|
|
|
|
if (typeof value === 'number') {
|
|
return format(value, options);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Format the given value in bytes into a string.
|
|
*
|
|
* If the value is negative, it is kept as such. If it is a float,
|
|
* it is rounded.
|
|
*
|
|
* @param {number} value
|
|
* @param {object} [options]
|
|
* @param {number} [options.decimalPlaces=2]
|
|
* @param {number} [options.fixedDecimals=false]
|
|
* @param {string} [options.thousandsSeparator=]
|
|
* @param {string} [options.unit=]
|
|
* @param {string} [options.unitSeparator=]
|
|
*
|
|
* @returns {string|null}
|
|
* @public
|
|
*/
|
|
|
|
function format(value, options) {
|
|
if (!Number.isFinite(value)) {
|
|
return null;
|
|
}
|
|
|
|
var mag = Math.abs(value);
|
|
var thousandsSeparator = (options && options.thousandsSeparator) || '';
|
|
var unitSeparator = (options && options.unitSeparator) || '';
|
|
var decimalPlaces = (options && options.decimalPlaces !== undefined) ? options.decimalPlaces : 2;
|
|
var fixedDecimals = Boolean(options && options.fixedDecimals);
|
|
var unit = (options && options.unit) || '';
|
|
|
|
if (!unit || !map[unit.toLowerCase()]) {
|
|
if (mag >= map.tb) {
|
|
unit = 'TB';
|
|
} else if (mag >= map.gb) {
|
|
unit = 'GB';
|
|
} else if (mag >= map.mb) {
|
|
unit = 'MB';
|
|
} else if (mag >= map.kb) {
|
|
unit = 'KB';
|
|
} else {
|
|
unit = 'B';
|
|
}
|
|
}
|
|
|
|
var val = value / map[unit.toLowerCase()];
|
|
var str = val.toFixed(decimalPlaces);
|
|
|
|
if (!fixedDecimals) {
|
|
str = str.replace(formatDecimalsRegExp, '$1');
|
|
}
|
|
|
|
if (thousandsSeparator) {
|
|
str = str.replace(formatThousandsRegExp, thousandsSeparator);
|
|
}
|
|
|
|
return str + unitSeparator + unit;
|
|
}
|
|
|
|
/**
|
|
* Parse the string value into an integer in bytes.
|
|
*
|
|
* If no unit is given, it is assumed the value is in bytes.
|
|
*
|
|
* @param {number|string} val
|
|
*
|
|
* @returns {number|null}
|
|
* @public
|
|
*/
|
|
|
|
function parse(val) {
|
|
if (typeof val === 'number' && !isNaN(val)) {
|
|
return val;
|
|
}
|
|
|
|
if (typeof val !== 'string') {
|
|
return null;
|
|
}
|
|
|
|
// Test if the string passed is valid
|
|
var results = parseRegExp.exec(val);
|
|
var floatValue;
|
|
var unit = 'b';
|
|
|
|
if (!results) {
|
|
// Nothing could be extracted from the given string
|
|
floatValue = parseInt(val, 10);
|
|
unit = 'b';
|
|
} else {
|
|
// Retrieve the value and the unit
|
|
floatValue = parseFloat(results[1]);
|
|
unit = results[4].toLowerCase();
|
|
}
|
|
|
|
return Math.floor(map[unit] * floatValue);
|
|
}
|
|
|
|
/*!
|
|
* compressible
|
|
* Copyright(c) 2013 Jonathan Ong
|
|
* Copyright(c) 2014 Jeremiah Senkpiel
|
|
* Copyright(c) 2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module dependencies.
|
|
* @private
|
|
*/
|
|
|
|
var db = mimeDb;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var COMPRESSIBLE_TYPE_REGEXP = /^text\/|\+(?:json|text|xml)$/i;
|
|
var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
var compressible_1 = compressible$1;
|
|
|
|
/**
|
|
* Checks if a type is compressible.
|
|
*
|
|
* @param {string} type
|
|
* @return {Boolean} compressible
|
|
* @public
|
|
*/
|
|
|
|
function compressible$1 (type) {
|
|
if (!type || typeof type !== 'string') {
|
|
return false
|
|
}
|
|
|
|
// strip parameters
|
|
var match = EXTRACT_TYPE_REGEXP.exec(type);
|
|
var mime = match && match[1].toLowerCase();
|
|
var data = db[mime];
|
|
|
|
// return database information
|
|
if (data && data.compressible !== undefined) {
|
|
return data.compressible
|
|
}
|
|
|
|
// fallback to regexp or unknown
|
|
return COMPRESSIBLE_TYPE_REGEXP.test(mime) || undefined
|
|
}
|
|
|
|
var src = {exports: {}};
|
|
|
|
var browser = {exports: {}};
|
|
|
|
var debug$1 = {exports: {}};
|
|
|
|
(function (module, exports) {
|
|
/**
|
|
* This is the common logic for both the Node.js and web browser
|
|
* implementations of `debug()`.
|
|
*
|
|
* Expose `debug()` as the module.
|
|
*/
|
|
|
|
exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
|
|
exports.coerce = coerce;
|
|
exports.disable = disable;
|
|
exports.enable = enable;
|
|
exports.enabled = enabled;
|
|
exports.humanize = build.ms;
|
|
|
|
/**
|
|
* The currently active debug mode names, and names to skip.
|
|
*/
|
|
|
|
exports.names = [];
|
|
exports.skips = [];
|
|
|
|
/**
|
|
* Map of special "%n" handling functions, for the debug "format" argument.
|
|
*
|
|
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
|
|
*/
|
|
|
|
exports.formatters = {};
|
|
|
|
/**
|
|
* Previous log timestamp.
|
|
*/
|
|
|
|
var prevTime;
|
|
|
|
/**
|
|
* Select a color.
|
|
* @param {String} namespace
|
|
* @return {Number}
|
|
* @api private
|
|
*/
|
|
|
|
function selectColor(namespace) {
|
|
var hash = 0, i;
|
|
|
|
for (i in namespace) {
|
|
hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
|
|
hash |= 0; // Convert to 32bit integer
|
|
}
|
|
|
|
return exports.colors[Math.abs(hash) % exports.colors.length];
|
|
}
|
|
|
|
/**
|
|
* Create a debugger with the given `namespace`.
|
|
*
|
|
* @param {String} namespace
|
|
* @return {Function}
|
|
* @api public
|
|
*/
|
|
|
|
function createDebug(namespace) {
|
|
|
|
function debug() {
|
|
// disabled?
|
|
if (!debug.enabled) return;
|
|
|
|
var self = debug;
|
|
|
|
// set `diff` timestamp
|
|
var curr = +new Date();
|
|
var ms = curr - (prevTime || curr);
|
|
self.diff = ms;
|
|
self.prev = prevTime;
|
|
self.curr = curr;
|
|
prevTime = curr;
|
|
|
|
// turn the `arguments` into a proper Array
|
|
var args = new Array(arguments.length);
|
|
for (var i = 0; i < args.length; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
|
|
args[0] = exports.coerce(args[0]);
|
|
|
|
if ('string' !== typeof args[0]) {
|
|
// anything else let's inspect with %O
|
|
args.unshift('%O');
|
|
}
|
|
|
|
// apply any `formatters` transformations
|
|
var index = 0;
|
|
args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
|
|
// if we encounter an escaped % then don't increase the array index
|
|
if (match === '%%') return match;
|
|
index++;
|
|
var formatter = exports.formatters[format];
|
|
if ('function' === typeof formatter) {
|
|
var val = args[index];
|
|
match = formatter.call(self, val);
|
|
|
|
// now we need to remove `args[index]` since it's inlined in the `format`
|
|
args.splice(index, 1);
|
|
index--;
|
|
}
|
|
return match;
|
|
});
|
|
|
|
// apply env-specific formatting (colors, etc.)
|
|
exports.formatArgs.call(self, args);
|
|
|
|
var logFn = debug.log || exports.log || console.log.bind(console);
|
|
logFn.apply(self, args);
|
|
}
|
|
|
|
debug.namespace = namespace;
|
|
debug.enabled = exports.enabled(namespace);
|
|
debug.useColors = exports.useColors();
|
|
debug.color = selectColor(namespace);
|
|
|
|
// env-specific initialization logic for debug instances
|
|
if ('function' === typeof exports.init) {
|
|
exports.init(debug);
|
|
}
|
|
|
|
return debug;
|
|
}
|
|
|
|
/**
|
|
* Enables a debug mode by namespaces. This can include modes
|
|
* separated by a colon and wildcards.
|
|
*
|
|
* @param {String} namespaces
|
|
* @api public
|
|
*/
|
|
|
|
function enable(namespaces) {
|
|
exports.save(namespaces);
|
|
|
|
exports.names = [];
|
|
exports.skips = [];
|
|
|
|
var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
|
|
var len = split.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
if (!split[i]) continue; // ignore empty strings
|
|
namespaces = split[i].replace(/\*/g, '.*?');
|
|
if (namespaces[0] === '-') {
|
|
exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
|
|
} else {
|
|
exports.names.push(new RegExp('^' + namespaces + '$'));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Disable debug output.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function disable() {
|
|
exports.enable('');
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given mode name is enabled, false otherwise.
|
|
*
|
|
* @param {String} name
|
|
* @return {Boolean}
|
|
* @api public
|
|
*/
|
|
|
|
function enabled(name) {
|
|
var i, len;
|
|
for (i = 0, len = exports.skips.length; i < len; i++) {
|
|
if (exports.skips[i].test(name)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (i = 0, len = exports.names.length; i < len; i++) {
|
|
if (exports.names[i].test(name)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Coerce `val`.
|
|
*
|
|
* @param {Mixed} val
|
|
* @return {Mixed}
|
|
* @api private
|
|
*/
|
|
|
|
function coerce(val) {
|
|
if (val instanceof Error) return val.stack || val.message;
|
|
return val;
|
|
}
|
|
}(debug$1, debug$1.exports));
|
|
|
|
/**
|
|
* This is the web browser implementation of `debug()`.
|
|
*
|
|
* Expose `debug()` as the module.
|
|
*/
|
|
|
|
(function (module, exports) {
|
|
exports = module.exports = debug$1.exports;
|
|
exports.log = log;
|
|
exports.formatArgs = formatArgs;
|
|
exports.save = save;
|
|
exports.load = load;
|
|
exports.useColors = useColors;
|
|
exports.storage = 'undefined' != typeof chrome
|
|
&& 'undefined' != typeof chrome.storage
|
|
? chrome.storage.local
|
|
: localstorage();
|
|
|
|
/**
|
|
* Colors.
|
|
*/
|
|
|
|
exports.colors = [
|
|
'lightseagreen',
|
|
'forestgreen',
|
|
'goldenrod',
|
|
'dodgerblue',
|
|
'darkorchid',
|
|
'crimson'
|
|
];
|
|
|
|
/**
|
|
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
|
|
* and the Firebug extension (any Firefox version) are known
|
|
* to support "%c" CSS customizations.
|
|
*
|
|
* TODO: add a `localStorage` variable to explicitly enable/disable colors
|
|
*/
|
|
|
|
function useColors() {
|
|
// NB: In an Electron preload script, document will be defined but not fully
|
|
// initialized. Since we know we're in Chrome, we'll just detect this case
|
|
// explicitly
|
|
if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
|
|
return true;
|
|
}
|
|
|
|
// is webkit? http://stackoverflow.com/a/16459606/376773
|
|
// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
|
|
return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
|
|
// is firebug? http://stackoverflow.com/a/398120/376773
|
|
(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
|
|
// is firefox >= v31?
|
|
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
|
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
|
|
// double check webkit in userAgent just in case we are in a worker
|
|
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
|
|
}
|
|
|
|
/**
|
|
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
|
|
*/
|
|
|
|
exports.formatters.j = function(v) {
|
|
try {
|
|
return JSON.stringify(v);
|
|
} catch (err) {
|
|
return '[UnexpectedJSONParseError]: ' + err.message;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Colorize log arguments if enabled.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function formatArgs(args) {
|
|
var useColors = this.useColors;
|
|
|
|
args[0] = (useColors ? '%c' : '')
|
|
+ this.namespace
|
|
+ (useColors ? ' %c' : ' ')
|
|
+ args[0]
|
|
+ (useColors ? '%c ' : ' ')
|
|
+ '+' + exports.humanize(this.diff);
|
|
|
|
if (!useColors) return;
|
|
|
|
var c = 'color: ' + this.color;
|
|
args.splice(1, 0, c, 'color: inherit');
|
|
|
|
// the final "%c" is somewhat tricky, because there could be other
|
|
// arguments passed either before or after the %c, so we need to
|
|
// figure out the correct index to insert the CSS into
|
|
var index = 0;
|
|
var lastC = 0;
|
|
args[0].replace(/%[a-zA-Z%]/g, function(match) {
|
|
if ('%%' === match) return;
|
|
index++;
|
|
if ('%c' === match) {
|
|
// we only are interested in the *last* %c
|
|
// (the user may have provided their own)
|
|
lastC = index;
|
|
}
|
|
});
|
|
|
|
args.splice(lastC, 0, c);
|
|
}
|
|
|
|
/**
|
|
* Invokes `console.log()` when available.
|
|
* No-op when `console.log` is not a "function".
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function log() {
|
|
// this hackery is required for IE8/9, where
|
|
// the `console.log` function doesn't have 'apply'
|
|
return 'object' === typeof console
|
|
&& console.log
|
|
&& Function.prototype.apply.call(console.log, console, arguments);
|
|
}
|
|
|
|
/**
|
|
* Save `namespaces`.
|
|
*
|
|
* @param {String} namespaces
|
|
* @api private
|
|
*/
|
|
|
|
function save(namespaces) {
|
|
try {
|
|
if (null == namespaces) {
|
|
exports.storage.removeItem('debug');
|
|
} else {
|
|
exports.storage.debug = namespaces;
|
|
}
|
|
} catch(e) {}
|
|
}
|
|
|
|
/**
|
|
* Load `namespaces`.
|
|
*
|
|
* @return {String} returns the previously persisted debug modes
|
|
* @api private
|
|
*/
|
|
|
|
function load() {
|
|
var r;
|
|
try {
|
|
r = exports.storage.debug;
|
|
} catch(e) {}
|
|
|
|
// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
|
|
if (!r && typeof process !== 'undefined' && 'env' in process) {
|
|
r = process.env.DEBUG;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
* Enable namespaces listed in `localStorage.debug` initially.
|
|
*/
|
|
|
|
exports.enable(load());
|
|
|
|
/**
|
|
* Localstorage attempts to return the localstorage.
|
|
*
|
|
* This is necessary because safari throws
|
|
* when a user disables cookies/localstorage
|
|
* and you attempt to access it.
|
|
*
|
|
* @return {LocalStorage}
|
|
* @api private
|
|
*/
|
|
|
|
function localstorage() {
|
|
try {
|
|
return window.localStorage;
|
|
} catch (e) {}
|
|
}
|
|
}(browser, browser.exports));
|
|
|
|
var node = {exports: {}};
|
|
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
(function (module, exports) {
|
|
var tty = require$$0__default;
|
|
var util = require$$0__default$1;
|
|
|
|
/**
|
|
* This is the Node.js implementation of `debug()`.
|
|
*
|
|
* Expose `debug()` as the module.
|
|
*/
|
|
|
|
exports = module.exports = debug$1.exports;
|
|
exports.init = init;
|
|
exports.log = log;
|
|
exports.formatArgs = formatArgs;
|
|
exports.save = save;
|
|
exports.load = load;
|
|
exports.useColors = useColors;
|
|
|
|
/**
|
|
* Colors.
|
|
*/
|
|
|
|
exports.colors = [6, 2, 3, 4, 5, 1];
|
|
|
|
/**
|
|
* Build up the default `inspectOpts` object from the environment variables.
|
|
*
|
|
* $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
|
|
*/
|
|
|
|
exports.inspectOpts = Object.keys(process.env).filter(function (key) {
|
|
return /^debug_/i.test(key);
|
|
}).reduce(function (obj, key) {
|
|
// camel-case
|
|
var prop = key
|
|
.substring(6)
|
|
.toLowerCase()
|
|
.replace(/_([a-z])/g, function (_, k) { return k.toUpperCase() });
|
|
|
|
// coerce string value into JS value
|
|
var val = process.env[key];
|
|
if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
|
|
else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
|
|
else if (val === 'null') val = null;
|
|
else val = Number(val);
|
|
|
|
obj[prop] = val;
|
|
return obj;
|
|
}, {});
|
|
|
|
/**
|
|
* The file descriptor to write the `debug()` calls to.
|
|
* Set the `DEBUG_FD` env variable to override with another value. i.e.:
|
|
*
|
|
* $ DEBUG_FD=3 node script.js 3>debug.log
|
|
*/
|
|
|
|
var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
|
|
|
|
if (1 !== fd && 2 !== fd) {
|
|
util.deprecate(function(){}, 'except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)')();
|
|
}
|
|
|
|
var stream = 1 === fd ? process.stdout :
|
|
2 === fd ? process.stderr :
|
|
createWritableStdioStream(fd);
|
|
|
|
/**
|
|
* Is stdout a TTY? Colored output is enabled when `true`.
|
|
*/
|
|
|
|
function useColors() {
|
|
return 'colors' in exports.inspectOpts
|
|
? Boolean(exports.inspectOpts.colors)
|
|
: tty.isatty(fd);
|
|
}
|
|
|
|
/**
|
|
* Map %o to `util.inspect()`, all on a single line.
|
|
*/
|
|
|
|
exports.formatters.o = function(v) {
|
|
this.inspectOpts.colors = this.useColors;
|
|
return util.inspect(v, this.inspectOpts)
|
|
.split('\n').map(function(str) {
|
|
return str.trim()
|
|
}).join(' ');
|
|
};
|
|
|
|
/**
|
|
* Map %o to `util.inspect()`, allowing multiple lines if needed.
|
|
*/
|
|
|
|
exports.formatters.O = function(v) {
|
|
this.inspectOpts.colors = this.useColors;
|
|
return util.inspect(v, this.inspectOpts);
|
|
};
|
|
|
|
/**
|
|
* Adds ANSI color escape codes if enabled.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
function formatArgs(args) {
|
|
var name = this.namespace;
|
|
var useColors = this.useColors;
|
|
|
|
if (useColors) {
|
|
var c = this.color;
|
|
var prefix = ' \u001b[3' + c + ';1m' + name + ' ' + '\u001b[0m';
|
|
|
|
args[0] = prefix + args[0].split('\n').join('\n' + prefix);
|
|
args.push('\u001b[3' + c + 'm+' + exports.humanize(this.diff) + '\u001b[0m');
|
|
} else {
|
|
args[0] = new Date().toUTCString()
|
|
+ ' ' + name + ' ' + args[0];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invokes `util.format()` with the specified arguments and writes to `stream`.
|
|
*/
|
|
|
|
function log() {
|
|
return stream.write(util.format.apply(util, arguments) + '\n');
|
|
}
|
|
|
|
/**
|
|
* Save `namespaces`.
|
|
*
|
|
* @param {String} namespaces
|
|
* @api private
|
|
*/
|
|
|
|
function save(namespaces) {
|
|
if (null == namespaces) {
|
|
// If you set a process.env field to null or undefined, it gets cast to the
|
|
// string 'null' or 'undefined'. Just delete instead.
|
|
delete process.env.DEBUG;
|
|
} else {
|
|
process.env.DEBUG = namespaces;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load `namespaces`.
|
|
*
|
|
* @return {String} returns the previously persisted debug modes
|
|
* @api private
|
|
*/
|
|
|
|
function load() {
|
|
return process.env.DEBUG;
|
|
}
|
|
|
|
/**
|
|
* Copied from `node/src/node.js`.
|
|
*
|
|
* XXX: It's lame that node doesn't expose this API out-of-the-box. It also
|
|
* relies on the undocumented `tty_wrap.guessHandleType()` which is also lame.
|
|
*/
|
|
|
|
function createWritableStdioStream (fd) {
|
|
var stream;
|
|
var tty_wrap = process.binding('tty_wrap');
|
|
|
|
// Note stream._type is used for test-module-load-list.js
|
|
|
|
switch (tty_wrap.guessHandleType(fd)) {
|
|
case 'TTY':
|
|
stream = new tty.WriteStream(fd);
|
|
stream._type = 'tty';
|
|
|
|
// Hack to have stream not keep the event loop alive.
|
|
// See https://github.com/joyent/node/issues/1726
|
|
if (stream._handle && stream._handle.unref) {
|
|
stream._handle.unref();
|
|
}
|
|
break;
|
|
|
|
case 'FILE':
|
|
var fs = fs__default;
|
|
stream = new fs.SyncWriteStream(fd, { autoClose: false });
|
|
stream._type = 'fs';
|
|
break;
|
|
|
|
case 'PIPE':
|
|
case 'TCP':
|
|
var net = require$$4__default;
|
|
stream = new net.Socket({
|
|
fd: fd,
|
|
readable: false,
|
|
writable: true
|
|
});
|
|
|
|
// FIXME Should probably have an option in net.Socket to create a
|
|
// stream from an existing fd which is writable only. But for now
|
|
// we'll just add this hack and set the `readable` member to false.
|
|
// Test: ./node test/fixtures/echo.js < /etc/passwd
|
|
stream.readable = false;
|
|
stream.read = null;
|
|
stream._type = 'pipe';
|
|
|
|
// FIXME Hack to have stream not keep the event loop alive.
|
|
// See https://github.com/joyent/node/issues/1726
|
|
if (stream._handle && stream._handle.unref) {
|
|
stream._handle.unref();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Probably an error on in uv_guess_handle()
|
|
throw new Error('Implement me. Unknown stream file type!');
|
|
}
|
|
|
|
// For supporting legacy API we put the FD here.
|
|
stream.fd = fd;
|
|
|
|
stream._isStdio = true;
|
|
|
|
return stream;
|
|
}
|
|
|
|
/**
|
|
* Init logic for `debug` instances.
|
|
*
|
|
* Create a new `inspectOpts` object in case `useColors` is set
|
|
* differently for a particular `debug` instance.
|
|
*/
|
|
|
|
function init (debug) {
|
|
debug.inspectOpts = {};
|
|
|
|
var keys = Object.keys(exports.inspectOpts);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Enable namespaces listed in `process.env.DEBUG` initially.
|
|
*/
|
|
|
|
exports.enable(load());
|
|
}(node, node.exports));
|
|
|
|
/**
|
|
* Detect Electron renderer process, which is node, but we should
|
|
* treat as a browser.
|
|
*/
|
|
|
|
if (typeof process !== 'undefined' && process.type === 'renderer') {
|
|
src.exports = browser.exports;
|
|
} else {
|
|
src.exports = node.exports;
|
|
}
|
|
|
|
/*!
|
|
* on-headers
|
|
* Copyright(c) 2014 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
var onHeaders_1 = onHeaders$1;
|
|
|
|
/**
|
|
* Create a replacement writeHead method.
|
|
*
|
|
* @param {function} prevWriteHead
|
|
* @param {function} listener
|
|
* @private
|
|
*/
|
|
|
|
function createWriteHead (prevWriteHead, listener) {
|
|
var fired = false;
|
|
|
|
// return function with core name and argument list
|
|
return function writeHead (statusCode) {
|
|
// set headers from arguments
|
|
var args = setWriteHeadHeaders.apply(this, arguments);
|
|
|
|
// fire listener
|
|
if (!fired) {
|
|
fired = true;
|
|
listener.call(this);
|
|
|
|
// pass-along an updated status code
|
|
if (typeof args[0] === 'number' && this.statusCode !== args[0]) {
|
|
args[0] = this.statusCode;
|
|
args.length = 1;
|
|
}
|
|
}
|
|
|
|
return prevWriteHead.apply(this, args)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Execute a listener when a response is about to write headers.
|
|
*
|
|
* @param {object} res
|
|
* @return {function} listener
|
|
* @public
|
|
*/
|
|
|
|
function onHeaders$1 (res, listener) {
|
|
if (!res) {
|
|
throw new TypeError('argument res is required')
|
|
}
|
|
|
|
if (typeof listener !== 'function') {
|
|
throw new TypeError('argument listener must be a function')
|
|
}
|
|
|
|
res.writeHead = createWriteHead(res.writeHead, listener);
|
|
}
|
|
|
|
/**
|
|
* Set headers contained in array on the response object.
|
|
*
|
|
* @param {object} res
|
|
* @param {array} headers
|
|
* @private
|
|
*/
|
|
|
|
function setHeadersFromArray (res, headers) {
|
|
for (var i = 0; i < headers.length; i++) {
|
|
res.setHeader(headers[i][0], headers[i][1]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set headers contained in object on the response object.
|
|
*
|
|
* @param {object} res
|
|
* @param {object} headers
|
|
* @private
|
|
*/
|
|
|
|
function setHeadersFromObject (res, headers) {
|
|
var keys = Object.keys(headers);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var k = keys[i];
|
|
if (k) res.setHeader(k, headers[k]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set headers and other properties on the response object.
|
|
*
|
|
* @param {number} statusCode
|
|
* @private
|
|
*/
|
|
|
|
function setWriteHeadHeaders (statusCode) {
|
|
var length = arguments.length;
|
|
var headerIndex = length > 1 && typeof arguments[1] === 'string'
|
|
? 2
|
|
: 1;
|
|
|
|
var headers = length >= headerIndex + 1
|
|
? arguments[headerIndex]
|
|
: undefined;
|
|
|
|
this.statusCode = statusCode;
|
|
|
|
if (Array.isArray(headers)) {
|
|
// handle array case
|
|
setHeadersFromArray(this, headers);
|
|
} else if (headers) {
|
|
// handle object case
|
|
setHeadersFromObject(this, headers);
|
|
}
|
|
|
|
// copy leading arguments
|
|
var args = new Array(Math.min(length, headerIndex));
|
|
for (var i = 0; i < args.length; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
|
|
return args
|
|
}
|
|
|
|
/*!
|
|
* compression
|
|
* Copyright(c) 2010 Sencha Inc.
|
|
* Copyright(c) 2011 TJ Holowaychuk
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* Copyright(c) 2014-2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module dependencies.
|
|
* @private
|
|
*/
|
|
|
|
var accepts = accepts$1;
|
|
var Buffer = build.safeBuffer.exports.Buffer;
|
|
var bytes = bytes$2.exports;
|
|
var compressible = compressible_1;
|
|
var debug = src.exports('compression');
|
|
var onHeaders = onHeaders_1;
|
|
var vary = build.vary.exports;
|
|
var zlib = require$$0__default$2;
|
|
|
|
/**
|
|
* Module exports.
|
|
*/
|
|
|
|
compression$2.exports = compression;
|
|
compression$2.exports.filter = shouldCompress;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/;
|
|
|
|
/**
|
|
* Compress response data with gzip / deflate.
|
|
*
|
|
* @param {Object} [options]
|
|
* @return {Function} middleware
|
|
* @public
|
|
*/
|
|
|
|
function compression (options) {
|
|
var opts = options || {};
|
|
|
|
// options
|
|
var filter = opts.filter || shouldCompress;
|
|
var threshold = bytes.parse(opts.threshold);
|
|
|
|
if (threshold == null) {
|
|
threshold = 1024;
|
|
}
|
|
|
|
return function compression (req, res, next) {
|
|
var ended = false;
|
|
var length;
|
|
var listeners = [];
|
|
var stream;
|
|
|
|
var _end = res.end;
|
|
var _on = res.on;
|
|
var _write = res.write;
|
|
|
|
// flush
|
|
res.flush = function flush () {
|
|
if (stream) {
|
|
stream.flush();
|
|
}
|
|
};
|
|
|
|
// proxy
|
|
|
|
res.write = function write (chunk, encoding) {
|
|
if (ended) {
|
|
return false
|
|
}
|
|
|
|
if (!this._header) {
|
|
this._implicitHeader();
|
|
}
|
|
|
|
return stream
|
|
? stream.write(toBuffer(chunk, encoding))
|
|
: _write.call(this, chunk, encoding)
|
|
};
|
|
|
|
res.end = function end (chunk, encoding) {
|
|
if (ended) {
|
|
return false
|
|
}
|
|
|
|
if (!this._header) {
|
|
// estimate the length
|
|
if (!this.getHeader('Content-Length')) {
|
|
length = chunkLength(chunk, encoding);
|
|
}
|
|
|
|
this._implicitHeader();
|
|
}
|
|
|
|
if (!stream) {
|
|
return _end.call(this, chunk, encoding)
|
|
}
|
|
|
|
// mark ended
|
|
ended = true;
|
|
|
|
// write Buffer for Node.js 0.8
|
|
return chunk
|
|
? stream.end(toBuffer(chunk, encoding))
|
|
: stream.end()
|
|
};
|
|
|
|
res.on = function on (type, listener) {
|
|
if (!listeners || type !== 'drain') {
|
|
return _on.call(this, type, listener)
|
|
}
|
|
|
|
if (stream) {
|
|
return stream.on(type, listener)
|
|
}
|
|
|
|
// buffer listeners for future stream
|
|
listeners.push([type, listener]);
|
|
|
|
return this
|
|
};
|
|
|
|
function nocompress (msg) {
|
|
debug('no compression: %s', msg);
|
|
addListeners(res, _on, listeners);
|
|
listeners = null;
|
|
}
|
|
|
|
onHeaders(res, function onResponseHeaders () {
|
|
// determine if request is filtered
|
|
if (!filter(req, res)) {
|
|
nocompress('filtered');
|
|
return
|
|
}
|
|
|
|
// determine if the entity should be transformed
|
|
if (!shouldTransform(req, res)) {
|
|
nocompress('no transform');
|
|
return
|
|
}
|
|
|
|
// vary
|
|
vary(res, 'Accept-Encoding');
|
|
|
|
// content-length below threshold
|
|
if (Number(res.getHeader('Content-Length')) < threshold || length < threshold) {
|
|
nocompress('size below threshold');
|
|
return
|
|
}
|
|
|
|
var encoding = res.getHeader('Content-Encoding') || 'identity';
|
|
|
|
// already encoded
|
|
if (encoding !== 'identity') {
|
|
nocompress('already encoded');
|
|
return
|
|
}
|
|
|
|
// head
|
|
if (req.method === 'HEAD') {
|
|
nocompress('HEAD request');
|
|
return
|
|
}
|
|
|
|
// compression method
|
|
var accept = accepts(req);
|
|
var method = accept.encoding(['gzip', 'deflate', 'identity']);
|
|
|
|
// we really don't prefer deflate
|
|
if (method === 'deflate' && accept.encoding(['gzip'])) {
|
|
method = accept.encoding(['gzip', 'identity']);
|
|
}
|
|
|
|
// negotiation failed
|
|
if (!method || method === 'identity') {
|
|
nocompress('not acceptable');
|
|
return
|
|
}
|
|
|
|
// compression stream
|
|
debug('%s compression', method);
|
|
stream = method === 'gzip'
|
|
? zlib.createGzip(opts)
|
|
: zlib.createDeflate(opts);
|
|
|
|
// add buffered listeners to stream
|
|
addListeners(stream, stream.on, listeners);
|
|
|
|
// header fields
|
|
res.setHeader('Content-Encoding', method);
|
|
res.removeHeader('Content-Length');
|
|
|
|
// compression
|
|
stream.on('data', function onStreamData (chunk) {
|
|
if (_write.call(res, chunk) === false) {
|
|
stream.pause();
|
|
}
|
|
});
|
|
|
|
stream.on('end', function onStreamEnd () {
|
|
_end.call(res);
|
|
});
|
|
|
|
_on.call(res, 'drain', function onResponseDrain () {
|
|
stream.resume();
|
|
});
|
|
});
|
|
|
|
next();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add bufferred listeners to stream
|
|
* @private
|
|
*/
|
|
|
|
function addListeners (stream, on, listeners) {
|
|
for (var i = 0; i < listeners.length; i++) {
|
|
on.apply(stream, listeners[i]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the length of a given chunk
|
|
*/
|
|
|
|
function chunkLength (chunk, encoding) {
|
|
if (!chunk) {
|
|
return 0
|
|
}
|
|
|
|
return !Buffer.isBuffer(chunk)
|
|
? Buffer.byteLength(chunk, encoding)
|
|
: chunk.length
|
|
}
|
|
|
|
/**
|
|
* Default filter function.
|
|
* @private
|
|
*/
|
|
|
|
function shouldCompress (req, res) {
|
|
var type = res.getHeader('Content-Type');
|
|
|
|
if (type === undefined || !compressible(type)) {
|
|
debug('%s not compressible', type);
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* Determine if the entity should be transformed.
|
|
* @private
|
|
*/
|
|
|
|
function shouldTransform (req, res) {
|
|
var cacheControl = res.getHeader('Cache-Control');
|
|
|
|
// Don't compress for Cache-Control: no-transform
|
|
// https://tools.ietf.org/html/rfc7234#section-5.2.2.4
|
|
return !cacheControl ||
|
|
!cacheControlNoTransformRegExp.test(cacheControl)
|
|
}
|
|
|
|
/**
|
|
* Coerce arguments to Buffer
|
|
* @private
|
|
*/
|
|
|
|
function toBuffer (chunk, encoding) {
|
|
return !Buffer.isBuffer(chunk)
|
|
? Buffer.from(chunk, encoding)
|
|
: chunk
|
|
}
|
|
|
|
var compression$1 = compression$2.exports;
|
|
|
|
async function preview(config, serverOptions) {
|
|
var _a, _b;
|
|
const app = build.connect();
|
|
const httpServer = await build.resolveHttpServer(config.server, app, await build.resolveHttpsConfig(config));
|
|
// cors
|
|
const { cors } = config.server;
|
|
if (cors !== false) {
|
|
app.use(build.corsMiddleware(typeof cors === 'boolean' ? {} : cors));
|
|
}
|
|
// proxy
|
|
if (config.server.proxy) {
|
|
app.use(build.proxyMiddleware(httpServer, config));
|
|
}
|
|
app.use(compression$1());
|
|
const distDir = path__default.resolve(config.root, config.build.outDir);
|
|
app.use(config.base, build.sirv(distDir, {
|
|
etag: true,
|
|
dev: true,
|
|
single: true
|
|
}));
|
|
const options = config.server;
|
|
const hostname = build.resolveHostname((_a = serverOptions.host) !== null && _a !== void 0 ? _a : options.host);
|
|
const port = (_b = serverOptions.port) !== null && _b !== void 0 ? _b : 5000;
|
|
const protocol = options.https ? 'https' : 'http';
|
|
const logger = config.logger;
|
|
const base = config.base;
|
|
const serverPort = await build.httpServerStart(httpServer, {
|
|
port,
|
|
strictPort: options.strictPort,
|
|
host: hostname.host,
|
|
logger
|
|
});
|
|
logger.info(build.source.cyan(`\n vite v${require('vite/package.json').version}`) +
|
|
build.source.green(` build preview server running at:\n`));
|
|
build.printServerUrls(hostname, protocol, serverPort, base, logger.info);
|
|
if (options.open) {
|
|
const path = typeof options.open === 'string' ? options.open : base;
|
|
build.openBrowser(`${protocol}://${hostname.name}:${serverPort}${path}`, true, logger);
|
|
}
|
|
}
|
|
|
|
const cli = cac('vite');
|
|
/**
|
|
* removing global flags before passing as command specific sub-configs
|
|
*/
|
|
function cleanOptions(options) {
|
|
const ret = { ...options };
|
|
delete ret['--'];
|
|
delete ret.c;
|
|
delete ret.config;
|
|
delete ret.r;
|
|
delete ret.root;
|
|
delete ret.base;
|
|
delete ret.l;
|
|
delete ret.logLevel;
|
|
delete ret.clearScreen;
|
|
delete ret.d;
|
|
delete ret.debug;
|
|
delete ret.f;
|
|
delete ret.filter;
|
|
delete ret.m;
|
|
delete ret.mode;
|
|
return ret;
|
|
}
|
|
cli
|
|
.option('-c, --config <file>', `[string] use specified config file`)
|
|
.option('-r, --root <path>', `[string] use specified root directory`)
|
|
.option('--base <path>', `[string] public base path (default: /)`)
|
|
.option('-l, --logLevel <level>', `[string] info | warn | error | silent`)
|
|
.option('--clearScreen', `[boolean] allow/disable clear screen when logging`)
|
|
.option('-d, --debug [feat]', `[string | boolean] show debug logs`)
|
|
.option('-f, --filter <filter>', `[string] filter debug logs`)
|
|
.option('-m, --mode <mode>', `[string] set env mode`);
|
|
// dev
|
|
cli
|
|
.command('[root]') // default command
|
|
.alias('serve')
|
|
.option('--host [host]', `[string] specify hostname`)
|
|
.option('--port <port>', `[number] specify port`)
|
|
.option('--https', `[boolean] use TLS + HTTP/2`)
|
|
.option('--open [path]', `[boolean | string] open browser on startup`)
|
|
.option('--cors', `[boolean] enable CORS`)
|
|
.option('--strictPort', `[boolean] exit if specified port is already in use`)
|
|
.option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
|
|
.action(async (root, options) => {
|
|
// output structure is preserved even after bundling so require()
|
|
// is ok here
|
|
const { createServer } = await Promise.resolve().then(function () { return require('./chunks/dep-1be34a63.js'); }).then(function (n) { return n.index$1; });
|
|
try {
|
|
const server = await createServer({
|
|
root,
|
|
base: options.base,
|
|
mode: options.mode,
|
|
configFile: options.config,
|
|
logLevel: options.logLevel,
|
|
clearScreen: options.clearScreen,
|
|
server: cleanOptions(options)
|
|
});
|
|
await server.listen();
|
|
}
|
|
catch (e) {
|
|
build.createLogger(options.logLevel).error(build.source.red(`error when starting dev server:\n${e.stack}`), { error: e });
|
|
process.exit(1);
|
|
}
|
|
});
|
|
// build
|
|
cli
|
|
.command('build [root]')
|
|
.option('--target <target>', `[string] transpile target (default: 'modules')`)
|
|
.option('--outDir <dir>', `[string] output directory (default: dist)`)
|
|
.option('--assetsDir <dir>', `[string] directory under outDir to place assets in (default: _assets)`)
|
|
.option('--assetsInlineLimit <number>', `[number] static asset base64 inline threshold in bytes (default: 4096)`)
|
|
.option('--ssr [entry]', `[string] build specified entry for server-side rendering`)
|
|
.option('--sourcemap', `[boolean] output source maps for build (default: false)`)
|
|
.option('--minify [minifier]', `[boolean | "terser" | "esbuild"] enable/disable minification, ` +
|
|
`or specify minifier to use (default: terser)`)
|
|
.option('--manifest', `[boolean] emit build manifest json`)
|
|
.option('--ssrManifest', `[boolean] emit ssr manifest json`)
|
|
.option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`)
|
|
.option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
|
|
.action(async (root, options) => {
|
|
const { build: build$1 } = await Promise.resolve().then(function () { return require('./chunks/dep-1be34a63.js'); }).then(function (n) { return n.build$1; });
|
|
const buildOptions = cleanOptions(options);
|
|
try {
|
|
await build$1({
|
|
root,
|
|
base: options.base,
|
|
mode: options.mode,
|
|
configFile: options.config,
|
|
logLevel: options.logLevel,
|
|
clearScreen: options.clearScreen,
|
|
build: buildOptions
|
|
});
|
|
}
|
|
catch (e) {
|
|
build.createLogger(options.logLevel).error(build.source.red(`error during build:\n${e.stack}`), { error: e });
|
|
process.exit(1);
|
|
}
|
|
});
|
|
// optimize
|
|
cli
|
|
.command('optimize [root]')
|
|
.option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
|
|
.action(async (root, options) => {
|
|
const { optimizeDeps } = await Promise.resolve().then(function () { return require('./chunks/dep-1be34a63.js'); }).then(function (n) { return n.index; });
|
|
try {
|
|
const config = await build.resolveConfig({
|
|
root,
|
|
base: options.base,
|
|
configFile: options.config,
|
|
logLevel: options.logLevel
|
|
}, 'build', 'development');
|
|
await optimizeDeps(config, options.force, true);
|
|
}
|
|
catch (e) {
|
|
build.createLogger(options.logLevel).error(build.source.red(`error when optimizing deps:\n${e.stack}`), { error: e });
|
|
process.exit(1);
|
|
}
|
|
});
|
|
cli
|
|
.command('preview [root]')
|
|
.option('--host [host]', `[string] specify hostname`)
|
|
.option('--port <port>', `[number] specify port`)
|
|
.option('--https', `[boolean] use TLS + HTTP/2`)
|
|
.option('--open [path]', `[boolean | string] open browser on startup`)
|
|
.option('--strictPort', `[boolean] exit if specified port is already in use`)
|
|
.action(async (root, options) => {
|
|
try {
|
|
const config = await build.resolveConfig({
|
|
root,
|
|
base: options.base,
|
|
configFile: options.config,
|
|
logLevel: options.logLevel,
|
|
server: {
|
|
open: options.open,
|
|
strictPort: options.strictPort,
|
|
https: options.https
|
|
}
|
|
}, 'serve', 'production');
|
|
await preview(config, cleanOptions(options));
|
|
}
|
|
catch (e) {
|
|
build.createLogger(options.logLevel).error(build.source.red(`error when starting preview server:\n${e.stack}`), { error: e });
|
|
process.exit(1);
|
|
}
|
|
});
|
|
cli.help();
|
|
cli.version(require('../../package.json').version);
|
|
cli.parse();
|
|
//# sourceMappingURL=cli.js.map
|