@zudojs/http 0.1.0 → 1.0.0

package/dist/httpMiddleware/pipeline/httpMiddleware.pipeline.js

@@ -0,0 +1,87 @@
+/**
+ * HTTP middleware pipeline implementation.
+ *
+ * @module httpMiddleware/pipeline
+ */
+import { use as registerUse, remove as registerRemove, setEnabled, has as registerHas, get as registerGet, list as registerList, } from "./httpPipeline.registration.js";
+import { isRegisteredMiddleware } from "./httpPipeline.helper.js";
+import { executePipeline } from "./httpPipeline.execution.js";
+export class HttpMiddlewarePipeline {
+    entries = [];
+    metadata;
+    onError;
+    sequence = 0;
+    constructor(options = {}) {
+        this.metadata = Object.freeze({
+            ...(options.metadata ?? {}),
+        });
+        this.onError = options.onError;
+        for (const middleware of options.middlewares ?? []) {
+            if (typeof middleware === "function") {
+                this.use(middleware);
+                continue;
+            }
+            /*
+             * Pre-registered middleware objects were previously dropped on the
+             * floor by a `typeof === "function"` filter, so a pipeline constructed
+             * from `list()` output lost every entry.
+             */
+            if (isRegisteredMiddleware(middleware)) {
+                this.entries.push({
+                    id: middleware.id,
+                    middleware: middleware.middleware,
+                    name: middleware.name,
+                    priority: middleware.priority,
+                    sequence: this.entries.length,
+                    enabled: middleware.enabled,
+                });
+            }
+        }
+    }
+    /* ------------------------------------------------------------------------ */
+    /* Registration                                                             */
+    /* ------------------------------------------------------------------------ */
+    use(middleware, options = {}) {
+        return registerUse(this.entries, middleware, () => `${options.name ?? "middleware"}-${++this.sequence}`, {
+            name: options.name,
+            priority: options.priority,
+            enabled: options.enabled,
+            metadata: options.metadata,
+            sequence: this.entries.length,
+        });
+    }
+    remove(id) {
+        return registerRemove(this.entries, id);
+    }
+    enable(id) {
+        return setEnabled(this.entries, id, true);
+    }
+    disable(id) {
+        return setEnabled(this.entries, id, false);
+    }
+    has(id) {
+        return registerHas(this.entries, id);
+    }
+    clear() {
+        this.entries.length = 0;
+    }
+    count() {
+        return this.entries.length;
+    }
+    get(id) {
+        return registerGet(this.entries, id);
+    }
+    list() {
+        return registerList(this.entries);
+    }
+    /* ------------------------------------------------------------------------ */
+    /* Execution                                                                */
+    /* ------------------------------------------------------------------------ */
+    async execute(request, response, options = {}) {
+        return executePipeline(this.entries, request, response, options, {
+            metadata: this.metadata,
+            onError: this.onError,
+        });
+    }
+}
+//# sourceMappingURL=httpMiddleware.pipeline.js.map

package/dist/httpMiddleware/pipeline/httpPipeline.execution.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Middleware pipeline execution logic.
+ *
+ * @module httpMiddleware/pipeline/execution
+ */
+import type { HttpMiddlewareErrorHandler, HttpMiddlewareState, InternalMiddleware } from "../httpMiddleware.type.js";
+import type { HttpRequestContext as RequestContext } from "../../httpRequest/httpRequest.context.js";
+import type { HttpResponseContext as ResponseContext } from "../../httpResponse/httpResponse.context.js";
+export interface PipelineExecutionOptions {
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly onError: HttpMiddlewareErrorHandler | undefined;
+}
+export declare function executePipeline(entries: InternalMiddleware[], request: RequestContext, response: ResponseContext, options: {
+    readonly state?: HttpMiddlewareState;
+    readonly signal?: AbortSignal;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+} | undefined, pipelineOptions: PipelineExecutionOptions): Promise<ResponseContext>;
+//# sourceMappingURL=httpPipeline.execution.d.ts.map

package/dist/httpMiddleware/pipeline/httpPipeline.execution.js

