@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-TTYXOAB7.mjs

@@ -0,0 +1,657 @@
+import {
+  FARM_ANONYMOUS_CLIENT_ADDRESS
+} from "./chunk-BRYPZIMB.mjs";
+import {
+  matchesFarmIfNoneMatch
+} from "./chunk-C6U66WWF.mjs";
+
+// src/image-pattern.ts
+var compiledPatterns = /* @__PURE__ */ new WeakMap();
+function matchesImagePathPattern(value, pattern) {
+  const pathname = pattern.pathname ?? "/**";
+  let compiled = compiledPatterns.get(pattern);
+  if (!compiled || compiled.pathname !== pathname) {
+    const escaped = pathname.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const source = escaped.replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*");
+    compiled = { pathname, matcher: new RegExp(`^${source}$`) };
+    compiledPatterns.set(pattern, compiled);
+  }
+  return compiled.matcher.test(value);
+}
+
+// src/image-server.ts
+var FarmImageRequestError = class extends Error {
+  constructor(code, status, message) {
+    super(message);
+    this.name = "FarmImageRequestError";
+    this.code = code;
+    this.status = status;
+  }
+};
+function createFarmImageHandler(config, options) {
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const cache = new FarmImageMemoryCache(options.cacheEntries ?? 100);
+  const inflight = /* @__PURE__ */ new Map();
+  const allowedWidths = /* @__PURE__ */ new Set([...config.deviceSizes, ...config.imageSizes]);
+  const allowedQualities = new Set(config.qualities);
+  return async function handleFarmImage(request, context) {
+    const requestUrl = new URL(request.url);
+    if (requestUrl.pathname !== config.path) return null;
+    try {
+      const trustedLocalOrigin = resolveTrustedLocalOrigin(
+        context?.trustedLocalOrigin ?? options.trustedLocalOrigin
+      );
+      if (config.provider === "none") {
+        throw new FarmImageRequestError(
+          "DISALLOWED_SOURCE",
+          404,
+          "The Farm image optimizer is disabled"
+        );
+      }
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        throw new FarmImageRequestError(
+          "INVALID_METHOD",
+          405,
+          "The Farm image optimizer only accepts GET and HEAD"
+        );
+      }
+      const sourceUrl = await resolveImageSourceUrl(
+        requestUrl,
+        trustedLocalOrigin,
+        config,
+        options.validateRemoteUrl
+      );
+      const width = parseAllowedInteger(requestUrl.searchParams.get("w"), allowedWidths, "width");
+      const quality = parseAllowedInteger(
+        requestUrl.searchParams.get("q"),
+        allowedQualities,
+        "quality"
+      );
+      const accept = request.headers.get("accept") ?? "";
+      const negotiatedFormat = selectOutputFormat(accept, config.formats) ?? "";
+      const cacheKey = `${sourceUrl.href}
+${width}
+${quality}
+${negotiatedFormat}`;
+      let optimized = cache.get(cacheKey);
+      if (!optimized) {
+        optimized = await runCoalesced(inflight, cacheKey, request.signal, async (signal) => {
+          const fetchedSource = await fetchImageSource(
+            sourceUrl,
+            requestUrl.origin,
+            trustedLocalOrigin,
+            config,
+            fetcher,
+            options.fetchRemote,
+            options.validateRemoteUrl,
+            signal
+          );
+          const source = await readResponseWithLimit(
+            fetchedSource.response,
+            config.maximumResponseBody
+          );
+          const sourceType = detectImageContentType(source);
+          validateSourceType(sourceType, config);
+          throwIfAborted(signal);
+          const result = await options.transform({
+            source,
+            sourceUrl: fetchedSource.url,
+            sourceType,
+            width,
+            quality,
+            accept,
+            formats: config.formats,
+            signal,
+            maximumResponseBody: config.maximumResponseBody
+          });
+          throwIfAborted(signal);
+          validateTransformedResult(result, config);
+          const entry = {
+            ...result,
+            etag: createImageEtag(result.body),
+            cacheControl: `public, max-age=${config.minimumCacheTTL}, stale-while-revalidate=${Math.max(
+              config.minimumCacheTTL,
+              60
+            )}`,
+            expiresAt: Date.now() + config.minimumCacheTTL * 1e3
+          };
+          cache.set(cacheKey, entry);
+          return entry;
+        });
+      }
+      return createOptimizedImageResponse(request, optimized);
+    } catch (error) {
+      if (!(error instanceof FarmImageRequestError) && !isAbortError(error)) {
+        try {
+          options.onError?.(error, request);
+        } catch {
+        }
+      }
+      return createFarmImageErrorResponse(error);
+    }
+  };
+}
+var DEFAULT_IMAGE_TRANSFORM_BODY_LIMIT = 10 * 1024 * 1024;
+function createCloudflareImageTransformer(fetcher = globalThis.fetch) {
+  return async ({ sourceUrl, width, quality, accept, formats, signal, maximumResponseBody }) => {
+    const format = selectOutputFormat(accept, formats);
+    const response = await fetcher(sourceUrl, {
+      signal,
+      redirect: "manual",
+      headers: { accept: "image/*" },
+      cf: {
+        image: {
+          fit: "scale-down",
+          width,
+          quality,
+          ...format ? { format: format === "image/avif" ? "avif" : "webp" } : {}
+        }
+      }
+    });
+    if (response.status >= 300 && response.status < 400) {
+      void cancelResponseBody(response);
+      throw new FarmImageRequestError(
+        "UNSUPPORTED_IMAGE",
+        502,
+        "Source image redirected after validation"
+      );
+    }
+    if (!response.ok) {
+      throw new FarmImageRequestError(
+        "UNSUPPORTED_IMAGE",
+        response.status === 404 ? 404 : 502,
+        "Cloudflare could not transform the source image"
+      );
+    }
+    const body = await readResponseWithLimit(
+      response,
+      maximumResponseBody ?? DEFAULT_IMAGE_TRANSFORM_BODY_LIMIT
+    );
+    return {
+      body,
+      contentType: normalizeImageContentType(response.headers.get("content-type")) || detectImageContentType(body)
+    };
+  };
+}
+function selectOutputFormat(accept, formats) {
+  const qualityByFormat = /* @__PURE__ */ new Map();
+  for (const range of accept.split(",")) {
+    const [rawType, ...parameters] = range.split(";");
+    const type = rawType.trim().toLowerCase();
+    if (!type) continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [rawName, rawValue] = parameter.split("=", 2);
+      if (rawName.trim().toLowerCase() !== "q") continue;
+      const parsed = Number(rawValue?.trim());
+      quality = Number.isFinite(parsed) && parsed >= 0 && parsed <= 1 ? parsed : 0;
+      break;
+    }
+    qualityByFormat.set(type, Math.max(qualityByFormat.get(type) ?? 0, quality));
+  }
+  let selected;
+  let selectedQuality = 0;
+  for (const format of formats) {
+    const quality = qualityByFormat.get(format) ?? 0;
+    if (quality > selectedQuality) {
+      selected = format;
+      selectedQuality = quality;
+    }
+  }
+  return selected;
+}
+function parseIpv6Hextets(value) {
+  let text = value.split("%", 1)[0] ?? "";
+  if (!text.includes(":")) return null;
+  let tail = [];
+  const lastColon = text.lastIndexOf(":");
+  const candidate = text.slice(lastColon + 1);
+  if (candidate.includes(".")) {
+    const octets = parseIpv4Octets(candidate);
+    if (!octets) return null;
+    tail = [octets[0] << 8 | octets[1], octets[2] << 8 | octets[3]];
+    text = text.slice(0, lastColon);
+    if (text.endsWith(":")) text += ":";
+    if (text === "") return null;
+  }
+  const compressionParts = text.split("::");
+  if (compressionParts.length > 2) return null;
+  const parseGroup = (group) => {
+    if (group === "") return [];
+    const hextets = [];
+    for (const part of group.split(":")) {
+      if (!/^[0-9a-f]{1,4}$/.test(part)) return null;
+      hextets.push(Number.parseInt(part, 16));
+    }
+    return hextets;
+  };
+  const head = parseGroup(compressionParts[0] ?? "");
+  const rest = parseGroup(compressionParts[1] ?? "");
+  if (!head || !rest) return null;
+  const explicit = [...head, ...rest, ...tail];
+  if (compressionParts.length === 1) {
+    return explicit.length === 8 ? explicit : null;
+  }
+  if (explicit.length >= 8) return null;
+  const zeros = Array.from({ length: 8 - explicit.length }, () => 0);
+  return [...head, ...zeros, ...rest, ...tail];
+}
+function parseIpv4Octets(value) {
+  const parts = value.split(".");
+  if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/.test(part))) return null;
+  const octets = parts.map(Number);
+  return octets.some((part) => part > 255) ? null : octets;
+}
+function isPrivateIpv4(octets) {
+  const [a, b] = octets;
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && (b === 0 || b === 168) || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function isPrivateImageAddress(address) {
+  const value = address.trim().toLowerCase().replace(/^\[|\]$/g, "");
+  const hextets = parseIpv6Hextets(value);
+  if (hextets) {
+    const [h0, h1, h2, h3, h4, h5, h6, h7] = hextets;
+    const zeroPrefix = h0 === 0 && h1 === 0 && h2 === 0 && h3 === 0;
+    const embedsIpv4 = zeroPrefix && (h4 === 0 && h5 === 65535 || h4 === 65535 && h5 === 0 || h4 === 0 && h5 === 0);
+    if (embedsIpv4 && (h6 !== 0 || h7 !== 0)) {
+      return isPrivateIpv4([h6 >> 8, h6 & 255, h7 >> 8, h7 & 255]);
+    }
+    if (h0 === 100 && h1 === 65435) {
+      if (h2 === 1) return true;
+      if (h2 === 0 && h3 === 0 && h4 === 0 && h5 === 0) {
+        return isPrivateIpv4([h6 >> 8, h6 & 255, h7 >> 8, h7 & 255]);
+      }
+    }
+    if (h0 === 8194) {
+      return isPrivateIpv4([h1 >> 8, h1 & 255, h2 >> 8, h2 & 255]);
+    }
+    if (zeroPrefix && h4 === 0 && h5 === 0 && h6 === 0 && (h7 === 0 || h7 === 1)) return true;
+    if ((h0 & 65024) === 64512) return true;
+    if ((h0 & 65472) === 65152) return true;
+    if ((h0 & 65280) === 65280) return true;
+    return false;
+  }
+  const octets = parseIpv4Octets(value);
+  return octets ? isPrivateIpv4(octets) : false;
+}
+function parseAllowedInteger(raw, allowed, name) {
+  if (!raw || !/^\d+$/.test(raw)) {
+    throw new FarmImageRequestError(
+      "INVALID_PARAMETER",
+      400,
+      `Image ${name} must be an allowed integer`
+    );
+  }
+  const value = Number(raw);
+  if (!allowed.has(value)) {
+    throw new FarmImageRequestError("INVALID_PARAMETER", 400, `Image ${name} is not configured`);
+  }
+  return value;
+}
+async function resolveImageSourceUrl(requestUrl, trustedLocalOrigin, config, validateRemoteUrl) {
+  const raw = requestUrl.searchParams.get("url");
+  if (!raw || raw.length > 4096 || raw.startsWith("//")) {
+    throw new FarmImageRequestError("INVALID_PARAMETER", 400, "Invalid image source URL");
+  }
+  let sourceUrl;
+  try {
+    sourceUrl = raw.startsWith("/") ? new URL(raw, trustedLocalOrigin ?? requestUrl.origin) : new URL(raw);
+  } catch {
+    throw new FarmImageRequestError("INVALID_PARAMETER", 400, "Invalid image source URL");
+  }
+  await validateImageSourceUrl(
+    sourceUrl,
+    requestUrl.origin,
+    trustedLocalOrigin,
+    config,
+    validateRemoteUrl
+  );
+  return sourceUrl;
+}
+async function validateImageSourceUrl(sourceUrl, requestOrigin, trustedLocalOrigin, config, validateRemoteUrl) {
+  if (sourceUrl.protocol !== "http:" && sourceUrl.protocol !== "https:") {
+    throw new FarmImageRequestError("DISALLOWED_SOURCE", 400, "Unsupported image protocol");
+  }
+  if (sourceUrl.username || sourceUrl.password || sourceUrl.hash) {
+    throw new FarmImageRequestError("DISALLOWED_SOURCE", 400, "Unsafe image source URL");
+  }
+  const isLocalSource = sourceUrl.origin === requestOrigin || sourceUrl.origin === trustedLocalOrigin;
+  if (isLocalSource) {
+    if (sourceUrl.pathname === config.path || !matchesLocalPatterns(sourceUrl, config.localPatterns)) {
+      throw new FarmImageRequestError(
+        "DISALLOWED_SOURCE",
+        400,
+        "Local image source is not allowed"
+      );
+    }
+    if (sourceUrl.origin === trustedLocalOrigin) return;
+  } else if (!matchesRemoteSource(sourceUrl, config)) {
+    throw new FarmImageRequestError("DISALLOWED_SOURCE", 400, "Remote image source is not allowed");
+  }
+  if (!config.dangerouslyAllowLocalIP && isPrivateImageAddress(sourceUrl.hostname)) {
+    throw new FarmImageRequestError("PRIVATE_SOURCE", 400, "Private image source is not allowed");
+  }
+  if (!config.dangerouslyAllowLocalIP) {
+    await validateRemoteUrl?.(sourceUrl);
+  }
+}
+async function fetchImageSource(initialUrl, requestOrigin, trustedLocalOrigin, config, fetcher, fetchRemote, validateRemoteUrl, signal) {
+  let currentUrl = initialUrl;
+  for (let redirectCount = 0; ; redirectCount += 1) {
+    throwIfAborted(signal);
+    const isTrustedLocal = currentUrl.origin === trustedLocalOrigin;
+    const sourceFetcher = isTrustedLocal ? fetcher : fetchRemote ?? fetcher;
+    const response = await sourceFetcher(currentUrl, {
+      method: "GET",
+      redirect: "manual",
+      signal,
+      headers: {
+        accept: "image/avif,image/webp,image/*,*/*;q=0.8",
+        "user-agent": "Farm.js Image Optimizer",
+        // This server fetching from itself arrives from a loopback address.
+        // Mark it so the app sees an anonymous visitor, not a trusted local one.
+        ...isTrustedLocal ? { [FARM_IMAGE_SOURCE_HEADER]: getFarmImageSourceToken() } : {}
+      }
+    });
+    if (![301, 302, 303, 307, 308].includes(response.status)) {
+      if (!response.ok) {
+        await cancelResponseBody(response);
+        throw new FarmImageRequestError(
+          "UNSUPPORTED_IMAGE",
+          response.status === 404 ? 404 : 502,
+          "Could not fetch source image"
+        );
+      }
+      return { response, url: currentUrl };
+    }
+    if (redirectCount >= config.maximumRedirects) {
+      await cancelResponseBody(response);
+      throw new FarmImageRequestError(
+        "TOO_MANY_REDIRECTS",
+        400,
+        "Source image exceeded the redirect limit"
+      );
+    }
+    const location = response.headers.get("location");
+    if (!location) {
+      await cancelResponseBody(response);
+      throw new FarmImageRequestError("UNSUPPORTED_IMAGE", 502, "Invalid image redirect");
+    }
+    await cancelResponseBody(response);
+    currentUrl = new URL(location, currentUrl);
+    await validateImageSourceUrl(
+      currentUrl,
+      requestOrigin,
+      trustedLocalOrigin,
+      config,
+      validateRemoteUrl
+    );
+  }
+}
+var FARM_IMAGE_SOURCE_HEADER = "x-farm-image-source";
+var FARM_IMAGE_SOURCE_TOKEN = /* @__PURE__ */ Symbol.for("farm.image.sourceToken");
+function getFarmImageSourceToken() {
+  const state = globalThis;
+  return state[FARM_IMAGE_SOURCE_TOKEN] ?? (state[FARM_IMAGE_SOURCE_TOKEN] = globalThis.crypto.randomUUID());
+}
+function _withFarmImageSourceClientAddress(request, context) {
+  const token = globalThis[FARM_IMAGE_SOURCE_TOKEN];
+  if (!token || request.headers.get(FARM_IMAGE_SOURCE_HEADER) !== token) return context;
+  return { ...context, clientAddress: FARM_ANONYMOUS_CLIENT_ADDRESS };
+}
+function resolveTrustedLocalOrigin(configured) {
+  const value = typeof configured === "function" ? configured() : configured;
+  if (!value) return void 0;
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new TypeError("trustedLocalOrigin must use http or https");
+  }
+  return url.origin;
+}
+async function runCoalesced(inflight, key, requestSignal, run) {
+  let entry = inflight.get(key);
+  if (!entry) {
+    const controller = new AbortController();
+    const created = {
+      controller,
+      waiters: 0,
+      promise: void 0
+    };
+    created.promise = run(controller.signal).finally(() => {
+      if (inflight.get(key) === created) inflight.delete(key);
+    });
+    created.promise.catch(() => {
+    });
+    inflight.set(key, created);
+    entry = created;
+  }
+  const pending = entry;
+  pending.waiters += 1;
+  try {
+    return await raceRequestAbort(pending.promise, requestSignal);
+  } finally {
+    pending.waiters -= 1;
+    if (pending.waiters === 0 && inflight.get(key) === pending) {
+      inflight.delete(key);
+      pending.controller.abort();
+    }
+  }
+}
+function raceRequestAbort(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(signal.reason ?? new Error("Aborted"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new Error("Aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+async function readResponseWithLimit(response, limit) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && Number(contentLength) > limit) {
+    void cancelResponseBody(response);
+    throw new FarmImageRequestError("BODY_TOO_LARGE", 413, "Source image is too large");
+  }
+  if (!response.body) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      byteLength += value.byteLength;
+      if (byteLength > limit) {
+        const error = new FarmImageRequestError("BODY_TOO_LARGE", 413, "Source image is too large");
+        void reader.cancel(error).catch(() => {
+        });
+        throw error;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+async function cancelResponseBody(response) {
+  try {
+    await response.body?.cancel();
+  } catch {
+  }
+}
+function detectImageContentType(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  if (bytes.length >= 6) {
+    const signature = new TextDecoder().decode(bytes.slice(0, 6));
+    if (signature === "GIF87a" || signature === "GIF89a") return "image/gif";
+  }
+  if (bytes.length >= 12) {
+    const riff = new TextDecoder().decode(bytes.slice(0, 4));
+    const webp = new TextDecoder().decode(bytes.slice(8, 12));
+    if (riff === "RIFF" && webp === "WEBP") return "image/webp";
+    const box = new TextDecoder().decode(bytes.slice(4, 12));
+    if (box.startsWith("ftypavif") || box.startsWith("ftypavis")) return "image/avif";
+  }
+  const prefix = new TextDecoder().decode(bytes.slice(0, 512)).trimStart().toLowerCase();
+  if (prefix.startsWith("<svg") || prefix.startsWith("<?xml") && prefix.includes("<svg")) {
+    return "image/svg+xml";
+  }
+  return "";
+}
+function validateSourceType(type, config) {
+  if (!type || type === "image/svg+xml" && !config.dangerouslyAllowSVG) {
+    throw new FarmImageRequestError("UNSUPPORTED_IMAGE", 415, "Unsupported source image");
+  }
+}
+function validateTransformedResult(result, config) {
+  if (!(result.body instanceof Uint8Array) || result.body.byteLength === 0) {
+    throw new Error("The image transformer returned an empty response");
+  }
+  if (result.body.byteLength > config.maximumResponseBody) {
+    throw new FarmImageRequestError("BODY_TOO_LARGE", 413, "Optimized image is too large");
+  }
+  const contentType = normalizeImageContentType(result.contentType);
+  if (!contentType || contentType === "image/svg+xml" && !config.dangerouslyAllowSVG) {
+    throw new Error("The image transformer returned an unsupported content type");
+  }
+  if (detectImageContentType(result.body) !== contentType) {
+    throw new Error("The image transformer returned bytes that do not match their content type");
+  }
+  result.contentType = contentType;
+}
+var OPTIMIZED_IMAGE_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "image/svg+xml"
+]);
+function normalizeImageContentType(value) {
+  const type = value?.split(";", 1)[0].trim().toLowerCase() ?? "";
+  return OPTIMIZED_IMAGE_TYPES.has(type) ? type : "";
+}
+function matchesRemoteSource(url, config) {
+  if (config.domains.includes(url.hostname.toLowerCase())) return true;
+  return config.remotePatterns.some((pattern) => matchesRemotePattern(url, pattern));
+}
+function matchesRemotePattern(url, pattern) {
+  return (!pattern.protocol || url.protocol === `${pattern.protocol}:`) && matchesHostname(url.hostname, pattern.hostname) && (pattern.port === void 0 || url.port === pattern.port) && matchesImagePathPattern(url.pathname, pattern) && (pattern.search === void 0 || url.search === pattern.search);
+}
+function matchesLocalPatterns(url, patterns) {
+  return patterns.some(
+    (pattern) => matchesImagePathPattern(url.pathname, pattern) && (pattern.search === void 0 || url.search === pattern.search)
+  );
+}
+function matchesHostname(hostname, pattern) {
+  const normalizedHostname = hostname.toLowerCase();
+  const normalizedPattern = pattern.toLowerCase();
+  if (normalizedPattern.startsWith("**.")) {
+    const suffix = normalizedPattern.slice(3);
+    return normalizedHostname === suffix || normalizedHostname.endsWith(`.${suffix}`);
+  }
+  if (normalizedPattern.startsWith("*.")) {
+    const suffix = normalizedPattern.slice(2);
+    const prefix = normalizedHostname.slice(0, -(suffix.length + 1));
+    return normalizedHostname.endsWith(`.${suffix}`) && !!prefix && !prefix.includes(".");
+  }
+  return normalizedHostname === normalizedPattern;
+}
+function createOptimizedImageResponse(request, image) {
+  const headers = new Headers({
+    "cache-control": image.cacheControl,
+    "content-type": image.contentType,
+    "content-length": String(image.body.byteLength),
+    "content-disposition": "inline",
+    etag: image.etag,
+    vary: "Accept",
+    "x-content-type-options": "nosniff",
+    // Every optimized image, not only SVG: if a response is ever rendered as a
+    // document, it still cannot run script or load anything.
+    "content-security-policy": "default-src 'none'; sandbox"
+  });
+  if (matchesFarmIfNoneMatch(request.headers.get("if-none-match"), image.etag)) {
+    headers.delete("content-length");
+    return new Response(null, { status: 304, headers });
+  }
+  const body = request.method === "HEAD" ? null : image.body.buffer.slice(
+    image.body.byteOffset,
+    image.body.byteOffset + image.body.byteLength
+  );
+  return new Response(body, { status: 200, headers });
+}
+function createFarmImageErrorResponse(error) {
+  const status = error instanceof FarmImageRequestError ? error.status : isAbortError(error) ? 499 : 500;
+  const headers = new Headers({
+    "cache-control": "no-store",
+    "content-type": "text/plain; charset=utf-8",
+    "x-content-type-options": "nosniff"
+  });
+  if (status === 405) headers.set("allow", "GET, HEAD");
+  const message = status === 400 ? "Invalid image request" : status === 404 ? "Image not found" : status === 405 ? "Method not allowed" : status === 413 ? "Image is too large" : status === 415 ? "Unsupported image" : status === 499 ? "Image request cancelled" : "Image optimization failed";
+  return new Response(message, { status, headers });
+}
+function createImageEtag(bytes) {
+  let hash = 2166136261;
+  for (const byte of bytes) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619);
+  }
+  return `W/"farm-${bytes.byteLength.toString(16)}-${(hash >>> 0).toString(16)}"`;
+}
+function throwIfAborted(signal) {
+  if (signal.aborted) {
+    throw signal.reason instanceof Error ? signal.reason : new DOMException("The image request was aborted", "AbortError");
+  }
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+var FarmImageMemoryCache = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const value = this.entries.get(key);
+    if (!value) return void 0;
+    if (value.expiresAt <= Date.now()) {
+      this.entries.delete(key);
+      return void 0;
+    }
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.capacity <= 0) return;
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    while (this.entries.size > this.capacity) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey === void 0) break;
+      this.entries.delete(oldestKey);
+    }
+  }
+};
+
+export {
+  FarmImageRequestError,
+  createFarmImageHandler,
+  createCloudflareImageTransformer,
+  selectOutputFormat,
+  isPrivateImageAddress,
+  _withFarmImageSourceClientAddress
+};