@httpland/compression-middleware 1.0.0-beta.1

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

@@ -0,0 +1,36 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * Contains the functions {@linkcode accepts}, {@linkcode acceptsEncodings}, and
+ * {@linkcode acceptsLanguages} to provide content negotiation capabilities.
+ *
+ * @module
+ */
+import { preferredEncodings } from "./_negotiation/encoding.js";
+import { preferredLanguages } from "./_negotiation/language.js";
+import { preferredMediaTypes } from "./_negotiation/media_type.js";
+export function accepts(request, ...types) {
+    const accept = request.headers.get("accept");
+    return types.length
+        ? accept ? preferredMediaTypes(accept, types)[0] : types[0]
+        : accept
+            ? preferredMediaTypes(accept)
+            : ["*/*"];
+}
+export function acceptsEncodings(request, ...encodings) {
+    const acceptEncoding = request.headers.get("accept-encoding");
+    return encodings.length
+        ? acceptEncoding
+            ? preferredEncodings(acceptEncoding, encodings)[0]
+            : encodings[0]
+        : acceptEncoding
+            ? preferredEncodings(acceptEncoding)
+            : ["*"];
+}
+export function acceptsLanguages(request, ...langs) {
+    const acceptLanguage = request.headers.get("accept-language");
+    return langs.length
+        ? acceptLanguage ? preferredLanguages(acceptLanguage, langs)[0] : langs[0]
+        : acceptLanguage
+            ? preferredLanguages(acceptLanguage)
+            : ["*"];
+}

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

@@ -0,0 +1,33 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import db from "./vendor/mime-db.v1.52.0.js";
+import { extensions } from "./_util.js";
+/** A map of the media type for a given extension */
+export const 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(db)) {
+        const mime = db[type];
+        const exts = mime.extensions;
+        if (!exts || !exts.length) {
+            continue;
+        }
+        // @ts-ignore work around denoland/dnt#148
+        extensions.set(type, exts);
+        for (const ext of exts) {
+            const current = types.get(ext);
+            if (current) {
+                const from = preference.indexOf(db[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;
+                }
+            }
+            types.set(ext, type);
+        }
+    }
+})();
+export { db };

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

@@ -0,0 +1,122 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/** A map of extensions for a given media type. */
+export const extensions = new Map();
+export 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)];
+}
+export 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];
+}
+export 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];
+}
+export 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;
+}
+function indexOf(s, fn) {
+    let i = -1;
+    for (const v of s) {
+        i++;
+        if (fn(v)) {
+            return i;
+        }
+    }
+    return -1;
+}
+export function isIterator(obj) {
+    if (obj == null) {
+        return false;
+    }
+    // deno-lint-ignore no-explicit-any
+    return typeof obj[Symbol.iterator] === "function";
+}
+export function isToken(s) {
+    if (!s) {
+        return false;
+    }
+    return indexOf(s, isNotTokenChar) < 0;
+}
+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);
+export 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;
+}

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

@@ -0,0 +1,54 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { parseMediaType } from "./parse_media_type.js";
+import { typeByExtension } from "./type_by_extension.js";
+import { getCharset } from "./get_charset.js";
+import { formatMediaType } from "./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
+ * ```
+ */
+export function contentType(extensionOrType) {
+    try {
+        const [mediaType, params = {}] = extensionOrType.includes("/")
+            ? parseMediaType(extensionOrType)
+            : [typeByExtension(extensionOrType), undefined];
+        if (!mediaType) {
+            return undefined;
+        }
+        if (!("charset" in params)) {
+            const charset = getCharset(mediaType);
+            if (charset) {
+                params.charset = charset;
+            }
+        }
+        return formatMediaType(mediaType, params);
+    }
+    catch {
+        // just swallow returning undefined
+    }
+    return undefined;
+}

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

@@ -0,0 +1,25 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { extensionsByType } from "./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
+ * ```
+ */
+export function extension(type) {
+    const exts = extensionsByType(type);
+    if (exts) {
+        return exts[0];
+    }
+    return undefined;
+}

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

@@ -0,0 +1,30 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { parseMediaType } from "./parse_media_type.js";
+import { extensions } from "./_util.js";
+export { 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
+ * ```
+ */
+export function extensionsByType(type) {
+    try {
+        const [mediaType] = parseMediaType(type);
+        return extensions.get(mediaType);
+    }
+    catch {
+        // just swallow errors, returning undefined
+    }
+}

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

@@ -0,0 +1,60 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { isIterator, isToken, needsEncoding } from "./_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`
+ * ```
+ */
+export function formatMediaType(type, param) {
+    let b = "";
+    const [major, sub] = type.split("/");
+    if (!sub) {
+        if (!isToken(type)) {
+            return "";
+        }
+        b += type.toLowerCase();
+    }
+    else {
+        if (!isToken(major) || !isToken(sub)) {
+            return "";
+        }
+        b += `${major.toLowerCase()}/${sub.toLowerCase()}`;
+    }
+    if (param) {
+        param = isIterator(param) ? Object.fromEntries(param) : param;
+        const attrs = Object.keys(param);
+        attrs.sort();
+        for (const attribute of attrs) {
+            if (!isToken(attribute)) {
+                return "";
+            }
+            const value = param[attribute];
+            b += `; ${attribute.toLowerCase()}`;
+            const needEnc = needsEncoding(value);
+            if (needEnc) {
+                b += "*";
+            }
+            b += "=";
+            if (needEnc) {
+                b += `utf-8''${encodeURIComponent(value)}`;
+                continue;
+            }
+            if (isToken(value)) {
+                b += value;
+                continue;
+            }
+            b += `"${value.replace(/["\\]/gi, (m) => `\\${m}`)}"`;
+        }
+    }
+    return b;
+}

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

