@httpland/compression-middleware 1.0.0-beta.1

package/esm/deps/deno.land/x/vary@1.0.0/mod.js

@@ -0,0 +1,108 @@
+/*!
+ * Based on https://github.com/jshttp/vary/blob/master/index.js
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * Copyright(c) 2020 Henry Zhuang
+ * MIT Licensed
+ */
+/**
+ * RegExp to match field-name in RFC 7230 sec 3.2
+ *
+ * field-name    = token
+ * token         = 1*tchar
+ * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+ *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+ *               / DIGIT / ALPHA
+ *               ; any VCHAR, except delimiters
+ */
+const FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/**
+ * Append a field to a vary header.
+ *
+ * @param {String} header
+ * @param {String|Array} field
+ * @return {String}
+ * @public
+ */
+export function append(header, field) {
+    // if (typeof header !== 'string') {
+    //   throw new TypeError('header argument is required')
+    // }
+    // if (!field) {
+    //   throw new TypeError('field argument is required')
+    // }
+    // existing, unspecified vary
+    if (header === "*") {
+        return header;
+    }
+    // get fields array
+    const fields = !Array.isArray(field) ? parse(String(field)) : field;
+    // assert on invalid field names
+    for (let j = 0; j < fields.length; j++) {
+        if (!FIELD_NAME_REGEXP.test(fields[j])) {
+            throw new TypeError(`field argument contains an invalid header name \`${fields[j]}\``);
+        }
+    }
+    // enumerate current values
+    let val = header;
+    const vals = parse(header.toLowerCase());
+    // unspecified vary
+    if (fields.indexOf("*") !== -1 || vals.indexOf("*") !== -1) {
+        return "*";
+    }
+    for (let i = 0; i < fields.length; i++) {
+        const fld = fields[i].toLowerCase();
+        // append value (case-preserving)
+        if (vals.indexOf(fld) === -1) {
+            vals.push(fld);
+            val = val ? val + ", " + fields[i] : fields[i];
+        }
+    }
+    return val;
+}
+/**
+ * Parse a vary header into an array.
+ *
+ * @param {String} header
+ * @return {Array}
+ * @private
+ */
+function parse(header) {
+    let end = 0;
+    const list = [];
+    let start = 0;
+    // gather tokens
+    for (let i = 0, len = header.length; i < len; i++) {
+        switch (header.charCodeAt(i)) {
+            case 0x20: /*   */
+                if (start === end) {
+                    start = end = i + 1;
+                }
+                break;
+            case 0x2c: /* , */
+                list.push(header.substring(start, end));
+                start = end = i + 1;
+                break;
+            default:
+                end = i + 1;
+                break;
+        }
+    }
+    // final token
+    list.push(header.substring(start, end));
+    return list;
+}
+/**
+ * Mark that a request is varied on a header field.
+ *
+ * @param {Headers} header
+ * @param {String|Array} field
+ * @public
+ */
+export function vary(header, field) {
+    // get existing header
+    let val = header.get("vary") || "";
+    // set new header
+    if ((val = append(val, field))) {
+        header.set("vary", val);
+    }
+}

package/esm/deps.js

@@ -0,0 +1,8 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export { CachingHeader, ContentNegotiationHeader, RepresentationHeader, } from "@httpland/http-utils";
+export { acceptsEncodings } from "./deps/deno.land/std@0.180.0/http/negotiation.js";
+export { parseMediaType } from "./deps/deno.land/std@0.180.0/media_types/mod.js";
+export { isNull } from "isxx";
+export { default as compressible } from "compressible";
+export { vary } from "./deps/deno.land/x/vary@1.0.0/mod.js";

package/esm/encoders/deflate.js

@@ -0,0 +1,11 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { Format } from "./utils.js";
+function encodeDeflate(stream) {
+    return stream.pipeThrough(new CompressionStream(Format.Deflate));
+}
+/** Encoder for `deflate` */
+export const Deflate = {
+    encoding: Format.Deflate,
+    encode: encodeDeflate,
+};

