@zudojs/http 0.1.0 → 1.1.0

package/dist/httpClient/httpClient.typeGuards.js

@@ -0,0 +1,23 @@
+/**
+ * HTTP client type guards.
+ *
+ * @module httpClient/typeGuards
+ */
+import { HttpClientError, HttpClientTimeoutError, HttpClientAbortError, HttpClientNetworkError, } from "./httpClient.error.js";
+import { HttpClientResponseMarker } from "./httpClient.helpers.js";
+export function isHttpClientError(value) {
+    return value instanceof HttpClientError;
+}
+export function isHttpClientTimeoutError(value) {
+    return value instanceof HttpClientTimeoutError;
+}
+export function isHttpClientAbortError(value) {
+    return value instanceof HttpClientAbortError;
+}
+export function isHttpClientNetworkError(value) {
+    return value instanceof HttpClientNetworkError;
+}
+export function createResponseInterceptorResult(response) {
+    return new HttpClientResponseMarker(response);
+}
+//# sourceMappingURL=httpClient.typeGuards.js.map

package/dist/httpClient/httpClient.url.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HTTP client URL handling.
+ *
+ * @module httpClient/url
+ */
+import type { HttpClientQuery } from "./httpClient.type.js";
+export declare function buildClientUrl(input: string | URL, baseUrl?: string, query?: HttpClientQuery): URL;
+export declare function appendQuery(url: URL, query: HttpClientQuery): URL;
+//# sourceMappingURL=httpClient.url.d.ts.map

package/dist/httpClient/httpClient.url.js

@@ -0,0 +1,40 @@
+/**
+ * HTTP client URL handling.
+ *
+ * @module httpClient/url
+ */
+import { isAbsoluteUrl, getDefaultBaseUrl } from "./httpClient.helpers.js";
+export function buildClientUrl(input, baseUrl, query) {
+    const value = input instanceof URL
+        ? new URL(input.toString())
+        : isAbsoluteUrl(input)
+            ? new URL(input)
+            : new URL(input, baseUrl ?? getDefaultBaseUrl());
+    if (query) {
+        appendQuery(value, query);
+    }
+    return value;
+}
+export function appendQuery(url, query) {
+    if (query instanceof URLSearchParams) {
+        for (const [key, value] of query.entries()) {
+            url.searchParams.append(key, value);
+        }
+        return url;
+    }
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                url.searchParams.append(key, String(item));
+            }
+        }
+        else {
+            url.searchParams.append(key, String(value));
+        }
+    }
+    return url;
+}
+//# sourceMappingURL=httpClient.url.js.map

package/dist/httpCompression/http.compression.d.ts