@@ -0,0 +1,97 @@
+/**
+ * Middleware pipeline execution logic.
+ *
+ * @module httpMiddleware/pipeline/execution
+ */
+import { HttpMiddlewareError, HttpMiddlewarePipelineError, } from "../httpMiddleware.error.js";
+import { normalizeResult } from "./httpPipeline.helper.js";
+import { list } from "./httpPipeline.registration.js";
+export async function executePipeline(entries, request, response, options = {}, pipelineOptions) {
+    const middlewares = list(entries);
+    const context = {
+        request,
+        response,
+        state: options.state ?? new Map(),
+        signal: options.signal ?? new AbortController().signal,
+        metadata: Object.freeze({
+            ...pipelineOptions.metadata,
+            ...(options.metadata ?? {}),
+        }),
+    };
+    const dispatch = async (index) => {
+        if (index >= middlewares.length) {
+            return response;
+        }
+        const entry = middlewares[index];
+        if (!entry) {
+            return response;
+        }
+        let nextCalls = 0;
+        const next = () => {
+            nextCalls += 1;
+            if (nextCalls > 1) {
+                /*
+                 * Calling `next()` twice runs the rest of the chain twice against one
+                 * request: duplicated side effects, and a second attempt to write a
+                 * response whose headers are already sent.
+                 */
+                return Promise.reject(new HttpMiddlewareError(`Middleware "${entry.name}" called next() more than once.`, {
+                    middlewareId: entry.id,
+                    middlewareName: entry.name,
+                }));
+            }
+            return dispatch(index + 1);
+        };
+        try {
+            const result = await entry.middleware(context, next);
+            return normalizeResult(result, response);
+        }
+        catch (error) {
+            /*
+             * Rethrow rather than returning the untouched response. Swallowing here
+             * let an inner failure resume the *outer* frames, so middleware that
+             * runs after `await next()` — access logging, CORS and security header
+             * emission, audit commits — executed against a response that was about
+             * to be discarded, and recorded the request as a success.
+             */
+            throw error instanceof HttpMiddlewareError
+                ? error
+                : new HttpMiddlewareError(`Middleware "${entry.name}" threw an error.`, {
+                    middlewareId: entry.id,
+                    middlewareName: entry.name,
+                    cause: error,
+                });
+        }
+    };
+    try {
+        return await dispatch(0);
+    }
+    catch (error) {
+        const middlewareError = error instanceof HttpMiddlewareError
+            ? error
+            : new HttpMiddlewareError("HTTP middleware pipeline failed.", {
+                cause: error,
+            });
+        if (pipelineOptions.onError) {
+            try {
+                /*
+                 * A successful `onError` is a genuine recovery and must be returned.
+                 * Previously every caught error was recorded before `onError` ran and
+                 * the recorded list was rethrown afterwards, so the handler's result
+                 * was always discarded and the option could never take effect.
+                 */
+                const errorResult = await pipelineOptions.onError(middlewareError.cause ?? error, context);
+                return normalizeResult(errorResult, response);
+            }
+            catch (handlerError) {
+                /* The handler's own failure is reported, not swallowed. */
+                throw new HttpMiddlewarePipelineError([
+                    middlewareError,
+                    new HttpMiddlewareError("HTTP middleware error handler threw an error.", { cause: handlerError }),
+                ]);
+            }
+        }
+        throw new HttpMiddlewarePipelineError([middlewareError]);
+    }
+}
+//# sourceMappingURL=httpPipeline.execution.js.map