package/esm/encoders/gzip.js

@@ -0,0 +1,11 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { Format } from "./utils.js";
+function encodeGzip(stream) {
+    return stream.pipeThrough(new CompressionStream(Format.Gzip));
+}
+/** Encoder for `gzip` */
+export const Gzip = {
+    encoding: Format.Gzip,
+    encode: encodeGzip,
+};

package/esm/encoders/utils.js

@@ -0,0 +1,7 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export var Format;
+(function (Format) {
+    Format["Gzip"] = "gzip";
+    Format["Deflate"] = "deflate";
+})(Format || (Format = {}));

package/esm/middleware.js

@@ -0,0 +1,55 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { acceptsEncodings, ContentNegotiationHeader, vary, } from "./deps.js";
+import { withContentEncoding } from "./transform.js";
+import { Gzip } from "./encoders/gzip.js";
+import { Deflate } from "./encoders/deflate.js";
+const DefaultEncoders = [Gzip, Deflate];
+/** Create HTTP content compression middleware.
+ *
+ * @example
+ * ```ts
+ * import { compression } from "https://deno.land/x/compression_middleware@$VERSION/mod.ts";
+ * import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+ *
+ * const middleware = compression();
+ * const request = new Request("test:", {
+ *   headers: {
+ *     "accept-encoding": "deflate;q=0.5, gzip;q=1.0, deflate-raw;q=0.3",
+ *   },
+ * });
+ *
+ * const response = await middleware(
+ *   request,
+ *   () => new Response("<body>"),
+ * );
+ *
+ * assertEquals(await response.text(), "<gzip:body>");
+ * assertEquals(response.headers.get("content-encoding"), "gzip");
+ * ```
+ */
+export function compression(encoders) {
+    const encodingMap = {
+        ...fromEncoders(DefaultEncoders),
+        ...Array.isArray(encoders) ? fromEncoders(encoders) : encoders,
+    };
+    const encodings = Object.keys(encodingMap);
+    return async (request, next) => {
+        const encoding = acceptsEncodings(request, ...encodings, IDENTITY);
+        const response = await next(request);
+        vary(response.headers, ContentNegotiationHeader.AcceptEncoding);
+        if (!encoding || encoding === IDENTITY)
+            return response;
+        const encode = encodingMap[encoding];
+        if (!encode)
+            return response;
+        return withContentEncoding(response, { encode, encoding });
+    };
+}
+export function flat(encoder) {
+    return [encoder.encoding, encoder.encode];
+}
+export function fromEncoders(encoders) {
+    return Object.fromEntries(encoders.map(flat));
+}
+const IDENTITY = "identity";

package/esm/mod.js

@@ -0,0 +1,3 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export { compression } from "./middleware.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/transform.js

@@ -0,0 +1,23 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { CachingHeader, compressible, isNull, parseMediaType, RepresentationHeader, } from "./deps.js";
+import { isNoTransform, reCalcContentLength } from "./utils.js";
+/** Response with `Content-Encoding` header. */
+export async function withContentEncoding(response, context) {
+    const contentType = response.headers.get(RepresentationHeader.ContentType);
+    const cacheControl = response.headers.get(CachingHeader.CacheControl);
+    if (isNull(contentType) ||
+        response.headers.has(RepresentationHeader.ContentEncoding) ||
+        !response.body ||
+        response.bodyUsed ||
+        (!isNull(cacheControl) && isNoTransform(cacheControl)))
+        return response;
+    const [mediaType] = parseMediaType(contentType);
+    const isCompressible = compressible(mediaType);
+    if (!isCompressible)
+        return response;
+    const bodyInit = await context.encode(response.body);
+    const newResponse = await reCalcContentLength(new Response(bodyInit, response));
+    newResponse.headers.set(RepresentationHeader.ContentEncoding, context.encoding);
+    return newResponse;
+}

package/esm/types.js

@@ -0,0 +1,3 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export {};

package/esm/utils.js

