@zudojs/http 0.1.0 → 1.1.0

package/dist/httpStream/httpStream.progress.js

@@ -1,27 +1,32 @@
 /**
  * @zudojs/http/httpStream — Pipe streams with progress reporting.
  */
-import { createAbortError } from "./httpStream.error.js";
+import { HttpStreamError as StreamError } from "@zudojs/errors";
+import { createAbortError, createStreamLimitError, normalizeStreamError, } from "./httpStream.error.js";
 import { destroyStream } from "./httpStream.destroy.js";
 import { getChunkSize } from "./httpStream.helper.js";
-import { isWritableFinished } from "./httpStream.state.js";
+import { isReadableEnded, isWritableFinished } from "./httpStream.state.js";
 import { createSettleGuard, cleanupListeners, wireAbortSignal, } from "./httpStream.eventHelper.js";
 export async function pipeStreamWithProgress(source, destination, onProgress, options = {}) {
     const signal = options.signal;
     if (signal?.aborted) {
+        destroyStream(source);
+        destroyStream(destination);
         throw createAbortError();
     }
+    const maxBytes = options.maxBytes ?? Number.POSITIVE_INFINITY;
     let bytes = 0;
     let chunks = 0;
     return new Promise((resolve, reject) => {
         const guard = createSettleGuard();
-        let cleanupFn;
+        /* Defined before any listener is attached; see consumeStream. */
+        let cleanupFn = () => { };
         const fail = (error) => {
             if (guard.settled())
                 return;
             guard.mark();
             cleanupFn();
-            reject(error instanceof Error ? error : new Error(String(error)));
+            reject(normalizeStreamError(error));
         };
         const complete = () => {
             if (guard.settled())
@@ -34,6 +39,12 @@ export async function pipeStreamWithProgress(source, destination, onProgress, op
             try {
                 chunks += 1;
                 bytes += getChunkSize(chunk);
+                if (bytes > maxBytes) {
+                    destroyStream(source);
+                    destroyStream(destination);
+                    fail(createStreamLimitError(maxBytes, bytes));
+                    return;
+                }
                 onProgress({ bytes, chunks });
             }
             catch (error) {
@@ -42,17 +53,40 @@ export async function pipeStreamWithProgress(source, destination, onProgress, op
                 fail(error);
             }
         };
+        /*
+         * `end` is driven from here alone — the pipe below is created with
+         * `{ end: false }` — so the destination is never ended twice.
+         */
         const onEnd = () => {
             if (options.end === false) {
                 complete();
                 return;
             }
             if (!isWritableFinished(destination)) {
-                destination.end();
+                try {
+                    destination.end();
+                }
+                catch (error) {
+                    fail(error);
+                }
                 return;
             }
             complete();
         };
+        /*
+         * A client that aborts mid-upload makes Node destroy the request stream
+         * and emit only `'close'` — neither `'end'` nor `'error'`. Without this
+         * listener the returned promise never settles: every aborted transfer
+         * leaks a pending promise, five listeners, and the buffers they close
+         * over, and any handler awaiting it hangs forever.
+         */
+        const onSourceClose = () => {
+            if (!guard.settled() && !isReadableEnded(source)) {
+                fail(new StreamError("Source stream closed before completion.", {
+                    code: "STREAM_SOURCE_CLOSED",
+                }));
+            }
+        };
         const onFinish = () => {
             complete();
         };
@@ -72,6 +106,7 @@ export async function pipeStreamWithProgress(source, destination, onProgress, op
         source.on("data", onData);
         source.once("end", onEnd);
         source.once("error", onError);
+        source.once("close", onSourceClose);
         destination.once("error", onDestinationError);
         destination.once("finish", onFinish);
         const removeAbort = wireAbortSignal(signal, onAbort);
@@ -80,6 +115,7 @@ export async function pipeStreamWithProgress(source, destination, onProgress, op
                 ["data", onData],
                 ["end", onEnd],
                 ["error", onError],
+                ["close", onSourceClose],
             ]);
             cleanupListeners(destination, [
                 ["error", onDestinationError],
@@ -88,9 +124,7 @@ export async function pipeStreamWithProgress(source, destination, onProgress, op
             removeAbort();
         };
         try {
-            source.pipe(destination, {
-                end: options.end !== false,
-            });
+            source.pipe(destination, { end: false });
         }
         catch (error) {
             fail(error);

package/dist/httpStream/httpStream.transform.d.ts

@@ -2,7 +2,7 @@
  * @zudojs/http/httpStream — Create PassThrough and Readable stream instances.
  */
 import { Readable, PassThrough } from "node:stream";
-import type { HTTPStreamOptions } from "./httpStream.types.js";
-export declare function createPassThrough(options?: HTTPStreamOptions): PassThrough;
-export declare function createReadableStream(data: Iterable<unknown> | AsyncIterable<unknown>, options?: HTTPStreamOptions): Readable;
+import type { HTTPStreamFactoryOptions } from "./httpStream.types.js";
+export declare function createPassThrough(options?: HTTPStreamFactoryOptions): PassThrough;
+export declare function createReadableStream(data: Iterable<unknown> | AsyncIterable<unknown>, options?: HTTPStreamFactoryOptions): Readable;
 //# sourceMappingURL=httpStream.transform.d.ts.map

package/dist/httpStream/httpStream.types.d.ts

@@ -2,8 +2,27 @@
  * @zudojs/http/httpStream — Stream option and result types.
  */
 export interface HTTPStreamOptions {
-    readonly highWaterMark?: number;
     readonly signal?: AbortSignal;
+    /**
+     * Maximum number of bytes to accept before the stream is destroyed and the
+     * operation rejects with a limit error. Defaults to
+     * `HTTP_DEFAULTS.BODY_LIMIT` (1 MiB).
+     *
+     * Pass `Infinity` to opt out deliberately.
+     */
+    readonly maxBytes?: number;
+}
+/**
+ * Options for the stream **factories**.
+ *
+ * `highWaterMark` lives here rather than on {@link HTTPStreamOptions} because
+ * only stream construction can honour it: a read or a pipe over a stream
+ * somebody else created cannot change that stream's buffer size, and
+ * accepting the option there told callers they had bounded a buffer when they
+ * had not.
+ */
+export interface HTTPStreamFactoryOptions extends HTTPStreamOptions {
+    readonly highWaterMark?: number;
 }
 export interface StreamPipeOptions extends HTTPStreamOptions {
     readonly end?: boolean;

package/dist/httpTrustProxy/httpTrustProxy.compilation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Trust proxy compilation.
+ *
+ * @module httpTrustProxy/compilation
+ */
+import type { TrustProxy } from "./httpTrustProxy.type.js";
+/**
+ * A compiled trust predicate.
+ *
+ * `index` is the hop distance from the socket peer: `0` is the immediate peer,
+ * `1` the proxy in front of it, and so on. This matches the convention used by
+ * `proxy-addr` and Express; counting from the left of the header list would
+ * make `(addr, hop) => hop < 1` trust the attacker-controlled end of the chain.
+ */
+export type TrustProxyPredicate = (value: string, index: number) => boolean;
+/**
+ * Compiles a trust proxy configuration into a predicate that decides whether a
+ * given hop address is a trusted proxy.
+ *
+ * Supported forms:
+ * - `false` (default) — trust nothing.
+ * - `true` / `"all"` / `"*"` — trust every hop.
+ * - `"loopback"`, `"linklocal"`, `"uniquelocal"` / `"private"` — named ranges.
+ * - an IP address, a CIDR range, a comma-separated list of either, or an array
+ *   of the same.
+ * - a custom predicate `(address, hopIndexFromPeer) => boolean`.
+ *
+ * Throws `TypeError` on a string that is none of the above rather than
+ * returning a predicate that can never match.
+ */
+export declare function compileTrustProxy(trustProxy: TrustProxy): TrustProxyPredicate;
+//# sourceMappingURL=httpTrustProxy.compilation.d.ts.map

package/dist/httpTrustProxy/httpTrustProxy.compilation.js

@@ -0,0 +1,119 @@
+/**
+ * Trust proxy compilation.
+ *
+ * @module httpTrustProxy/compilation
+ */
+import { LINK_LOCAL_RANGES, LOOPBACK_RANGES, UNIQUE_LOCAL_RANGES, ipEquals, ipMatchesCidr, parseCidr, parseIpAddress, } from "./httpTrustProxy.ip.js";
+const PRESET_RANGES = Object.freeze({
+    loopback: LOOPBACK_RANGES,
+    linklocal: LINK_LOCAL_RANGES,
+    uniquelocal: UNIQUE_LOCAL_RANGES,
+    private: UNIQUE_LOCAL_RANGES,
+});
+function isPresetName(value) {
+    return Object.prototype.hasOwnProperty.call(PRESET_RANGES, value);
+}
+const compilationCache = new Map();
+const MAX_CACHE_ENTRIES = 64;
+function splitTokens(trustProxy) {
+    const values = typeof trustProxy === "string" ? [trustProxy] : trustProxy;
+    const tokens = [];
+    for (const value of values) {
+        for (const token of value.split(",")) {
+            const trimmed = token.trim();
+            if (trimmed.length > 0) {
+                tokens.push(trimmed);
+            }
+        }
+    }
+    return tokens;
+}
+function buildListPredicate(trustProxy) {
+    const tokens = splitTokens(trustProxy);
+    const matchers = [];
+    let trustAll = false;
+    for (const token of tokens) {
+        const lower = token.toLowerCase();
+        if (lower === "all" || lower === "*") {
+            trustAll = true;
+            continue;
+        }
+        if (isPresetName(lower)) {
+            for (const range of PRESET_RANGES[lower]) {
+                const cidr = parseCidr(range);
+                if (cidr) {
+                    matchers.push((address) => ipMatchesCidr(address, cidr));
+                }
+            }
+            continue;
+        }
+        const cidr = parseCidr(token);
+        if (cidr) {
+            matchers.push((address) => ipMatchesCidr(address, cidr));
+            continue;
+        }
+        const exact = parseIpAddress(token);
+        if (exact) {
+            matchers.push((address) => ipEquals(address, exact));
+            continue;
+        }
+        /*
+         * Silently compiling an unmatchable predicate is how `trustProxy:
+         * "10.0.0.0/8"` used to become "trust nothing" (or, in the adapter,
+         * "trust everything") with no diagnostic. Fail at configuration time.
+         */
+        throw new TypeError(`Invalid trustProxy entry: ${token}. Expected an IP address, a CIDR range, or one of: all, loopback, linklocal, uniquelocal, private.`);
+    }
+    if (trustAll) {
+        return () => true;
+    }
+    if (matchers.length === 0) {
+        return () => false;
+    }
+    return (value) => {
+        const address = parseIpAddress(value);
+        if (!address) {
+            return false;
+        }
+        return matchers.some((matcher) => matcher(address));
+    };
+}
+/**
+ * Compiles a trust proxy configuration into a predicate that decides whether a
+ * given hop address is a trusted proxy.
+ *
+ * Supported forms:
+ * - `false` (default) — trust nothing.
+ * - `true` / `"all"` / `"*"` — trust every hop.
+ * - `"loopback"`, `"linklocal"`, `"uniquelocal"` / `"private"` — named ranges.
+ * - an IP address, a CIDR range, a comma-separated list of either, or an array
+ *   of the same.
+ * - a custom predicate `(address, hopIndexFromPeer) => boolean`.
+ *
+ * Throws `TypeError` on a string that is none of the above rather than
+ * returning a predicate that can never match.
+ */
+export function compileTrustProxy(trustProxy) {
+    if (typeof trustProxy === "function") {
+        return trustProxy;
+    }
+    if (trustProxy === true) {
+        return () => true;
+    }
+    /* Anything that is not a string or a list (including `false`, `undefined`
+     * and any malformed runtime value) trusts nothing. */
+    if (typeof trustProxy !== "string" && !Array.isArray(trustProxy)) {
+        return () => false;
+    }
+    const cached = compilationCache.get(trustProxy);
+    if (cached) {
+        return cached;
+    }
+    const predicate = buildListPredicate(trustProxy);
+    if (compilationCache.size >= MAX_CACHE_ENTRIES) {
+        compilationCache.clear();
+    }
+    compilationCache.set(trustProxy, predicate);
+    return predicate;
+}
+//# sourceMappingURL=httpTrustProxy.compilation.js.map

package/dist/httpTrustProxy/httpTrustProxy.core.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Trust proxy utilities for HTTP servers.
+ *
+ * Provides functionality for parsing proxy headers and
+ * determining the real client IP, protocol, and hostname.
+ *
+ * @module httpTrustProxy
+ */
+export * from "./httpTrustProxy.type.js";
+export * from "./httpTrustProxy.ip.js";
+export * from "./httpTrustProxy.compilation.js";
+export * from "./httpTrustProxy.parsing.js";
+export * from "./httpTrustProxy.helper.js";
+//# sourceMappingURL=httpTrustProxy.core.d.ts.map

package/dist/httpTrustProxy/httpTrustProxy.core.js

@@ -0,0 +1,14 @@
+/**
+ * Trust proxy utilities for HTTP servers.
+ *
+ * Provides functionality for parsing proxy headers and
+ * determining the real client IP, protocol, and hostname.
+ *
+ * @module httpTrustProxy
+ */
+export * from "./httpTrustProxy.type.js";
+export * from "./httpTrustProxy.ip.js";
+export * from "./httpTrustProxy.compilation.js";
+export * from "./httpTrustProxy.parsing.js";
+export * from "./httpTrustProxy.helper.js";
+//# sourceMappingURL=httpTrustProxy.core.js.map

package/dist/httpTrustProxy/httpTrustProxy.helper.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Trust proxy helper functions.
+ *
+ * Every `X-Forwarded-*` / `Forwarded` header on a request was written by
+ * whoever opened the socket. The single rule these helpers enforce is:
+ * **the socket peer is authoritative, and forwarded headers are consulted only
+ * when that peer is a configured trusted proxy.**
+ *
+ * @module httpTrustProxy/helpers
+ */
+import type { TrustProxy, ProxyRequest, ProxyInfo } from "./httpTrustProxy.type.js";
+/**
+ * Determines if the given address is a trusted proxy.
+ *
+ * `index` defaults to `0`, the immediate socket peer.
+ */
+export declare function isTrustedProxy(address: string, trustProxy: TrustProxy, index?: number): boolean;
+/**
+ * Determines whether the immediate socket peer is a configured trusted proxy.
+ *
+ * This is the gate for every forwarded-header helper below. When it is false,
+ * no `X-Forwarded-*` value may influence the result, because the peer writing
+ * them is an ordinary (possibly hostile) client.
+ */
+export declare function isTrustedPeer(request: ProxyRequest, trustProxy?: TrustProxy): boolean;
+/**
+ * Gets the client IP address from the request.
+ *
+ * Walks the chain right to left starting at the socket peer, skipping hops the
+ * `trustProxy` predicate accepts, and returns the first hop it does not. The
+ * hop index passed to a custom predicate is counted **from the peer** (`0` is
+ * the peer), matching the `proxy-addr` / Express convention.
+ *
+ * With `trustProxy: false` (the default) the socket peer is returned and
+ * forwarded headers are ignored entirely.
+ */
+export declare function getClientIp(request: ProxyRequest, trustProxy?: TrustProxy): string | undefined;
+/**
+ * Gets the proxy chain from the request, left to right, including the socket
+ * peer as the final hop.
+ */
+export declare function getProxyChain(request: ProxyRequest): readonly string[];
+/**
+ * Gets the request protocol from proxy headers.
+ *
+ * Returns `"http"` unless the socket peer is a trusted proxy *and* the
+ * forwarded value is `http` or `https`. An unrecognised value such as
+ * `gopher` is discarded rather than propagated.
+ */
+export declare function getRequestProtocol(request: ProxyRequest, trustProxy?: TrustProxy): string;
+/**
+ * Determines if the request is secure (HTTPS).
+ */
+export declare function isSecureRequest(request: ProxyRequest, trustProxy?: TrustProxy): boolean;
+/**
+ * Gets the request hostname from proxy headers, without the port.
+ *
+ * IPv6 literals are handled: `[::1]:8080` yields `::1`, not `[`.
+ */
+export declare function getRequestHostname(request: ProxyRequest, trustProxy?: TrustProxy): string | undefined;
+/**
+ * Gets the request port from proxy headers.
+ */
+export declare function getRequestPort(request: ProxyRequest, trustProxy?: TrustProxy): number | undefined;
+/**
+ * Gets the port the client connected from, when a forwarded entry carries one.
+ */
+export declare function getClientPort(request: ProxyRequest, trustProxy?: TrustProxy): number | undefined;
+/**
+ * Gets comprehensive proxy information from the request.
+ */
+export declare function getProxyInfo(request: ProxyRequest, trustProxy?: TrustProxy): ProxyInfo;
+//# sourceMappingURL=httpTrustProxy.helper.d.ts.map

package/dist/httpTrustProxy/httpTrustProxy.helper.js

@@ -0,0 +1,226 @@
+/**
+ * Trust proxy helper functions.
+ *
+ * Every `X-Forwarded-*` / `Forwarded` header on a request was written by
+ * whoever opened the socket. The single rule these helpers enforce is:
+ * **the socket peer is authoritative, and forwarded headers are consulted only
+ * when that peer is a configured trusted proxy.**
+ *
+ * @module httpTrustProxy/helpers
+ */
+import { X_FORWARDED_PROTO, X_FORWARDED_HOST, X_FORWARDED_PORT, } from "./httpTrustProxy.type.js";
+import { compileTrustProxy } from "./httpTrustProxy.compilation.js";
+import { getForwardedClientAddresses, splitAddressAndPort, } from "./httpTrustProxy.parsing.js";
+const ALLOWED_PROTOCOLS = Object.freeze(["http", "https"]);
+function firstHeaderValue(header) {
+    const value = Array.isArray(header) ? header[0] : header;
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    /*
+     * A proxy that appends rather than overwrites produces `https, http`. The
+     * left-most entry is whatever the *client* sent, so it cannot be trusted on
+     * its own; it is only read after the peer has been verified as a proxy that
+     * is expected to prepend the true value.
+     */
+    const first = value.split(",")[0];
+    return typeof first === "string" ? first.trim() : undefined;
+}
+/**
+ * Determines if the given address is a trusted proxy.
+ *
+ * `index` defaults to `0`, the immediate socket peer.
+ */
+export function isTrustedProxy(address, trustProxy, index = 0) {
+    if (!address) {
+        return false;
+    }
+    return compileTrustProxy(trustProxy)(address, index);
+}
+/**
+ * Determines whether the immediate socket peer is a configured trusted proxy.
+ *
+ * This is the gate for every forwarded-header helper below. When it is false,
+ * no `X-Forwarded-*` value may influence the result, because the peer writing
+ * them is an ordinary (possibly hostile) client.
+ */
+export function isTrustedPeer(request, trustProxy = false) {
+    if (!trustProxy) {
+        return false;
+    }
+    const peer = request.socket?.remoteAddress;
+    if (!peer) {
+        return false;
+    }
+    return isTrustedProxy(peer, trustProxy, 0);
+}
+/**
+ * Builds the full hop chain, ordered left (originating client) to right
+ * (immediate socket peer). The peer is appended because it is the one address
+ * in the chain that the client cannot forge, and it must be the first hop the
+ * trust walk examines.
+ */
+function buildChain(request) {
+    const forwarded = getForwardedClientAddresses(request).map((entry) => entry.address);
+    const peer = request.socket?.remoteAddress;
+    return peer ? [...forwarded, peer] : forwarded;
+}
+/**
+ * Gets the client IP address from the request.
+ *
+ * Walks the chain right to left starting at the socket peer, skipping hops the
+ * `trustProxy` predicate accepts, and returns the first hop it does not. The
+ * hop index passed to a custom predicate is counted **from the peer** (`0` is
+ * the peer), matching the `proxy-addr` / Express convention.
+ *
+ * With `trustProxy: false` (the default) the socket peer is returned and
+ * forwarded headers are ignored entirely.
+ */
+export function getClientIp(request, trustProxy = false) {
+    const peer = request.socket?.remoteAddress;
+    if (!trustProxy) {
+        return peer;
+    }
+    const chain = buildChain(request);
+    if (chain.length === 0) {
+        return peer;
+    }
+    const checker = compileTrustProxy(trustProxy);
+    for (let position = chain.length - 1; position >= 0; position -= 1) {
+        const address = chain[position];
+        if (!address) {
+            return peer;
+        }
+        if (checker(address, chain.length - 1 - position)) {
+            continue;
+        }
+        return address;
+    }
+    /* Every hop is trusted, so the left-most entry is the originating client. */
+    return chain[0] ?? peer;
+}
+/**
+ * Gets the proxy chain from the request, left to right, including the socket
+ * peer as the final hop.
+ */
+export function getProxyChain(request) {
+    return buildChain(request);
+}
+function trustedForwardedEntries(request, trustProxy) {
+    if (!isTrustedPeer(request, trustProxy)) {
+        return [];
+    }
+    return getForwardedClientAddresses(request);
+}
+/**
+ * Gets the request protocol from proxy headers.
+ *
+ * Returns `"http"` unless the socket peer is a trusted proxy *and* the
+ * forwarded value is `http` or `https`. An unrecognised value such as
+ * `gopher` is discarded rather than propagated.
+ */
+export function getRequestProtocol(request, trustProxy = false) {
+    if (!isTrustedPeer(request, trustProxy)) {
+        return "http";
+    }
+    for (const entry of getForwardedClientAddresses(request)) {
+        const protocol = entry.protocol?.toLowerCase();
+        if (protocol && ALLOWED_PROTOCOLS.includes(protocol)) {
+            return protocol;
+        }
+    }
+    const value = firstHeaderValue(request.headers[X_FORWARDED_PROTO])
+        ?.trim()
+        .toLowerCase();
+    if (value && ALLOWED_PROTOCOLS.includes(value)) {
+        return value;
+    }
+    return "http";
+}
+/**
+ * Determines if the request is secure (HTTPS).
+ */
+export function isSecureRequest(request, trustProxy = false) {
+    return getRequestProtocol(request, trustProxy) === "https";
+}
+/**
+ * Gets the request hostname from proxy headers, without the port.
+ *
+ * IPv6 literals are handled: `[::1]:8080` yields `::1`, not `[`.
+ */
+export function getRequestHostname(request, trustProxy = false) {
+    if (!isTrustedPeer(request, trustProxy)) {
+        return undefined;
+    }
+    for (const entry of trustedForwardedEntries(request, trustProxy)) {
+        if (entry.host) {
+            return splitAddressAndPort(entry.host).address;
+        }
+    }
+    const value = firstHeaderValue(request.headers[X_FORWARDED_HOST]);
+    if (!value) {
+        return undefined;
+    }
+    const { address } = splitAddressAndPort(value);
+    return address.length > 0 ? address : undefined;
+}
+/**
+ * Gets the request port from proxy headers.
+ */
+export function getRequestPort(request, trustProxy = false) {
+    if (!isTrustedPeer(request, trustProxy)) {
+        return undefined;
+    }
+    const portHeader = firstHeaderValue(request.headers[X_FORWARDED_PORT]);
+    if (portHeader) {
+        const port = Number.parseInt(portHeader, 10);
+        if (Number.isInteger(port) && port >= 0 && port <= 65535) {
+            return port;
+        }
+    }
+    for (const entry of trustedForwardedEntries(request, trustProxy)) {
+        if (entry.host) {
+            const { port } = splitAddressAndPort(entry.host);
+            if (port !== undefined) {
+                return port;
+            }
+        }
+    }
+    const hostHeader = firstHeaderValue(request.headers[X_FORWARDED_HOST]);
+    if (hostHeader) {
+        const { port } = splitAddressAndPort(hostHeader);
+        if (port !== undefined) {
+            return port;
+        }
+    }
+    return undefined;
+}
+/**
+ * Gets the port the client connected from, when a forwarded entry carries one.
+ */
+export function getClientPort(request, trustProxy = false) {
+    const clientIp = getClientIp(request, trustProxy);
+    if (!clientIp) {
+        return undefined;
+    }
+    for (const entry of trustedForwardedEntries(request, trustProxy)) {
+        if (entry.address === clientIp && entry.port !== undefined) {
+            return entry.port;
+        }
+    }
+    return undefined;
+}
+/**
+ * Gets comprehensive proxy information from the request.
+ */
+export function getProxyInfo(request, trustProxy = false) {
+    return {
+        clientIp: getClientIp(request, trustProxy),
+        clientPort: getClientPort(request, trustProxy),
+        protocol: getRequestProtocol(request, trustProxy),
+        hostname: getRequestHostname(request, trustProxy),
+        port: getRequestPort(request, trustProxy),
+        chain: getProxyChain(request),
+    };
+}
+//# sourceMappingURL=httpTrustProxy.helper.js.map