@@ -0,0 +1,36 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { parseMediaType } from "./parse_media_type.js";
+import { db } from "./_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`
+ * ```
+ */
+export function getCharset(type) {
+    try {
+        const [mediaType, params] = parseMediaType(type);
+        if (params && params["charset"]) {
+            return params["charset"];
+        }
+        const entry = db[mediaType];
+        if (entry && entry.charset) {
+            return entry.charset;
+        }
+        if (mediaType.startsWith("text/")) {
+            return "UTF-8";
+        }
+    }
+    catch {
+        // just swallow errors, returning undefined
+    }
+    return undefined;
+}

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

@@ -0,0 +1,22 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/** 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
+ */
+export * from "./content_type.js";
+export * from "./extension.js";
+export * from "./extensions_by_type.js";
+export * from "./format_media_type.js";
+export * from "./get_charset.js";
+export * from "./parse_media_type.js";
+export * from "./type_by_extension.js";

package/esm/deps/deno.land/std@0.180.0/media_types/parse_media_type.js

@@ -0,0 +1,121 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { consumeMediaParam, decode2331Encoding } from "./_util.js";
+/**
+ * Parses the media type and any optional parameters, per
+ * [RFC 1521](https://datatracker.ietf.org/doc/html/rfc1521). Media types are
+ * the values in `Content-Type` and `Content-Disposition` headers. On success
+ * the function returns a tuple where the first element is the media type and
+ * the second element is the optional parameters or `undefined` if there are
+ * none.
+ *
+ * The function will throw if the parsed value is invalid.
+ *
+ * The returned media type will be normalized to be lower case, and returned
+ * params keys will be normalized to lower case, but preserves the casing of
+ * the value.
+ *
+ * @example
+ * ```ts
+ * import { parseMediaType } from "https://deno.land/std@$STD_VERSION/media_types/parse_media_type.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertEquals(
+ *   parseMediaType("application/JSON"),
+ *   [
+ *     "application/json",
+ *     undefined
+ *   ]
+ * );
+ *
+ * assertEquals(
+ *   parseMediaType("text/html; charset=UTF-8"),
+ *   [
+ *     "application/json",
+ *     { charset: "UTF-8" },
+ *   ]
+ * );
+ * ```
+ */
+export function parseMediaType(v) {
+    const [base] = v.split(";");
+    const mediaType = base.toLowerCase().trim();
+    const params = {};
+    // Map of base parameter name -> parameter name -> value
+    // for parameters containing a '*' character.
+    const continuation = new Map();
+    v = v.slice(base.length);
+    while (v.length) {
+        v = v.trimStart();
+        if (v.length === 0) {
+            break;
+        }
+        const [key, value, rest] = consumeMediaParam(v);
+        if (!key) {
+            if (rest.trim() === ";") {
+                // ignore trailing semicolons
+                break;
+            }
+            throw new TypeError("Invalid media parameter.");
+        }
+        let pmap = params;
+        const [baseName, rest2] = key.split("*");
+        if (baseName && rest2 != null) {
+            if (!continuation.has(baseName)) {
+                continuation.set(baseName, {});
+            }
+            pmap = continuation.get(baseName);
+        }
+        if (key in pmap) {
+            throw new TypeError("Duplicate key parsed.");
+        }
+        pmap[key] = value;
+        v = rest;
+    }
+    // Stitch together any continuations or things with stars
+    // (i.e. RFC 2231 things with stars: "foo*0" or "foo*")
+    let str = "";
+    for (const [key, pieceMap] of continuation) {
+        const singlePartKey = `${key}*`;
+        const v = pieceMap[singlePartKey];
+        if (v) {
+            const decv = decode2331Encoding(v);
+            if (decv) {
+                params[key] = decv;
+            }
+            continue;
+        }
+        str = "";
+        let valid = false;
+        for (let n = 0;; n++) {
+            const simplePart = `${key}*${n}`;
+            let v = pieceMap[simplePart];
+            if (v) {
+                valid = true;
+                str += v;
+                continue;
+            }
+            const encodedPart = `${simplePart}*`;
+            v = pieceMap[encodedPart];
+            if (!v) {
+                break;
+            }
+            valid = true;
+            if (n === 0) {
+                const decv = decode2331Encoding(v);
+                if (decv) {
+                    str += decv;
+                }
+            }
+            else {
+                const decv = decodeURI(v);
+                str += decv;
+            }
+        }
+        if (valid) {
+            params[key] = str;
+        }
+    }
+    return Object.keys(params).length
+        ? [mediaType, params]
+        : [mediaType, undefined];
+}

package/esm/deps/deno.land/std@0.180.0/media_types/type_by_extension.js

@@ -0,0 +1,23 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { types } from "./_db.js";
+/**
+ * Returns the media type associated with the file extension. Values are
+ * normalized to lower case and matched irrespective of a leading `.`.
+ *
+ * When `extension` has no associated type, the function returns `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { typeByExtension } from "https://deno.land/std@$STD_VERSION/media_types/type_by_extension.ts";
+ *
+ * typeByExtension("js"); // `application/json`
+ * typeByExtension(".HTML"); // `text/html`
+ * typeByExtension("foo"); // undefined
+ * typeByExtension("file.json"); // undefined
+ * ```
+ */
+export function typeByExtension(extension) {
+    extension = extension.startsWith(".") ? extension.slice(1) : extension;
+    // @ts-ignore workaround around denoland/dnt#148
+    return types.get(extension.toLowerCase());
+}