@@ -0,0 +1,19 @@
+// Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { RepresentationHeader } from "./deps.js";
+const ReNoTransform = /(?:^|,)\s*?no-transform\s*?(?:,|$)/;
+export function isNoTransform(input) {
+    return ReNoTransform.test(input);
+}
+export async function reCalcContentLength(response) {
+    if (response.bodyUsed ||
+        !response.headers.has(RepresentationHeader.ContentLength))
+        return response;
+    const length = await response
+        .clone()
+        .arrayBuffer()
+        .then((buffer) => buffer.byteLength)
+        .then(String);
+    response.headers.set(RepresentationHeader.ContentLength, length);
+    return response;
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "module": "./esm/mod.js",
+  "main": "./script/mod.js",
+  "types": "./types/mod.d.ts",
+  "name": "@httpland/compression-middleware",
+  "version": "1.0.0-beta.1",
+  "description": "HTTP compression middleware",
+  "keywords": [
+    "http",
+    "middleware",
+    "header",
+    "compression",
+    "compress",
+    "gzip",
+    "deflate",
+    "encoding",
+    "encoder",
+    "fetch-api"
+  ],
+  "engines": {
+    "node": "^18.x"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/httpland/compression-middleware",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/httpland/compression-middleware.git"
+  },
+  "bugs": {
+    "url": "https://github.com/httpland/compression-middleware/issues"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/mod.d.ts",
+        "default": "./esm/mod.js"
+      },
+      "require": {
+        "types": "./types/mod.d.ts",
+        "default": "./script/mod.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@httpland/http-middleware": "1.0.0",
+    "@httpland/http-utils": "1.0.0-beta.13",
+    "compressible": "2.0.18",
+    "isxx": "1.0.0-beta.24"
+  }
+}

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

@@ -0,0 +1,45 @@
+"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.isQuality = exports.compareSpecs = void 0;
+function compareSpecs(a, b) {
+    return (b.q - a.q ||
+        (b.s ?? 0) - (a.s ?? 0) ||
+        (a.o ?? 0) - (b.o ?? 0) ||
+        a.i - b.i ||
+        0);
+}
+exports.compareSpecs = compareSpecs;
+function isQuality(spec) {
+    return spec.q > 0;
+}
+exports.isQuality = isQuality;

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

@@ -0,0 +1,125 @@
+"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.preferredEncodings = void 0;
+const common_js_1 = require("./common.js");
+const simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
+function parseEncoding(str, i) {
+    const match = simpleEncodingRegExp.exec(str);
+    if (!match) {
+        return undefined;
+    }
+    const encoding = match[1];
+    let q = 1;
+    if (match[2]) {
+        const params = match[2].split(";");
+        for (const param of params) {
+            const p = param.trim().split("=");
+            if (p[0] === "q") {
+                q = parseFloat(p[1]);
+                break;
+            }
+        }
+    }
+    return { encoding, q, i };
+}
+function specify(encoding, spec, i = -1) {
+    if (!spec.encoding) {
+        return;
+    }
+    let s = 0;
+    if (spec.encoding.toLocaleLowerCase() === encoding.toLocaleLowerCase()) {
+        s = 1;
+    }
+    else if (spec.encoding !== "*") {
+        return;
+    }
+    return {
+        i,
+        o: spec.i,
+        q: spec.q,
+        s,
+    };
+}
+function parseAcceptEncoding(accept) {
+    const accepts = accept.split(",");
+    const parsedAccepts = [];
+    let hasIdentity = false;
+    let minQuality = 1;
+    for (let i = 0; i < accepts.length; i++) {
+        const encoding = parseEncoding(accepts[i].trim(), i);
+        if (encoding) {
+            parsedAccepts.push(encoding);
+            hasIdentity = hasIdentity || !!specify("identity", encoding);
+            minQuality = Math.min(minQuality, encoding.q || 1);
+        }
+    }
+    if (!hasIdentity) {
+        parsedAccepts.push({
+            encoding: "identity",
+            q: minQuality,
+            i: accepts.length - 1,
+        });
+    }
+    return parsedAccepts;
+}
+function getEncodingPriority(encoding, accepted, index) {
+    let priority = { o: -1, q: 0, s: 0, i: 0 };
+    for (const s of accepted) {
+        const spec = specify(encoding, s, index);
+        if (spec &&
+            (priority.s - spec.s || priority.q - spec.q ||
+                priority.o - spec.o) <
+                0) {
+            priority = spec;
+        }
+    }
+    return priority;
+}
+/** Given an `Accept-Encoding` string, parse out the encoding returning a
+ * negotiated encoding based on the `provided` encodings otherwise just a
+ * prioritized array of encodings. */
+function preferredEncodings(accept, provided) {
+    const accepts = parseAcceptEncoding(accept);
+    if (!provided) {
+        return accepts
+            .filter(common_js_1.isQuality)
+            .sort(common_js_1.compareSpecs)
+            .map((spec) => spec.encoding);
+    }
+    const priorities = provided.map((type, index) => getEncodingPriority(type, accepts, index));
+    return priorities
+        .filter(common_js_1.isQuality)
+        .sort(common_js_1.compareSpecs)
+        .map((priority) => provided[priorities.indexOf(priority)]);
+}
+exports.preferredEncodings = preferredEncodings;

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