@@ -0,0 +1,71 @@
+/**
+ * HTTP compression utilities.
+ *
+ * Handles compression negotiation and response encoding decisions.
+ * Actual compression/decompression is intentionally delegated to adapters.
+ */
+import type { HTTPHeader } from "../httpProtocol/http.protocol.js";
+export type CompressionEncoding = "br" | "gzip" | "deflate" | "identity";
+export interface CompressionPreference {
+    readonly encoding: CompressionEncoding;
+    readonly quality: number;
+    readonly specificity: number;
+    readonly order: number;
+}
+export interface CompressionOptions {
+    readonly threshold?: number;
+    readonly preferredEncodings?: readonly CompressionEncoding[];
+    readonly minimumQuality?: number;
+    readonly enabled?: boolean;
+}
+export interface CompressionDecision {
+    readonly encoding: CompressionEncoding;
+    readonly compress: boolean;
+    readonly quality: number;
+}
+export declare const DEFAULT_COMPRESSION_THRESHOLD = 1024;
+export declare const DEFAULT_MIN_COMPRESSION_QUALITY = 0.1;
+export declare const DEFAULT_PREFERRED_ENCODINGS: readonly CompressionEncoding[];
+export declare const COMPRESSION_ENCODINGS: readonly CompressionEncoding[];
+/**
+ * Upper bound on the number of `Accept-Encoding` entries considered.
+ *
+ * The header is attacker-controlled and free to send; without a cap a single
+ * request can carry a thousand entries whose parsing and sorting cost is paid
+ * on the request-serving thread.
+ */
+export declare const MAX_ACCEPT_ENCODING_ENTRIES = 64;
+export declare function isCompressionEncoding(value: string): value is CompressionEncoding;
+export declare function normalizeCompressionEncoding(value: string): CompressionEncoding | undefined;
+/**
+ * Parses `Accept-Encoding` into the codings this package can emit.
+ *
+ * Codings outside `br | gzip | deflate | identity` — and the `*` wildcard —
+ * are omitted rather than being relabelled as `identity`.
+ */
+export declare function parseCompressionPreferences(header: string | undefined | null): CompressionPreference[];
+export declare function getCompressionQuality(acceptEncoding: string | undefined | null, encoding: CompressionEncoding): number;
+export declare function negotiateCompression(acceptEncoding: string | undefined | null, available?: readonly CompressionEncoding[] | undefined): CompressionEncoding;
+export declare function shouldCompress(contentLength: number | undefined, contentType: string | undefined, options?: CompressionOptions | undefined): boolean;
+export declare function chooseCompression(acceptEncoding: string | undefined | null, contentLength: number | undefined, contentType: string | undefined, options?: CompressionOptions | undefined): CompressionDecision;
+/**
+ * Applies the response headers implied by a chosen content coding.
+ *
+ * `Vary: Accept-Encoding` is set on **every** branch, identity included: the
+ * coding was chosen per-request from the client's `Accept-Encoding`, so the
+ * identity representation varies on it exactly as the compressed ones do.
+ * Storing one representation with `Vary` and another without is a documented
+ * cache-poisoning enabler. RFC 9110 §8.4.1 also says a sender should not emit
+ * `Content-Encoding: identity`, so that branch now sets no coding at all.
+ */
+export declare function applyCompressionHeaders(headers: readonly HTTPHeader[], encoding: CompressionEncoding): HTTPHeader[];
+export declare function removeCompressionHeaders(headers: readonly HTTPHeader[]): HTTPHeader[];
+export declare function isAlreadyCompressedType(contentType: string): boolean;
+export declare function isCompressibleType(contentType: string | undefined): boolean;
+export declare function hasVaryValue(vary: string | undefined, value: string): boolean;
+export declare function addVaryValue(headers: readonly HTTPHeader[], value: string): HTTPHeader[];
+export declare function getCompressionMimeType(encoding: CompressionEncoding): string | undefined;
+export declare function isCompressionSupported(encoding: string): encoding is CompressionEncoding;
+export declare function requiresCompressionVary(encoding: CompressionEncoding): boolean;
+export declare function isCacheableCompressedResponse(encoding: CompressionEncoding): boolean;
+//# sourceMappingURL=http.compression.d.ts.map

package/dist/httpCompression/http.compression.js

