@httpland/compression-middleware 1.0.0-beta.1

package/script/deps/deno.land/std@0.180.0/http/_negotiation/media_type.js

@@ -0,0 +1,178 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/*!
+ * Adapted directly from negotiator at https://github.com/jshttp/negotiator/
+ * which is licensed as follows:
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2012-2014 Federico Romero
+ * Copyright (c) 2012-2014 Isaac Z. Schlueter
+ * Copyright (c) 2014-2015 Douglas Christopher Wilson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferredMediaTypes = void 0;
+const common_js_1 = require("./common.js");
+const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+function quoteCount(str) {
+    let count = 0;
+    let index = 0;
+    while ((index = str.indexOf(`"`, index)) !== -1) {
+        count++;
+        index++;
+    }
+    return count;
+}
+function splitMediaTypes(accept) {
+    const accepts = accept.split(",");
+    let j = 0;
+    for (let i = 1; i < accepts.length; i++) {
+        if (quoteCount(accepts[j]) % 2 === 0) {
+            accepts[++j] = accepts[i];
+        }
+        else {
+            accepts[j] += `,${accepts[i]}`;
+        }
+    }
+    accepts.length = j + 1;
+    return accepts;
+}
+function splitParameters(str) {
+    const parameters = str.split(";");
+    let j = 0;
+    for (let i = 1; i < parameters.length; i++) {
+        if (quoteCount(parameters[j]) % 2 === 0) {
+            parameters[++j] = parameters[i];
+        }
+        else {
+            parameters[j] += `;${parameters[i]}`;
+        }
+    }
+    parameters.length = j + 1;
+    return parameters.map((p) => p.trim());
+}
+function splitKeyValuePair(str) {
+    const [key, value] = str.split("=");
+    return [key.toLowerCase(), value];
+}
+function parseMediaType(str, i) {
+    const match = simpleMediaTypeRegExp.exec(str);
+    if (!match) {
+        return;
+    }
+    const params = Object.create(null);
+    let q = 1;
+    const [, type, subtype, parameters] = match;
+    if (parameters) {
+        const kvps = splitParameters(parameters).map(splitKeyValuePair);
+        for (const [key, val] of kvps) {
+            const value = val && val[0] === `"` && val[val.length - 1] === `"`
+                ? val.slice(1, val.length - 1)
+                : val;
+            if (key === "q" && value) {
+                q = parseFloat(value);
+                break;
+            }
+            params[key] = value;
+        }
+    }
+    return { type, subtype, params, q, i };
+}
+function parseAccept(accept) {
+    const accepts = splitMediaTypes(accept);
+    const mediaTypes = [];
+    for (let i = 0; i < accepts.length; i++) {
+        const mediaType = parseMediaType(accepts[i].trim(), i);
+        if (mediaType) {
+            mediaTypes.push(mediaType);
+        }
+    }
+    return mediaTypes;
+}
+function getFullType(spec) {
+    return `${spec.type}/${spec.subtype}`;
+}
+function specify(type, spec, index) {
+    const p = parseMediaType(type, index);
+    if (!p) {
+        return;
+    }
+    let s = 0;
+    if (spec.type.toLowerCase() === p.type.toLowerCase()) {
+        s |= 4;
+    }
+    else if (spec.type !== "*") {
+        return;
+    }
+    if (spec.subtype.toLowerCase() === p.subtype.toLowerCase()) {
+        s |= 2;
+    }
+    else if (spec.subtype !== "*") {
+        return;
+    }
+    const keys = Object.keys(spec.params);
+    if (keys.length) {
+        if (keys.every((key) => (spec.params[key] || "").toLowerCase() ===
+            (p.params[key] || "").toLowerCase())) {
+            s |= 1;
+        }
+        else {
+            return;
+        }
+    }
+    return {
+        i: index,
+        o: spec.o,
+        q: spec.q,
+        s,
+    };
+}
+function getMediaTypePriority(type, accepted, index) {
+    let priority = { o: -1, q: 0, s: 0, i: index };
+    for (const accepts of accepted) {
+        const spec = specify(type, accepts, index);
+        if (spec &&
+            ((priority.s || 0) - (spec.s || 0) ||
+                (priority.q || 0) - (spec.q || 0) ||
+                (priority.o || 0) - (spec.o || 0)) < 0) {
+            priority = spec;
+        }
+    }
+    return priority;
+}
+function preferredMediaTypes(accept, provided) {
+    const accepts = parseAccept(accept === undefined ? "*/*" : accept || "");
+    if (!provided) {
+        return accepts
+            .filter(common_js_1.isQuality)
+            .sort(common_js_1.compareSpecs)
+            .map(getFullType);
+    }
+    const priorities = provided.map((type, index) => {
+        return getMediaTypePriority(type, accepts, index);
+    });
+    return priorities
+        .filter(common_js_1.isQuality)
+        .sort(common_js_1.compareSpecs)
+        .map((priority) => provided[priorities.indexOf(priority)]);
+}
+exports.preferredMediaTypes = preferredMediaTypes;