@@ -0,0 +1,114 @@
+"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.preferredLanguages = void 0;
+const common_js_1 = require("./common.js");
+const SIMPLE_LANGUAGE_REGEXP = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
+function parseLanguage(str, i) {
+    const match = SIMPLE_LANGUAGE_REGEXP.exec(str);
+    if (!match) {
+        return undefined;
+    }
+    const [, prefix, suffix] = match;
+    const full = suffix ? `${prefix}-${suffix}` : prefix;
+    let q = 1;
+    if (match[3]) {
+        const params = match[3].split(";");
+        for (const param of params) {
+            const [key, value] = param.trim().split("=");
+            if (key === "q") {
+                q = parseFloat(value);
+                break;
+            }
+        }
+    }
+    return { prefix, suffix, full, q, i };
+}
+function parseAcceptLanguage(accept) {
+    const accepts = accept.split(",");
+    const result = [];
+    for (let i = 0; i < accepts.length; i++) {
+        const language = parseLanguage(accepts[i].trim(), i);
+        if (language) {
+            result.push(language);
+        }
+    }
+    return result;
+}
+function specify(language, spec, i) {
+    const p = parseLanguage(language, i);
+    if (!p) {
+        return undefined;
+    }
+    let s = 0;
+    if (spec.full.toLowerCase() === p.full.toLowerCase()) {
+        s |= 4;
+    }
+    else if (spec.prefix.toLowerCase() === p.prefix.toLowerCase()) {
+        s |= 2;
+    }
+    else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) {
+        s |= 1;
+    }
+    else if (spec.full !== "*") {
+        return;
+    }
+    return { i, o: spec.i, q: spec.q, s };
+}
+function getLanguagePriority(language, accepted, index) {
+    let priority = { i: -1, o: -1, q: 0, s: 0 };
+    for (const accepts of accepted) {
+        const spec = specify(language, accepts, index);
+        if (spec &&
+            ((priority.s ?? 0) - (spec.s ?? 0) || priority.q - spec.q ||
+                (priority.o ?? 0) - (spec.o ?? 0)) < 0) {
+            priority = spec;
+        }
+    }
+    return priority;
+}
+function preferredLanguages(accept = "*", provided) {
+    const accepts = parseAcceptLanguage(accept);
+    if (!provided) {
+        return accepts
+            .filter(common_js_1.isQuality)
+            .sort(common_js_1.compareSpecs)
+            .map((spec) => spec.full);
+    }
+    const priorities = provided
+        .map((type, index) => getLanguagePriority(type, accepts, index));
+    return priorities
+        .filter(common_js_1.isQuality)
+        .sort(common_js_1.compareSpecs)
+        .map((priority) => provided[priorities.indexOf(priority)]);
+}
+exports.preferredLanguages = preferredLanguages;