package/dist/httpMiddleware/pipeline/httpPipeline.helper.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Internal helper functions for the middleware pipeline.
+ *
+ * @module httpMiddleware/pipeline/helpers
+ */
+import type { HttpMiddlewareContext, RegisteredMiddleware } from "../httpMiddleware.type.js";
+import { HttpRequestContext as RequestContext } from "../../httpRequest/httpRequest.context.js";
+import { HttpResponseContext as ResponseContext } from "../../httpResponse/httpResponse.context.js";
+export declare function nextResult(context: HttpMiddlewareContext, dispatch: (index: number) => Promise<ResponseContext>, index: number): Promise<ResponseContext>;
+/**
+ * Turns whatever a middleware returned into a response context.
+ *
+ * This is the single normalizer for the package. `builtin/helpers` used to
+ * carry a second, near-identical copy (`normalizeMiddlewareResult`); it has
+ * been deleted in favour of this one.
+ *
+ * @param result - The middleware's return value.
+ * @param fallback - The ambient response to continue with when the middleware
+ *   did not produce one of its own.
+ * @returns The response context to continue the pipeline with.
+ * @throws {HttpMiddlewareError} If no response context can be determined.
+ */
+export declare function normalizeResult(result: void | Response | RequestContext | ResponseContext | undefined, fallback?: ResponseContext): ResponseContext;
+/**
+ * Narrows a value to a response context.
+ *
+ * A web `Response` is explicitly excluded: it satisfies the structural test
+ * (`headers` is a prototype getter) but is a different type entirely, and
+ * treating one as a response context loses its headers.
+ */
+export declare function isResponseContext(value: unknown): value is ResponseContext;
+export declare function isRequestContext(value: unknown): value is RequestContext;
+export declare function isRegisteredMiddleware(value: unknown): value is RegisteredMiddleware;
+export declare function normalizePriority(priority?: number): number;
+export declare function sanitizeName(name: string): string;
+//# sourceMappingURL=httpPipeline.helper.d.ts.map

package/dist/httpMiddleware/pipeline/httpPipeline.helper.js

@@ -0,0 +1,114 @@
+/**
+ * Internal helper functions for the middleware pipeline.
+ *
+ * @module httpMiddleware/pipeline/helpers
+ */
+import { HttpRequestContext as RequestContext } from "../../httpRequest/httpRequest.context.js";
+import { HttpResponseContext as ResponseContext } from "../../httpResponse/httpResponse.context.js";
+import { isWebResponse, webResponseToContext, } from "../../httpResponse/httpResponse.fromWeb.js";
+import { HttpMiddlewareError } from "../httpMiddleware.error.js";
+export async function nextResult(context, dispatch, index) {
+    return dispatch(index + 1);
+}
+/**
+ * Turns whatever a middleware returned into a response context.
+ *
+ * This is the single normalizer for the package. `builtin/helpers` used to
+ * carry a second, near-identical copy (`normalizeMiddlewareResult`); it has
+ * been deleted in favour of this one.
+ *
+ * @param result - The middleware's return value.
+ * @param fallback - The ambient response to continue with when the middleware
+ *   did not produce one of its own.
+ * @returns The response context to continue the pipeline with.
+ * @throws {HttpMiddlewareError} If no response context can be determined.
+ */
+export function normalizeResult(result, fallback) {
+    /*
+     * The `Response` check must come first. `isResponseContext` tests for a
+     * `headers` property, and `headers` is a getter on `Response.prototype`, so
+     * `"headers" in someResponse` is true and every web `Response` used to be
+     * waved through as if it already were a response context — its `Headers`
+     * object was then spread into `{}` and all of its headers were lost.
+     */
+    if (isWebResponse(result)) {
+        return webResponseToContext(result);
+    }
+    if (isResponseContext(result)) {
+        return result;
+    }
+    if (isRequestContext(result)) {
+        /*
+         * A request context is not a response. Returning one signals "continue
+         * with this request", so the ambient response is the correct result. The
+         * previous code fabricated `{ request } as unknown as ResponseContext`
+         * when there was no ambient response: an object with no status, headers
+         * or body, which the adapter read as `undefined` throughout. There is no
+         * honest response to invent here, so this is reported instead.
+         */
+        if (fallback) {
+            return fallback;
+        }
+        throw new HttpMiddlewareError("Middleware returned a request context but no response context is " +
+            "available to continue with. A request context signals 'continue " +
+            "with this request'; it cannot be used as a response.");
+    }
+    if (fallback) {
+        return fallback;
+    }
+    throw new HttpMiddlewareError("Middleware completed without producing a response context.");
+}
+/**
+ * Narrows a value to a response context.
+ *
+ * A web `Response` is explicitly excluded: it satisfies the structural test
+ * (`headers` is a prototype getter) but is a different type entirely, and
+ * treating one as a response context loses its headers.
+ */
+export function isResponseContext(value) {
+    if (value instanceof ResponseContext) {
+        return true;
+    }
+    /*
+     * The nominal checks come first because the structural ones cannot tell
+     * these types apart. `headers` is a getter on `Response.prototype` and on
+     * `HttpRequestContext.prototype`, so `"headers" in value` is true for both,
+     * and a web `Response` or a request context was previously waved through as
+     * a response context.
+     */
+    if (value === null ||
+        typeof value !== "object" ||
+        isWebResponse(value) ||
+        value instanceof RequestContext) {
+        return false;
+    }
+    return "response" in value || "status" in value || "headers" in value;
+}
+export function isRequestContext(value) {
+    if (value instanceof RequestContext) {
+        return true;
+    }
+    if (value === null ||
+        typeof value !== "object" ||
+        isWebResponse(value) ||
+        value instanceof ResponseContext) {
+        return false;
+    }
+    return "request" in value || "method" in value || "url" in value;
+}
+export function isRegisteredMiddleware(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "middleware" in value &&
+        "id" in value);
+}
+export function normalizePriority(priority) {
+    if (priority === undefined || !Number.isFinite(priority)) {
+        return 0;
+    }
+    return priority;
+}
+export function sanitizeName(name) {
+    return name.trim().replace(/[^a-zA-Z0-9_-]+/g, "-") || "middleware";
+}
+//# sourceMappingURL=httpPipeline.helper.js.map