@@ -0,0 +1,334 @@
+/**
+ * HTTP compression utilities.
+ *
+ * Handles compression negotiation and response encoding decisions.
+ * Actual compression/decompression is intentionally delegated to adapters.
+ */
+import { getHeader, setHeader } from "../httpProtocol/http.protocol.js";
+import { parseAcceptEncoding } from "../httpNegotiation/httpNegotiation.core.js";
+/* -------------------------------------------------------------------------- */
+/* Constants                                                                  */
+/* -------------------------------------------------------------------------- */
+export const DEFAULT_COMPRESSION_THRESHOLD = 1024;
+export const DEFAULT_MIN_COMPRESSION_QUALITY = 0.1;
+export const DEFAULT_PREFERRED_ENCODINGS = [
+    "br",
+    "gzip",
+    "deflate",
+    "identity",
+];
+export const COMPRESSION_ENCODINGS = [
+    "br",
+    "gzip",
+    "deflate",
+    "identity",
+];
+/**
+ * Upper bound on the number of `Accept-Encoding` entries considered.
+ *
+ * The header is attacker-controlled and free to send; without a cap a single
+ * request can carry a thousand entries whose parsing and sorting cost is paid
+ * on the request-serving thread.
+ */
+export const MAX_ACCEPT_ENCODING_ENTRIES = 64;
+/* -------------------------------------------------------------------------- */
+/* Encoding Validation                                                        */
+/* -------------------------------------------------------------------------- */
+export function isCompressionEncoding(value) {
+    const normalized = value.trim().toLowerCase();
+    return (normalized === "br" ||
+        normalized === "gzip" ||
+        normalized === "deflate" ||
+        normalized === "identity");
+}
+export function normalizeCompressionEncoding(value) {
+    const normalized = value.trim().toLowerCase();
+    return isCompressionEncoding(normalized) ? normalized : undefined;
+}
+function parseCompressionHeader(header) {
+    if (typeof header === "string" && header.trim().length === 0) {
+        return { entries: [], wildcard: undefined, empty: true };
+    }
+    const parsed = parseAcceptEncoding(header).slice(0, MAX_ACCEPT_ENCODING_ENTRIES);
+    const entries = [];
+    let wildcard;
+    for (const preference of parsed) {
+        const value = preference.value.trim().toLowerCase();
+        if (value === "*") {
+            if (wildcard === undefined || preference.quality > wildcard) {
+                wildcard = preference.quality;
+            }
+            continue;
+        }
+        const encoding = normalizeCompressionEncoding(value);
+        /*
+         * An unknown coding is dropped, not relabelled. Aliasing `zstd;q=0.9` to
+         * `identity` made a client that merely prefers zstd look like a client
+         * that strongly prefers no compression at all, and beat its own explicit
+         * `gzip` fallback.
+         */
+        if (encoding === undefined) {
+            continue;
+        }
+        entries.push({
+            encoding,
+            quality: preference.quality,
+            specificity: preference.specificity,
+            order: preference.order,
+        });
+    }
+    return { entries, wildcard, empty: false };
+}
+/**
+ * Parses `Accept-Encoding` into the codings this package can emit.
+ *
+ * Codings outside `br | gzip | deflate | identity` — and the `*` wildcard —
+ * are omitted rather than being relabelled as `identity`.
+ */
+export function parseCompressionPreferences(header) {
+    return [...parseCompressionHeader(header).entries];
+}
+/* -------------------------------------------------------------------------- */
+/* Quality                                                                    */
+/* -------------------------------------------------------------------------- */
+function qualityFor(parsed, encoding) {
+    if (parsed.empty) {
+        return encoding === "identity" ? 1 : 0;
+    }
+    if (parsed.entries.length === 0 && parsed.wildcard === undefined) {
+        return 1;
+    }
+    let best;
+    for (const preference of parsed.entries) {
+        if (preference.encoding !== encoding) {
+            continue;
+        }
+        if (!best ||
+            preference.quality > best.quality ||
+            (preference.quality === best.quality &&
+                preference.specificity > best.specificity)) {
+            best = preference;
+        }
+    }
+    if (best) {
+        return best.quality;
+    }
+    /*
+     * A wildcard covers any coding that was not named explicitly — including
+     * identity, whose implicit acceptability a wildcard overrides.
+     */
+    if (parsed.wildcard !== undefined) {
+        return parsed.wildcard;
+    }
+    /*
+     * RFC 9110 §12.5.3: identity is acceptable unless explicitly rejected.
+     */
+    return encoding === "identity" ? 1 : 0;
+}
+export function getCompressionQuality(acceptEncoding, encoding) {
+    return qualityFor(parseCompressionHeader(acceptEncoding), encoding);
+}
+/* -------------------------------------------------------------------------- */
+/* Negotiation                                                                */
+/* -------------------------------------------------------------------------- */
+export function negotiateCompression(acceptEncoding, available = DEFAULT_PREFERRED_ENCODINGS) {
+    return negotiateParsed(parseCompressionHeader(acceptEncoding), available);
+}
+function negotiateParsed(parsed, available = DEFAULT_PREFERRED_ENCODINGS) {
+    const candidates = [...available];
+    if (candidates.length === 0) {
+        return "identity";
+    }
+    let best;
+    for (let index = 0; index < candidates.length; index += 1) {
+        const encoding = candidates[index];
+        if (encoding === undefined) {
+            continue;
+        }
+        const quality = qualityFor(parsed, encoding);
+        if (quality <= 0) {
+            continue;
+        }
+        const priority = candidates.length - index;
+        if (!best ||
+            quality > best.quality ||
+            (quality === best.quality && priority > best.priority)) {
+            best = {
+                encoding,
+                quality,
+                priority,
+            };
+        }
+    }
+    return best?.encoding ?? "identity";
+}
+/* -------------------------------------------------------------------------- */
+/* Response Compression                                                       */
+/* -------------------------------------------------------------------------- */
+export function shouldCompress(contentLength, contentType, options = {}) {
+    if (options.enabled === false) {
+        return false;
+    }
+    if (contentLength !== undefined &&
+        contentLength < (options.threshold ?? DEFAULT_COMPRESSION_THRESHOLD)) {
+        return false;
+    }
+    /*
+     * An allowlist, not a denylist. Compressing an already-compressed or opaque
+     * binary payload burns CPU for no gain, and compressing a response that
+     * mixes attacker-controlled and secret content is the precondition for a
+     * BREACH-class compression oracle.
+     */
+    return isCompressibleType(contentType);
+}
+export function chooseCompression(acceptEncoding, contentLength, contentType, options = {}) {
+    const parsed = parseCompressionHeader(acceptEncoding);
+    if (!shouldCompress(contentLength, contentType, options)) {
+        return {
+            encoding: "identity",
+            compress: false,
+            quality: qualityFor(parsed, "identity"),
+        };
+    }
+    const available = options.preferredEncodings ?? DEFAULT_PREFERRED_ENCODINGS;
+    const encoding = negotiateParsed(parsed, available);
+    const quality = qualityFor(parsed, encoding);
+    const minimumQuality = options.minimumQuality ?? DEFAULT_MIN_COMPRESSION_QUALITY;
+    if (encoding === "identity" || quality < minimumQuality) {
+        return {
+            encoding: "identity",
+            compress: false,
+            quality: qualityFor(parsed, "identity"),
+        };
+    }
+    return {
+        encoding,
+        compress: true,
+        quality,
+    };
+}
+/* -------------------------------------------------------------------------- */
+/* Header Handling                                                            */
+/* -------------------------------------------------------------------------- */
+/**
+ * Applies the response headers implied by a chosen content coding.
+ *
+ * `Vary: Accept-Encoding` is set on **every** branch, identity included: the
+ * coding was chosen per-request from the client's `Accept-Encoding`, so the
+ * identity representation varies on it exactly as the compressed ones do.
+ * Storing one representation with `Vary` and another without is a documented
+ * cache-poisoning enabler. RFC 9110 §8.4.1 also says a sender should not emit
+ * `Content-Encoding: identity`, so that branch now sets no coding at all.
+ */
+export function applyCompressionHeaders(headers, encoding) {
+    const result = encoding === "identity"
+        ? [...headers]
+        : setHeader(headers, "content-encoding", encoding);
+    /*
+     * Content-Length refers to the encoded body. Compression adapters should
+     * recalculate it after transforming the payload.
+     */
+    return addVaryValue(result, "Accept-Encoding");
+}
+export function removeCompressionHeaders(headers) {
+    return headers.filter((header) => {
+        const name = header.name.toLowerCase();
+        return name !== "content-encoding" && name !== "content-length";
+    });
+}
+/* -------------------------------------------------------------------------- */
+/* Content-Type Helpers                                                       */
+/* -------------------------------------------------------------------------- */
+export function isAlreadyCompressedType(contentType) {
+    const normalized = (contentType.split(";", 1)[0] ?? "").trim().toLowerCase();
+    if (normalized === "application/zip" ||
+        normalized === "application/gzip" ||
+        normalized === "application/x-gzip" ||
+        normalized === "application/x-7z-compressed" ||
+        normalized === "application/x-rar-compressed" ||
+        normalized === "application/zstd" ||
+        normalized === "image/jpeg" ||
+        normalized === "image/png" ||
+        normalized === "image/gif" ||
+        normalized === "image/webp" ||
+        normalized === "audio/mpeg" ||
+        normalized === "audio/ogg" ||
+        normalized === "video/mp4" ||
+        normalized === "video/webm") {
+        return true;
+    }
+    return false;
+}
+export function isCompressibleType(contentType) {
+    if (!contentType) {
+        return true;
+    }
+    if (isAlreadyCompressedType(contentType)) {
+        return false;
+    }
+    const normalized = (contentType.split(";", 1)[0] ?? "").trim().toLowerCase();
+    return (normalized.startsWith("text/") ||
+        normalized.startsWith("application/json") ||
+        normalized.startsWith("application/javascript") ||
+        normalized.startsWith("application/xml") ||
+        normalized.endsWith("+json") ||
+        normalized.endsWith("+xml") ||
+        normalized === "application/graphql" ||
+        normalized === "application/wasm" ||
+        normalized === "image/svg+xml");
+}
+/* -------------------------------------------------------------------------- */
+/* Vary Helpers                                                               */
+/* -------------------------------------------------------------------------- */
+export function hasVaryValue(vary, value) {
+    if (!vary) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return vary
+        .split(",")
+        .map((item) => item.trim().toLowerCase())
+        .some((item) => item === normalized || item === "*");
+}
+export function addVaryValue(headers, value) {
+    const existing = getHeader(headers, "vary");
+    if (!existing) {
+        return setHeader(headers, "vary", value);
+    }
+    if (hasVaryValue(existing, value)) {
+        return [...headers];
+    }
+    return setHeader(headers, "vary", `${existing}, ${value}`);
+}
+/* -------------------------------------------------------------------------- */
+/* Compression Stream Metadata                                                */
+/* -------------------------------------------------------------------------- */
+export function getCompressionMimeType(encoding) {
+    switch (encoding) {
+        case "br":
+            return "application/octet-stream";
+        case "gzip":
+            return "application/gzip";
+        case "deflate":
+            return "application/zlib";
+        case "identity":
+            return undefined;
+    }
+}
+export function isCompressionSupported(encoding) {
+    return isCompressionEncoding(encoding);
+}
+/* -------------------------------------------------------------------------- */
+/* Cache Semantics                                                            */
+/* -------------------------------------------------------------------------- */
+export function requiresCompressionVary(encoding) {
+    return encoding !== "identity";
+}
+export function isCacheableCompressedResponse(encoding) {
+    /*
+     * Compression itself does not make a response uncacheable. The response
+     * must vary on Accept-Encoding when multiple representations are served.
+     */
+    return encoding === "br" || encoding === "gzip" || encoding === "deflate";
+}
+//# sourceMappingURL=http.compression.js.map