package/script/deps/deno.land/std@0.180.0/http/negotiation.js

@@ -0,0 +1,42 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acceptsLanguages = exports.acceptsEncodings = exports.accepts = void 0;
+/**
+ * Contains the functions {@linkcode accepts}, {@linkcode acceptsEncodings}, and
+ * {@linkcode acceptsLanguages} to provide content negotiation capabilities.
+ *
+ * @module
+ */
+const encoding_js_1 = require("./_negotiation/encoding.js");
+const language_js_1 = require("./_negotiation/language.js");
+const media_type_js_1 = require("./_negotiation/media_type.js");
+function accepts(request, ...types) {
+    const accept = request.headers.get("accept");
+    return types.length
+        ? accept ? (0, media_type_js_1.preferredMediaTypes)(accept, types)[0] : types[0]
+        : accept
+            ? (0, media_type_js_1.preferredMediaTypes)(accept)
+            : ["*/*"];
+}
+exports.accepts = accepts;
+function acceptsEncodings(request, ...encodings) {
+    const acceptEncoding = request.headers.get("accept-encoding");
+    return encodings.length
+        ? acceptEncoding
+            ? (0, encoding_js_1.preferredEncodings)(acceptEncoding, encodings)[0]
+            : encodings[0]
+        : acceptEncoding
+            ? (0, encoding_js_1.preferredEncodings)(acceptEncoding)
+            : ["*"];
+}
+exports.acceptsEncodings = acceptsEncodings;
+function acceptsLanguages(request, ...langs) {
+    const acceptLanguage = request.headers.get("accept-language");
+    return langs.length
+        ? acceptLanguage ? (0, language_js_1.preferredLanguages)(acceptLanguage, langs)[0] : langs[0]
+        : acceptLanguage
+            ? (0, language_js_1.preferredLanguages)(acceptLanguage)
+            : ["*"];
+}
+exports.acceptsLanguages = acceptsLanguages;

package/script/deps/deno.land/std@0.180.0/media_types/_db.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = exports.types = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const mime_db_v1_52_0_js_1 = __importDefault(require("./vendor/mime-db.v1.52.0.js"));
+exports.db = mime_db_v1_52_0_js_1.default;
+const _util_js_1 = require("./_util.js");
+/** A map of the media type for a given extension */
+exports.types = new Map();
+/** Internal function to populate the maps based on the Mime DB. */
+(function populateMaps() {
+    const preference = ["nginx", "apache", undefined, "iana"];
+    for (const type of Object.keys(mime_db_v1_52_0_js_1.default)) {
+        const mime = mime_db_v1_52_0_js_1.default[type];
+        const exts = mime.extensions;
+        if (!exts || !exts.length) {
+            continue;
+        }
+        // @ts-ignore work around denoland/dnt#148
+        _util_js_1.extensions.set(type, exts);
+        for (const ext of exts) {
+            const current = exports.types.get(ext);
+            if (current) {
+                const from = preference.indexOf(mime_db_v1_52_0_js_1.default[current].source);
+                const to = preference.indexOf(mime.source);
+                if (current !== "application/octet-stream" &&
+                    (from > to ||
+                        // @ts-ignore work around denoland/dnt#148
+                        (from === to && current.startsWith("application/")))) {
+                    continue;
+                }
+            }
+            exports.types.set(ext, type);
+        }
+    }
+})();

package/script/deps/deno.land/std@0.180.0/media_types/_util.js