package/dist/httpMiddleware/pipeline/httpPipeline.registration.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Middleware pipeline registration logic.
+ *
+ * @module httpMiddleware/pipeline/registration
+ */
+import type { HttpMiddleware, HttpMiddlewarePipelineOptions, InternalMiddleware, RegisteredMiddleware } from "../httpMiddleware.type.js";
+export interface PipelineRegistration {
+    readonly entries: InternalMiddleware[];
+    readonly metadata: Readonly<Record<string, unknown>>;
+    sequence: number;
+}
+export declare function createRegistration(options?: HttpMiddlewarePipelineOptions): PipelineRegistration;
+export interface UseRegistrationOptions {
+    readonly name?: string;
+    readonly priority?: number;
+    readonly enabled?: boolean;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly sequence?: number;
+}
+export declare function use(entries: InternalMiddleware[], middleware: HttpMiddleware, createId: () => string, options?: UseRegistrationOptions): () => void;
+export declare function remove(entries: InternalMiddleware[], id: string): boolean;
+export declare function setEnabled(entries: InternalMiddleware[], id: string, enabled: boolean): boolean;
+export declare function has(entries: InternalMiddleware[], id: string): boolean;
+export declare function get(entries: InternalMiddleware[], id: string): RegisteredMiddleware | undefined;
+export declare function list(entries: InternalMiddleware[]): readonly RegisteredMiddleware[];
+export declare function createId(entries: InternalMiddleware[], sequence: number): string;
+//# sourceMappingURL=httpPipeline.registration.d.ts.map

package/dist/httpMiddleware/pipeline/httpPipeline.registration.js