package/dist/httpConditional/httpConditional.core.d.ts

@@ -0,0 +1,141 @@
+/**
+ * HTTP conditional request utilities.
+ *
+ * Handles ETag, If-None-Match, If-Match, If-Modified-Since,
+ * If-Unmodified-Since and related conditional request semantics.
+ */
+export interface EntityTag {
+    readonly value: string;
+    readonly weak: boolean;
+}
+export interface ConditionalHeaders {
+    readonly ifMatch?: string;
+    readonly ifNoneMatch?: string;
+    readonly ifModifiedSince?: string;
+    readonly ifUnmodifiedSince?: string;
+    readonly ifRange?: string;
+}
+export interface ConditionalResource {
+    readonly etag?: string;
+    readonly lastModified?: Date | string;
+}
+export interface ConditionalResult {
+    readonly matched: boolean;
+    readonly notModified: boolean;
+    readonly preconditionFailed: boolean;
+    readonly statusCode?: 304 | 412;
+    /**
+     * Whether a `Range` header may be honoured for this request.
+     *
+     * `false` when an `If-Range` condition was supplied and did not match the
+     * current representation; RFC 9110 section 13.1.5 then requires the server
+     * to ignore `Range` and return the full 200 response.
+     */
+    readonly rangeApplicable: boolean;
+}
+export type ConditionalMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "TRACE" | "CONNECT";
+export declare const NOT_MODIFIED_STATUS = 304;
+export declare const PRECONDITION_FAILED_STATUS = 412;
+export declare function parseEntityTag(value: string | undefined | null): EntityTag | undefined;
+/**
+ * Formats an entity tag for the wire.
+ *
+ * @param tag - The tag value, or a parsed {@link EntityTag}.
+ * @param weak - Whether to emit the `W/` weakness indicator.
+ * @returns The formatted entity tag.
+ * @throws {TypeError} If the value contains a character outside `etagc` —
+ *   notably DQUOTE, CR, LF or NUL, which would otherwise split the response.
+ */
+export declare function formatEntityTag(tag: EntityTag | string, weak?: boolean): string;
+/**
+ * Parses an entity-tag list header into its tags.
+ *
+ * @remarks
+ * The wildcard `*` yields an **empty** list, which is indistinguishable from
+ * "no parseable tags". Callers making a precondition decision must use
+ * {@link parseEntityTagCondition}, or pair this with {@link isWildcardETag};
+ * treating an empty result as "no precondition" turns `If-Match: *` — the
+ * strongest possible precondition — into no precondition at all.
+ *
+ * @param value - The raw header value.
+ * @returns The parsed entity tags.
+ */
+export declare function parseEntityTagList(value: string | undefined | null): readonly EntityTag[];
+export declare function isWildcardETag(value: string | undefined | null): boolean;
+/**
+ * Parses an entity-tag list header, distinguishing the `*` wildcard from an
+ * empty or unparseable list.
+ *
+ * @param value - The raw header value.
+ * @returns The wildcard flag, whether the header was present, and the tags.
+ */
+export declare function parseEntityTagCondition(value: string | undefined | null): {
+    readonly present: boolean;
+    readonly wildcard: boolean;
+    readonly tags: readonly EntityTag[];
+};
+export declare function strongETagMatch(left: EntityTag | string | undefined, right: EntityTag | string | undefined): boolean;
+export declare function weakETagMatch(left: EntityTag | string | undefined, right: EntityTag | string | undefined): boolean;
+export declare function matchesETagList(header: string | undefined | null, currentETag: string | EntityTag | undefined, strong?: boolean): boolean;
+/**
+ * Parses an HTTP-date.
+ *
+ * Only the three formats RFC 9110 section 5.6.7 defines are accepted:
+ * IMF-fixdate, the obsolete RFC 850 form, and the asctime form. Every one is
+ * interpreted as UTC — `Date.parse` reads asctime as *server-local* time, so
+ * delegating to it silently skews every `If-Modified-Since` comparison on a
+ * server that is not running in UTC.
+ *
+ * @param value - The raw header value.
+ * @returns The parsed instant, or `undefined` if it is not an HTTP-date.
+ */
+export declare function parseHTTPDate(value: string | undefined | null): Date | undefined;
+export declare function normalizeHTTPDate(value: Date | string): Date | undefined;
+export declare function formatHTTPDate(value: Date | string): string;
+export declare function isNotModifiedSince(lastModified: Date | string | undefined, ifModifiedSince: string | undefined): boolean;
+export declare function isModifiedSince(lastModified: Date | string | undefined, ifUnmodifiedSince: string | undefined): boolean;
+export declare function matchesIfRange(ifRange: string | undefined, resource: ConditionalResource | undefined): boolean;
+export declare function evaluateIfMatch(header: string | undefined, currentETag: string | EntityTag | undefined): boolean;
+export declare function evaluateIfNoneMatch(header: string | undefined, currentETag: string | EntityTag | undefined): boolean;
+/**
+ * Evaluates every conditional request header in RFC 9110 section 13.2.2
+ * precedence order.
+ *
+ * `If-Range` is evaluated last and reported through
+ * {@link ConditionalResult.rangeApplicable}: when it is present and does not
+ * match the current representation, the caller must ignore the `Range`
+ * header and send the full 200 response.
+ *
+ * @param method - The request method.
+ * @param headers - The conditional request headers.
+ * @param resource - The current representation's validators.
+ * @returns The evaluation outcome.
+ */
+export declare function evaluateConditionalRequest(method: string | undefined, headers: ConditionalHeaders, resource: ConditionalResource): ConditionalResult;
+/**
+ * Reports whether a `Range` header may be honoured for this request.
+ *
+ * @param headers - The conditional request headers.
+ * @param resource - The current representation's validators.
+ * @returns `false` when `If-Range` was sent and does not match.
+ */
+export declare function isRangeApplicable(headers: ConditionalHeaders, resource: ConditionalResource): boolean;
+export declare function extractConditionalHeaders(headers: Headers | Readonly<Record<string, string | undefined>>): ConditionalHeaders;
+export declare function shouldReturnNotModified(method: string | undefined, resource: ConditionalResource, headers: ConditionalHeaders): boolean;
+export declare function shouldReturnPreconditionFailed(method: string | undefined, resource: ConditionalResource, headers: ConditionalHeaders): boolean;
+/**
+ * Generates an entity tag from a representation.
+ *
+ * The digest is SHA-256 truncated to 128 bits. A 32-bit non-cryptographic
+ * hash is unusable here: a strong ETag asserts byte equality, and a 2^32
+ * output space makes a colliding representation findable in roughly 2^16
+ * trials, which is a cache-poisoning primitive.
+ *
+ * @param value - The representation to digest.
+ * @param weak - Whether to emit a weak validator.
+ * @returns The formatted entity tag.
+ */
+export declare function generateETag(value: string | Uint8Array, weak?: boolean): string;
+export declare function createConditionalResource(options?: ConditionalResource | undefined): ConditionalResource;
+export declare function isFresh(resource: ConditionalResource, headers: ConditionalHeaders): boolean;
+//# sourceMappingURL=httpConditional.core.d.ts.map