@@ -0,0 +1,132 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsEncoding = exports.isToken = exports.isIterator = exports.decode2331Encoding = exports.consumeMediaParam = exports.consumeValue = exports.consumeToken = exports.extensions = void 0;
+/** A map of extensions for a given media type. */
+exports.extensions = new Map();
+function consumeToken(v) {
+    const notPos = indexOf(v, isNotTokenChar);
+    if (notPos == -1) {
+        return [v, ""];
+    }
+    if (notPos == 0) {
+        return ["", v];
+    }
+    return [v.slice(0, notPos), v.slice(notPos)];
+}
+exports.consumeToken = consumeToken;
+function consumeValue(v) {
+    if (!v) {
+        return ["", v];
+    }
+    if (v[0] !== `"`) {
+        return consumeToken(v);
+    }
+    let value = "";
+    for (let i = 1; i < v.length; i++) {
+        const r = v[i];
+        if (r === `"`) {
+            return [value, v.slice(i + 1)];
+        }
+        if (r === "\\" && i + 1 < v.length && isTSpecial(v[i + 1])) {
+            value += v[i + 1];
+            i++;
+            continue;
+        }
+        if (r === "\r" || r === "\n") {
+            return ["", v];
+        }
+        value += v[i];
+    }
+    return ["", v];
+}
+exports.consumeValue = consumeValue;
+function consumeMediaParam(v) {
+    let rest = v.trimStart();
+    if (!rest.startsWith(";")) {
+        return ["", "", v];
+    }
+    rest = rest.slice(1);
+    rest = rest.trimStart();
+    let param;
+    [param, rest] = consumeToken(rest);
+    param = param.toLowerCase();
+    if (!param) {
+        return ["", "", v];
+    }
+    rest = rest.slice(1);
+    rest = rest.trimStart();
+    const [value, rest2] = consumeValue(rest);
+    if (value == "" && rest2 === rest) {
+        return ["", "", v];
+    }
+    rest = rest2;
+    return [param, value, rest];
+}
+exports.consumeMediaParam = consumeMediaParam;
+function decode2331Encoding(v) {
+    const sv = v.split(`'`, 3);
+    if (sv.length !== 3) {
+        return undefined;
+    }
+    const charset = sv[0].toLowerCase();
+    if (!charset) {
+        return undefined;
+    }
+    if (charset != "us-ascii" && charset != "utf-8") {
+        return undefined;
+    }
+    const encv = decodeURI(sv[2]);
+    if (!encv) {
+        return undefined;
+    }
+    return encv;
+}
+exports.decode2331Encoding = decode2331Encoding;
+function indexOf(s, fn) {
+    let i = -1;
+    for (const v of s) {
+        i++;
+        if (fn(v)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function isIterator(obj) {
+    if (obj == null) {
+        return false;
+    }
+    // deno-lint-ignore no-explicit-any
+    return typeof obj[Symbol.iterator] === "function";
+}
+exports.isIterator = isIterator;
+function isToken(s) {
+    if (!s) {
+        return false;
+    }
+    return indexOf(s, isNotTokenChar) < 0;
+}
+exports.isToken = isToken;
+function isNotTokenChar(r) {
+    return !isTokenChar(r);
+}
+function isTokenChar(r) {
+    const code = r.charCodeAt(0);
+    return code > 0x20 && code < 0x7f && !isTSpecial(r);
+}
+function isTSpecial(r) {
+    return `()<>@,;:\\"/[]?=`.includes(r[0]);
+}
+const CHAR_CODE_SPACE = " ".charCodeAt(0);
+const CHAR_CODE_TILDE = "~".charCodeAt(0);
+function needsEncoding(s) {
+    for (const b of s) {
+        const charCode = b.charCodeAt(0);
+        if ((charCode < CHAR_CODE_SPACE || charCode > CHAR_CODE_TILDE) && b !== "\t") {
+            return true;
+        }
+    }
+    return false;
+}
+exports.needsEncoding = needsEncoding;

package/script/deps/deno.land/std@0.180.0/media_types/content_type.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentType = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const parse_media_type_js_1 = require("./parse_media_type.js");
+const type_by_extension_js_1 = require("./type_by_extension.js");
+const get_charset_js_1 = require("./get_charset.js");
+const format_media_type_js_1 = require("./format_media_type.js");
+/**
+ * Given an extension or media type, return a full `Content-Type` or
+ * `Content-Disposition` header value.
+ *
+ * The function will treat the `extensionOrType` as a media type when it
+ * contains a `/`, otherwise it will process it as an extension, with or without
+ * the leading `.`.
+ *
+ * Returns `undefined` if unable to resolve the media type.
+ *
+ * > Note: a side effect of `deno/x/media_types` was that you could pass a file
+ * > name (e.g. `file.json`) and it would return the content type. This behavior
+ * > is intentionally not supported here. If you want to get an extension for a
+ * > file name, use `extname()` from `std/path/mod.ts` to determine the
+ * > extension and pass it here.
+ *
+ * @example
+ * ```ts
+ * import { contentType } from "https://deno.land/std@$STD_VERSION/media_types/content_type.ts";
+ *
+ * contentType(".json"); // `application/json; charset=UTF-8`
+ * contentType("text/html"); // `text/html; charset=UTF-8`
+ * contentType("text/html; charset=UTF-8"); // `text/html; charset=UTF-8`
+ * contentType("txt"); // `text/plain; charset=UTF-8`
+ * contentType("foo"); // undefined
+ * contentType("file.json"); // undefined
+ * ```
+ */
+function contentType(extensionOrType) {
+    try {
+        const [mediaType, params = {}] = extensionOrType.includes("/")
+            ? (0, parse_media_type_js_1.parseMediaType)(extensionOrType)
+            : [(0, type_by_extension_js_1.typeByExtension)(extensionOrType), undefined];
+        if (!mediaType) {
+            return undefined;
+        }
+        if (!("charset" in params)) {
+            const charset = (0, get_charset_js_1.getCharset)(mediaType);
+            if (charset) {
+                params.charset = charset;
+            }
+        }
+        return (0, format_media_type_js_1.formatMediaType)(mediaType, params);
+    }
+    catch {
+        // just swallow returning undefined
+    }
+    return undefined;
+}
+exports.contentType = contentType;

package/script/deps/deno.land/std@0.180.0/media_types/extension.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extension = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const extensions_by_type_js_1 = require("./extensions_by_type.js");
+/**
+ * For a given media type, return the most relevant extension, or `undefined`
+ * if no extension can be found.
+ *
+ * Extensions are returned without a leading `.`.
+ *
+ * @example
+ * ```ts
+ * import { extension } from "https://deno.land/std@$STD_VERSION/media_types/extension.ts";
+ *
+ * extension("text/plain"); // `txt`
+ * extension("application/json"); // `json`
+ * extension("text/html; charset=UTF-8"); // `html`
+ * extension("application/foo"); // undefined
+ * ```
+ */
+function extension(type) {
+    const exts = (0, extensions_by_type_js_1.extensionsByType)(type);
+    if (exts) {
+        return exts[0];
+    }
+    return undefined;
+}
+exports.extension = extension;

package/script/deps/deno.land/std@0.180.0/media_types/extensions_by_type.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionsByType = exports.extensions = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const parse_media_type_js_1 = require("./parse_media_type.js");
+const _util_js_1 = require("./_util.js");
+Object.defineProperty(exports, "extensions", { enumerable: true, get: function () { return _util_js_1.extensions; } });
+/**
+ * Returns the extensions known to be associated with the media type `type`.
+ * The returned extensions will each begin with a leading dot, as in `.html`.
+ *
+ * When `type` has no associated extensions, the function returns `undefined`.
+ *
+ * Extensions are returned without a leading `.`.
+ *
+ * @example
+ * ```ts
+ * import { extensionsByType } from "https://deno.land/std@$STD_VERSION/media_types/extensions_by_type.ts";
+ *
+ * extensionsByType("application/json"); // ["json", "map"]
+ * extensionsByType("text/html; charset=UTF-8"); // ["html", "htm", "shtml"]
+ * extensionsByType("application/foo"); // undefined
+ * ```
+ */
+function extensionsByType(type) {
+    try {
+        const [mediaType] = (0, parse_media_type_js_1.parseMediaType)(type);
+        return _util_js_1.extensions.get(mediaType);
+    }
+    catch {
+        // just swallow errors, returning undefined
+    }
+}
+exports.extensionsByType = extensionsByType;

package/script/deps/deno.land/std@0.180.0/media_types/format_media_type.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMediaType = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const _util_js_1 = require("./_util.js");
+/** Serializes the media type and the optional parameters as a media type
+ * conforming to RFC 2045 and RFC 2616.
+ *
+ * The type and parameter names are written in lower-case.
+ *
+ * When any of the arguments results in a standard violation then the return
+ * value will be an empty string (`""`).
+ *
+ * @example
+ * ```ts
+ * import { formatMediaType } from "https://deno.land/std@$STD_VERSION/media_types/format_media_type.ts";
+ *
+ * formatMediaType("text/plain", { charset: "UTF-8" }); // `text/plain; charset=UTF-8`
+ * ```
+ */
+function formatMediaType(type, param) {
+    let b = "";
+    const [major, sub] = type.split("/");
+    if (!sub) {
+        if (!(0, _util_js_1.isToken)(type)) {
+            return "";
+        }
+        b += type.toLowerCase();
+    }
+    else {
+        if (!(0, _util_js_1.isToken)(major) || !(0, _util_js_1.isToken)(sub)) {
+            return "";
+        }
+        b += `${major.toLowerCase()}/${sub.toLowerCase()}`;
+    }
+    if (param) {
+        param = (0, _util_js_1.isIterator)(param) ? Object.fromEntries(param) : param;
+        const attrs = Object.keys(param);
+        attrs.sort();
+        for (const attribute of attrs) {
+            if (!(0, _util_js_1.isToken)(attribute)) {
+                return "";
+            }
+            const value = param[attribute];
+            b += `; ${attribute.toLowerCase()}`;
+            const needEnc = (0, _util_js_1.needsEncoding)(value);
+            if (needEnc) {
+                b += "*";
+            }
+            b += "=";
+            if (needEnc) {
+                b += `utf-8''${encodeURIComponent(value)}`;
+                continue;
+            }
+            if ((0, _util_js_1.isToken)(value)) {
+                b += value;
+                continue;
+            }
+            b += `"${value.replace(/["\\]/gi, (m) => `\\${m}`)}"`;
+        }
+    }
+    return b;
+}
+exports.formatMediaType = formatMediaType;

package/script/deps/deno.land/std@0.180.0/media_types/get_charset.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCharset = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const parse_media_type_js_1 = require("./parse_media_type.js");
+const _db_js_1 = require("./_db.js");
+/**
+ * Given a media type or header value, identify the encoding charset. If the
+ * charset cannot be determined, the function returns `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { getCharset } from "https://deno.land/std@$STD_VERSION/media_types/get_charset.ts";
+ *
+ * getCharset("text/plain"); // `UTF-8`
+ * getCharset("application/foo"); // undefined
+ * getCharset("application/news-checkgroups"); // `US-ASCII`
+ * getCharset("application/news-checkgroups; charset=UTF-8"); // `UTF-8`
+ * ```
+ */
+function getCharset(type) {
+    try {
+        const [mediaType, params] = (0, parse_media_type_js_1.parseMediaType)(type);
+        if (params && params["charset"]) {
+            return params["charset"];
+        }
+        const entry = _db_js_1.db[mediaType];
+        if (entry && entry.charset) {
+            return entry.charset;
+        }
+        if (mediaType.startsWith("text/")) {
+            return "UTF-8";
+        }
+    }
+    catch {
+        // just swallow errors, returning undefined
+    }
+    return undefined;
+}
+exports.getCharset = getCharset;

package/script/deps/deno.land/std@0.180.0/media_types/mod.js

@@ -0,0 +1,38 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Utility functions for media types (MIME types).
+ *
+ * This API is inspired by the GoLang [`mime`](https://pkg.go.dev/mime) package
+ * and [jshttp/mime-types](https://github.com/jshttp/mime-types), and is
+ * designed to integrate and improve the APIs from
+ * [deno.land/x/media_types](https://deno.land/x/media_types).
+ *
+ * The `vendor` folder contains copy of the
+ * [jshttp/mime-db](https://github.com/jshttp/mime-types) `db.json` file along
+ * with its license.
+ *
+ * @module
+ */
+__exportStar(require("./content_type.js"), exports);
+__exportStar(require("./extension.js"), exports);
+__exportStar(require("./extensions_by_type.js"), exports);
+__exportStar(require("./format_media_type.js"), exports);
+__exportStar(require("./get_charset.js"), exports);
+__exportStar(require("./parse_media_type.js"), exports);
+__exportStar(require("./type_by_extension.js"), exports);