@@ -0,0 +1,100 @@
+/**
+ * Middleware pipeline registration logic.
+ *
+ * @module httpMiddleware/pipeline/registration
+ */
+import { isRegisteredMiddleware, normalizePriority, sanitizeName, } from "./httpPipeline.helper.js";
+export function createRegistration(options = {}) {
+    const entries = [];
+    const metadata = Object.freeze({
+        ...(options.metadata ?? {}),
+    });
+    let sequence = 0;
+    for (const middleware of options.middlewares ?? []) {
+        if (isRegisteredMiddleware(middleware)) {
+            entries.push({
+                id: middleware.id,
+                middleware: middleware.middleware,
+                name: middleware.name,
+                priority: middleware.priority,
+                enabled: middleware.enabled,
+            });
+        }
+        else {
+            use(entries, middleware, () => createId(entries, sequence++), {
+                sequence: entries.length,
+            });
+        }
+    }
+    return { entries, metadata, sequence };
+}
+export function use(entries, middleware, createId, options = {}) {
+    if (typeof middleware !== "function") {
+        throw new TypeError("HTTP middleware must be a function.");
+    }
+    const id = createId();
+    entries.push({
+        id,
+        middleware,
+        name: options.name ?? id,
+        priority: normalizePriority(options.priority),
+        /*
+         * `sequence` is the registration-order tiebreaker `list()` sorts on. It
+         * must be stored or equal priorities collapse to an arbitrary order.
+         */
+        sequence: options.sequence ?? entries.length,
+        metadata: options.metadata,
+        enabled: options.enabled ?? true,
+    });
+    return () => {
+        remove(entries, id);
+    };
+}
+export function remove(entries, id) {
+    const index = entries.findIndex((entry) => entry.id === id);
+    if (index === -1) {
+        return false;
+    }
+    entries.splice(index, 1);
+    return true;
+}
+export function setEnabled(entries, id, enabled) {
+    const entry = entries.find((item) => item.id === id);
+    if (!entry) {
+        return false;
+    }
+    entry.enabled = enabled;
+    return true;
+}
+export function has(entries, id) {
+    return entries.some((entry) => entry.id === id);
+}
+export function get(entries, id) {
+    const entry = entries.find((item) => item.id === id);
+    if (!entry) {
+        return undefined;
+    }
+    return {
+        id: entry.id,
+        name: entry.name,
+        priority: entry.priority,
+        enabled: entry.enabled,
+        middleware: entry.middleware,
+    };
+}
+export function list(entries) {
+    return entries
+        .filter((entry) => entry.enabled)
+        .sort((a, b) => a.priority - b.priority || (a.sequence ?? 0) - (b.sequence ?? 0))
+        .map((entry) => ({
+        id: entry.id,
+        name: entry.name,
+        priority: entry.priority,
+        enabled: entry.enabled,
+        middleware: entry.middleware,
+    }));
+}
+export function createId(entries, sequence) {
+    return `${sanitizeName("middleware")}-${sequence}`;
+}
+//# sourceMappingURL=httpPipeline.registration.js.map

package/dist/httpMime/http.mime.d.ts

@@ -0,0 +1,144 @@
+/**
+ * MIME type utilities.
+ *
+ * Provides extension-to-MIME and MIME-to-extension resolution used by
+ * request handling, static files, uploads, downloads, and HTTP responses.
+ */
+export interface MIMETypeDefinition {
+    readonly type: string;
+    readonly extensions: readonly string[];
+}
+export declare const MIME_TYPES: {
+    readonly AAC: "audio/aac";
+    readonly AVIF: "image/avif";
+    readonly AVI: "video/x-msvideo";
+    readonly BIN: "application/octet-stream";
+    readonly BMP: "image/bmp";
+    readonly BZIP: "application/x-bzip";
+    readonly BZIP2: "application/x-bzip2";
+    readonly CSV: "text/csv";
+    readonly CSS: "text/css";
+    readonly DOC: "application/msword";
+    readonly DOCX: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    readonly EOT: "application/vnd.ms-fontobject";
+    readonly EPUB: "application/epub+zip";
+    readonly GIF: "image/gif";
+    readonly GZIP: "application/gzip";
+    readonly HTML: "text/html";
+    readonly ICO: "image/x-icon";
+    readonly JAR: "application/java-archive";
+    readonly JPEG: "image/jpeg";
+    readonly JPG: "image/jpeg";
+    readonly JS: "text/javascript";
+    readonly JSON: "application/json";
+    readonly MAP: "application/json";
+    readonly M4A: "audio/mp4";
+    readonly MP3: "audio/mpeg";
+    readonly MP4: "video/mp4";
+    readonly MPEG: "video/mpeg";
+    readonly OGG: "audio/ogg";
+    readonly OTF: "font/otf";
+    readonly PDF: "application/pdf";
+    readonly PNG: "image/png";
+    readonly PPT: "application/vnd.ms-powerpoint";
+    readonly PPTX: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    readonly RAR: "application/vnd.rar";
+    readonly RSS: "application/rss+xml";
+    readonly SVG: "image/svg+xml";
+    readonly TAR: "application/x-tar";
+    readonly TIFF: "image/tiff";
+    readonly TIF: "image/tiff";
+    readonly TS: "video/mp2t";
+    readonly TXT: "text/plain";
+    readonly WASM: "application/wasm";
+    readonly WAV: "audio/wav";
+    readonly WEBA: "audio/webm";
+    readonly WEBM: "video/webm";
+    readonly WEBP: "image/webp";
+    readonly WOFF: "font/woff";
+    readonly WOFF2: "font/woff2";
+    readonly XML: "application/xml";
+    readonly XLS: "application/vnd.ms-excel";
+    readonly XLSX: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    readonly ZIP: "application/zip";
+    readonly ZST: "application/zstd";
+};
+export type KnownMIMEType = (typeof MIME_TYPES)[keyof typeof MIME_TYPES];
+export declare function getMIMEType(filenameOrExtension: string | undefined | null): string;
+export declare function lookupMIMEType(filenameOrExtension: string | undefined | null): string | undefined;
+export declare function getExtension(filenameOrExtension: string): string;
+export declare function getMIMEExtensions(mimeType: string): readonly string[];
+export declare function getPrimaryExtension(mimeType: string): string | undefined;
+/**
+ * Resolves a MIME type string to its canonical {@link KnownMIMEType}.
+ *
+ * @param mimeType - The raw MIME type, with or without parameters.
+ * @returns The canonical type, or `undefined` if it is not known.
+ */
+export declare function toKnownMIMEType(mimeType: string | undefined | null): KnownMIMEType | undefined;
+/**
+ * Checks whether a string names a MIME type this module knows.
+ *
+ * @remarks
+ * Returns a plain `boolean` rather than narrowing: the check normalises
+ * (lower-cases, strips parameters) before testing, so the input's own runtime
+ * value may still be `"TEXT/HTML; charset=utf-8"`. Use
+ * {@link toKnownMIMEType} when the narrowed value is what you need.
+ *
+ * @param mimeType - The raw MIME type.
+ * @returns `true` if the type is known.
+ */
+export declare function isKnownMIMEType(mimeType: string | undefined | null): boolean;
+export declare function isMIMEType(value: string | undefined | null): boolean;
+/**
+ * Asserts that a value is one of the MIME types this module knows.
+ *
+ * The narrowing is to {@link KnownMIMEType}, so the check must be membership
+ * in that union — a purely syntactic check would assert a type the value does
+ * not hold and let an exhaustive `switch` fall through silently.
+ *
+ * @param value - The candidate MIME type.
+ * @throws {TypeError} If the value is not a known MIME type.
+ */
+export declare function assertMIMEType(value: string): asserts value is KnownMIMEType;
+export declare function normalizeMIMEType(mimeType: string): string;
+export declare function getMIMECategory(mimeType: string): string | undefined;
+export declare function getMIMESubtype(mimeType: string): string | undefined;
+export declare function isTextMIME(mimeType: string): boolean;
+export declare function isImageMIME(mimeType: string): boolean;
+export declare function isAudioMIME(mimeType: string): boolean;
+export declare function isVideoMIME(mimeType: string): boolean;
+export declare function isApplicationMIME(mimeType: string): boolean;
+export declare function isFontMIME(mimeType: string): boolean;
+export declare function isJSONMIME(mimeType: string): boolean;
+export declare function isXMLMIME(mimeType: string): boolean;
+export declare function isMultipartMIME(mimeType: string): boolean;
+export declare function isBinaryMIME(mimeType: string): boolean;
+export declare function mimeTypesEqual(left: string, right: string): boolean;
+export declare function matchesMIMEType(actual: string, expected: string): boolean;
+/**
+ * Parses an `Accept` header into media types, most preferred first.
+ *
+ * Weights are honoured: entries are sorted by descending `q` (stably, so
+ * header order breaks ties) and `q=0` entries — explicit rejections — are
+ * dropped.
+ *
+ * @param header - The raw `Accept` header.
+ * @returns The acceptable media types in preference order.
+ */
+export declare function parseAcceptHeader(header: string | undefined | null): string[];
+export declare function negotiateMIMEType(accepted: string | readonly string[], available: readonly string[]): string | undefined;
+export declare function withCharset(mimeType: string, charset: string): string;
+export declare function isUTF8MIME(mimeType: string): boolean;
+/**
+ * Resolves a filename to a `Content-Type` value.
+ *
+ * A `charset=utf-8` parameter is attached for text-bearing types so the
+ * response is never subject to browser charset sniffing.
+ *
+ * @param filename - The filename or path.
+ * @returns The `Content-Type` value.
+ */
+export declare function filenameToMIME(filename: string): string;
+export declare function mimeToFilename(mimeType: string, basename?: string): string;
+//# sourceMappingURL=http.mime.d.ts.map