@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-CFG4QERR.cjs

@@ -0,0 +1,434 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJYT7AN37cjs = require('./chunk-JYT7AN37.cjs');
+
+
+var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
+
+// src/server-http.ts
+function createFarmNodeRequestAbortSignal(req, res) {
+  const controller = new AbortController();
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    req.off("aborted", abort);
+    res.off("close", abortOnEarlyClose);
+    res.off("finish", dispose);
+    controller.signal.removeEventListener("abort", dispose);
+  };
+  const abort = () => controller.abort();
+  const abortOnEarlyClose = () => {
+    if (!res.writableEnded) abort();
+    dispose();
+  };
+  if (req.aborted) {
+    controller.abort();
+    return controller.signal;
+  }
+  req.once("aborted", abort);
+  res.once("close", abortOnEarlyClose);
+  res.once("finish", dispose);
+  controller.signal.addEventListener("abort", dispose, { once: true });
+  return controller.signal;
+}
+var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
+var DEFAULT_FARM_SERVER_HEADERS_TIMEOUT = 6e4;
+var DEFAULT_FARM_SERVER_REQUEST_TIMEOUT = 3e5;
+var DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT = 5e3;
+var DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT = 3e4;
+var MAX_FARM_SERVER_TIMEOUT = 2147483647;
+function createFarmWeakETag(body) {
+  let hash = 2166136261;
+  for (let index = 0; index < body.length; index++) {
+    hash ^= body.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `W/"${(hash >>> 0).toString(16).padStart(8, "0")}"`;
+}
+function matchesFarmIfNoneMatch(value, etag) {
+  const expected = parseEntityTag(trimOptionalWhitespace(etag));
+  if (!expected) return false;
+  const values = Array.isArray(value) ? value : [value];
+  const combined = values.filter((header) => typeof header === "string").join(",");
+  const fieldValue = trimOptionalWhitespace(combined);
+  if (!fieldValue) return false;
+  if (fieldValue === "*") return true;
+  let matched = false;
+  let hasEntityTag = false;
+  for (const candidate of splitEntityTags(fieldValue)) {
+    const token = trimOptionalWhitespace(candidate);
+    if (!token) continue;
+    const parsed = parseEntityTag(token);
+    if (!parsed) return false;
+    hasEntityTag = true;
+    if (parsed === expected) matched = true;
+  }
+  return hasEntityTag && matched;
+}
+function trimOptionalWhitespace(value) {
+  return value.replace(/^[\t ]+|[\t ]+$/g, "");
+}
+function parseEntityTag(value) {
+  const opaqueTag = value.startsWith("W/") ? value.slice(2) : value;
+  if (opaqueTag.length < 2 || opaqueTag[0] !== '"' || opaqueTag.at(-1) !== '"') return null;
+  for (let index = 1; index < opaqueTag.length - 1; index++) {
+    const code = opaqueTag.charCodeAt(index);
+    if (code === 33 || code >= 35 && code <= 126 || code >= 128) continue;
+    return null;
+  }
+  return opaqueTag;
+}
+function splitEntityTags(value) {
+  const tags = [];
+  let start = 0;
+  let quoted = false;
+  for (let index = 0; index < value.length; index++) {
+    const character = value[index];
+    if (character === '"') {
+      quoted = !quoted;
+    } else if (character === "," && !quoted) {
+      tags.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  tags.push(value.slice(start));
+  return tags;
+}
+var FarmRequestBodyError = class extends Error {
+  constructor(code, status, message) {
+    super(message);
+    this.name = "FarmRequestBodyError";
+    this.code = code;
+    this.status = status;
+  }
+};
+function resolveFarmServerConfig(config) {
+  const headersTimeout = parseFarmServerDuration(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.headersTimeout]), () => ( DEFAULT_FARM_SERVER_HEADERS_TIMEOUT)),
+    "server.headersTimeout"
+  );
+  const requestTimeout = parseFarmServerDuration(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _2 => _2.requestTimeout]), () => ( DEFAULT_FARM_SERVER_REQUEST_TIMEOUT)),
+    "server.requestTimeout"
+  );
+  if (headersTimeout > requestTimeout) {
+    throw new TypeError("server.headersTimeout must not exceed server.requestTimeout");
+  }
+  return Object.freeze({
+    bodySizeLimit: parseBodySizeLimit(
+      _nullishCoalesce(_optionalChain([config, 'optionalAccess', _3 => _3.bodySizeLimit]), () => ( DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT)),
+      "server.bodySizeLimit"
+    ),
+    trustProxy: _optionalChain([config, 'optionalAccess', _4 => _4.trustProxy]) === true,
+    headersTimeout,
+    requestTimeout,
+    keepAliveTimeout: parseFarmServerDuration(
+      _nullishCoalesce(_optionalChain([config, 'optionalAccess', _5 => _5.keepAliveTimeout]), () => ( DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT)),
+      "server.keepAliveTimeout"
+    ),
+    gracefulShutdownTimeout: parseFarmServerDuration(
+      _nullishCoalesce(_optionalChain([config, 'optionalAccess', _6 => _6.gracefulShutdownTimeout]), () => ( DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT)),
+      "server.gracefulShutdownTimeout"
+    ),
+    health: resolveFarmServerHealthConfig(_optionalChain([config, 'optionalAccess', _7 => _7.health]))
+  });
+}
+function parseFarmServerDuration(value, optionName = "duration") {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${optionName} must be a positive safe integer`);
+    }
+    if (value > MAX_FARM_SERVER_TIMEOUT) {
+      throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
+    }
+    return value;
+  }
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
+  if (!match) {
+    throw new TypeError(`${optionName} must be milliseconds or a duration such as "30s" or "2m"`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  const milliseconds = Math.floor(amount * multiplier);
+  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
+    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
+  }
+  if (milliseconds > MAX_FARM_SERVER_TIMEOUT) {
+    throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
+  }
+  return milliseconds;
+}
+function resolveFarmServerHealthConfig(config) {
+  if (config === false || config && "enabled" in config && config.enabled === false) {
+    return Object.freeze({
+      enabled: false,
+      livenessPath: "/_farm/health/live",
+      readinessPath: "/_farm/health/ready"
+    });
+  }
+  const livenessPath = normalizeHealthPath(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _8 => _8.livenessPath]), () => ( "/_farm/health/live")),
+    "server.health.livenessPath"
+  );
+  const readinessPath = normalizeHealthPath(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _9 => _9.readinessPath]), () => ( "/_farm/health/ready")),
+    "server.health.readinessPath"
+  );
+  if (livenessPath === readinessPath) {
+    throw new TypeError("server.health livenessPath and readinessPath must be different");
+  }
+  return Object.freeze({ enabled: true, livenessPath, readinessPath });
+}
+function normalizeHealthPath(value, optionName) {
+  const path = value.trim();
+  if (!path.startsWith("/") || path.includes("?") || path.includes("#") || path.includes("*")) {
+    throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
+  }
+  const normalized = path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
+  _chunkYTVSWXEZcjs.assertBrowserStableRoutePath.call(void 0, normalized);
+  return normalized;
+}
+function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${optionName} must be a positive safe integer`);
+    }
+    return value;
+  }
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)?$/);
+  if (!match) {
+    throw new TypeError(`${optionName} must be bytes or a size string such as "500kb" or "10mb"`);
+  }
+  const amount = Number(match[1]);
+  const unit = _nullishCoalesce(match[2], () => ( "b"));
+  const multiplier = {
+    b: 1,
+    kb: 1e3,
+    mb: 1e6,
+    gb: 1e9,
+    kib: 1024,
+    mib: 1048576,
+    gib: 1073741824
+  };
+  const bytes = Math.floor(amount * multiplier[unit]);
+  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
+    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
+  }
+  return bytes;
+}
+function withFarmRequestClientAddress(request, trustProxy, clientAddress) {
+  const requestWithShape = request;
+  if (!requestWithShape.socket) {
+    const forwardedFor = trustProxy ? _optionalChain([request, 'access', _10 => _10.headers, 'access', _11 => _11.get, 'call', _12 => _12("x-forwarded-for"), 'optionalAccess', _13 => _13.split, 'call', _14 => _14(","), 'access', _15 => _15.at, 'call', _16 => _16(-1), 'optionalAccess', _17 => _17.trim, 'call', _18 => _18()]) : void 0;
+    try {
+      requestWithShape.socket = { remoteAddress: forwardedFor || clientAddress || void 0 };
+    } catch (e) {
+    }
+  }
+  return requestWithShape;
+}
+var liveRequestClones = /* @__PURE__ */ new WeakMap();
+function cloneFarmRequest(request) {
+  const cloned = request.clone();
+  if (request.body) {
+    const clones = liveRequestClones.get(request);
+    if (clones) clones.push(cloned);
+    else liveRequestClones.set(request, [cloned]);
+  }
+  return cloned;
+}
+function cloneFarmRequestWithContext(request) {
+  const cloned = cloneFarmRequest(request);
+  _chunkJYT7AN37cjs.copyRequestContext.call(void 0, request, cloned);
+  return cloned;
+}
+async function bufferFarmRequestBody(request, limit) {
+  if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
+    return request;
+  }
+  const bytes = await readFarmRequestBody(request, limit);
+  const body = new Uint8Array(bytes.byteLength);
+  body.set(bytes);
+  const buffered = new Request(request, {
+    // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- GET and HEAD return above.
+    body: body.buffer
+  });
+  _chunkJYT7AN37cjs.copyRequestContext.call(void 0, request, buffered);
+  return buffered;
+}
+async function readFarmRequestBody(request, limit) {
+  try {
+    validateContentLength(request.headers.get("content-length"), limit);
+  } catch (error) {
+    void _optionalChain([request, 'access', _19 => _19.body, 'optionalAccess', _20 => _20.cancel, 'call', _21 => _21(error), 'access', _22 => _22.catch, 'call', _23 => _23(() => {
+    })]);
+    throw error;
+  }
+  throwIfAborted(request.signal);
+  if (!request.body) return new Uint8Array();
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  const cancelBodyRead = () => {
+    void reader.cancel(request.signal.reason).catch(() => {
+    });
+  };
+  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
+  try {
+    while (true) {
+      throwIfAborted(request.signal);
+      const { done, value } = await reader.read();
+      throwIfAborted(request.signal);
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > limit) {
+        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
+        void reader.cancel(error).catch(() => {
+        });
+        throw error;
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    if (request.signal.aborted) throwIfAborted(request.signal);
+    throw error;
+  } finally {
+    request.signal.removeEventListener("abort", cancelBodyRead);
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+var nodeRequestBodies = /* @__PURE__ */ new WeakMap();
+async function readNodeRequestBody(request, limit) {
+  let body = nodeRequestBodies.get(request);
+  if (!body) {
+    body = readNodeRequestBodyOnce(request, limit);
+    nodeRequestBodies.set(request, body);
+  }
+  const bytes = await body;
+  if (bytes.byteLength > limit) {
+    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
+  }
+  return bytes;
+}
+async function readNodeRequestBodyOnce(request, limit) {
+  const rawContentLength = request.headers["content-length"];
+  const contentLength = Array.isArray(rawContentLength) ? rawContentLength[0] : rawContentLength;
+  try {
+    validateContentLength(contentLength, limit);
+  } catch (error) {
+    _optionalChain([request, 'access', _24 => _24.resume, 'optionalCall', _25 => _25()]);
+    throw error;
+  }
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    let settled = false;
+    const cleanup = () => {
+      _optionalChain([request, 'access', _26 => _26.removeListener, 'optionalCall', _27 => _27("data", onData)]);
+      _optionalChain([request, 'access', _28 => _28.removeListener, 'optionalCall', _29 => _29("end", onEnd)]);
+      _optionalChain([request, 'access', _30 => _30.removeListener, 'optionalCall', _31 => _31("error", onError)]);
+    };
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      _optionalChain([request, 'access', _32 => _32.resume, 'optionalCall', _33 => _33()]);
+      reject(error);
+    };
+    const onData = (chunk) => {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += bytes.byteLength;
+      if (total > limit) {
+        rejectOnce(new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large"));
+        return;
+      }
+      chunks.push(bytes);
+    };
+    const onEnd = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(Buffer.concat(chunks, total));
+    };
+    const onError = (error) => rejectOnce(error);
+    request.on("data", onData);
+    request.on("end", onEnd);
+    request.on("error", onError);
+  });
+}
+function createFarmNodeRequestBodyStream(request) {
+  let iterator;
+  return new ReadableStream(
+    {
+      async pull(controller) {
+        _nullishCoalesce(iterator, () => ( (iterator = request[Symbol.asyncIterator]())));
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(
+          value instanceof Uint8Array ? value : new TextEncoder().encode(String(value))
+        );
+      },
+      async cancel(reason) {
+        await _optionalChain([iterator, 'optionalAccess', _34 => _34.return, 'optionalCall', _35 => _35(reason)]);
+      }
+    },
+    // No eager pull: the request stays untouched until the handler reads it.
+    { highWaterMark: 0 }
+  );
+}
+function createFarmRequestBodyErrorResponse(error) {
+  if (!(error instanceof FarmRequestBodyError)) return null;
+  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
+    status: error.status,
+    headers: {
+      "cache-control": "no-store",
+      "content-type": "text/plain; charset=utf-8",
+      "x-content-type-options": "nosniff"
+    }
+  });
+}
+function validateContentLength(value, limit) {
+  const contentLength = _optionalChain([value, 'optionalAccess', _36 => _36.trim, 'call', _37 => _37()]);
+  if (!contentLength) return;
+  if (!/^\d+$/.test(contentLength)) {
+    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
+  }
+  if (Number(contentLength) > limit) {
+    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
+  }
+}
+function throwIfAborted(signal) {
+  if (!signal.aborted) return;
+  if (signal.reason !== void 0) throw signal.reason;
+  throw new DOMException("The operation was aborted", "AbortError");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createFarmNodeRequestAbortSignal = createFarmNodeRequestAbortSignal; exports.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT; exports.createFarmWeakETag = createFarmWeakETag; exports.matchesFarmIfNoneMatch = matchesFarmIfNoneMatch; exports.resolveFarmServerConfig = resolveFarmServerConfig; exports.parseBodySizeLimit = parseBodySizeLimit; exports.withFarmRequestClientAddress = withFarmRequestClientAddress; exports.cloneFarmRequest = cloneFarmRequest; exports.cloneFarmRequestWithContext = cloneFarmRequestWithContext; exports.bufferFarmRequestBody = bufferFarmRequestBody; exports.readFarmRequestBody = readFarmRequestBody; exports.readNodeRequestBody = readNodeRequestBody; exports.createFarmNodeRequestBodyStream = createFarmNodeRequestBodyStream; exports.createFarmRequestBodyErrorResponse = createFarmRequestBodyErrorResponse;

package/dist/chunk-CI4UNQHO.cjs

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkPRFNLQSPcjs = require('./chunk-PRFNLQSP.cjs');
+
+// src/app-markdown.ts
+var _promises = require('fs/promises');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _url = require('url');
+async function createFarmMarkdownRouteModuleFromFile(filePath, options = {}) {
+  const source = await _promises.readFile.call(void 0, filePath, "utf8");
+  return _chunkPRFNLQSPcjs.createFarmMarkdownRouteModule.call(void 0, {
+    source,
+    filePath,
+    components: options.components,
+    config: options.config
+  });
+}
+async function loadFarmMdxComponents(config, options) {
+  const configured = _optionalChain([config, 'optionalAccess', _ => _.components]);
+  if (!configured) {
+    return {};
+  }
+  if (typeof configured !== "string") {
+    return configured;
+  }
+  const modulePath = _path2.default.isAbsolute(configured) ? configured : _path2.default.join(options.root, configured);
+  const mod = options.loadModule ? await options.loadModule(modulePath) : await import(_url.pathToFileURL.call(void 0, modulePath).href);
+  const maybeModule = mod;
+  return maybeModule.components || maybeModule.default || {};
+}
+
+
+
+
+exports.createFarmMarkdownRouteModuleFromFile = createFarmMarkdownRouteModuleFromFile; exports.loadFarmMdxComponents = loadFarmMdxComponents;

package/dist/chunk-CKPTIEDX.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/islands-action-protocol.ts
+var FARM_ACTION_RESULT_KEY = "__farmAction";
+function isFarmIslandsActionResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const meta = value[FARM_ACTION_RESULT_KEY];
+  return !!meta && typeof meta === "object" && Array.isArray(meta.invalidations);
+}
+
+
+
+
+exports.FARM_ACTION_RESULT_KEY = FARM_ACTION_RESULT_KEY; exports.isFarmIslandsActionResult = isFarmIslandsActionResult;

package/dist/chunk-CL2ONP73.cjs

@@ -0,0 +1,180 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkA25FXJ7Dcjs = require('./chunk-A25FXJ7D.cjs');
+
+// src/plugins/compression.ts
+var _stream = require('stream');
+var _zlib = require('zlib');
+var Q_VALUE = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/;
+function parseEncodingQuality(header) {
+  const qualities = /* @__PURE__ */ new Map();
+  for (const item of header.split(",")) {
+    const [rawEncoding, ...parameters] = item.trim().split(";");
+    const encoding = _optionalChain([rawEncoding, 'optionalAccess', _ => _.trim, 'call', _2 => _2(), 'access', _3 => _3.toLowerCase, 'call', _4 => _4()]);
+    if (!encoding) continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [rawName, rawValue] = parameter.split("=", 2);
+      if (_optionalChain([rawName, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6(), 'access', _7 => _7.toLowerCase, 'call', _8 => _8()]) !== "q") continue;
+      const value = _nullishCoalesce(_optionalChain([rawValue, 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]), () => ( ""));
+      quality = Q_VALUE.test(value) ? Number(value) : 0;
+    }
+    qualities.set(encoding, Math.max(_nullishCoalesce(qualities.get(encoding), () => ( 0)), quality));
+  }
+  return qualities;
+}
+function selectEncoding(header) {
+  if (!header.trim()) return void 0;
+  const qualities = parseEncodingQuality(header);
+  const wildcard = _nullishCoalesce(qualities.get("*"), () => ( 0));
+  const quality = (encoding) => _nullishCoalesce(qualities.get(encoding), () => ( wildcard));
+  const brotli = quality("br");
+  const gzip2 = quality("gzip");
+  if (brotli <= 0 && gzip2 <= 0) return void 0;
+  return brotli >= gzip2 ? "br" : "gzip";
+}
+var COMPRESSIBLE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "application/javascript",
+  "application/json",
+  "application/ndjson",
+  "application/wasm",
+  "application/x-ndjson",
+  "application/xml",
+  // Font formats that store raw glyph tables. `font/woff` and `font/woff2` are
+  // deliberately absent: their payloads are already deflate and brotli streams.
+  "application/vnd.ms-fontobject",
+  "font/otf",
+  "font/ttf"
+]);
+var COMPRESSIBLE_MEDIA_TYPE_SUFFIXES = ["+json", "+xml"];
+function isCompressibleMediaType(mediaType) {
+  if (!mediaType) return false;
+  if (mediaType === "text/event-stream") return false;
+  if (mediaType.startsWith("text/")) return true;
+  if (COMPRESSIBLE_MEDIA_TYPES.has(mediaType)) return true;
+  return COMPRESSIBLE_MEDIA_TYPE_SUFFIXES.some((suffix) => mediaType.endsWith(suffix));
+}
+function isCompressionEligible(request, response, bufferedText) {
+  if (
+    // Known buffered text proves a body without reading response.body, which
+    // would create a lazy response's Web stream.
+    request.method !== "HEAD" && bufferedText === void 0 && !response.body || response.status === 204 || response.status === 205 || response.status === 304 || response.headers.has("content-encoding") || response.headers.has("content-range") || _optionalChain([response, 'access', _11 => _11.headers, 'access', _12 => _12.get, 'call', _13 => _13("cache-control"), 'optionalAccess', _14 => _14.toLowerCase, 'call', _15 => _15(), 'access', _16 => _16.includes, 'call', _17 => _17("no-transform")])
+  ) {
+    return false;
+  }
+  const mediaType = _optionalChain([response, 'access', _18 => _18.headers, 'access', _19 => _19.get, 'call', _20 => _20("content-type"), 'optionalAccess', _21 => _21.split, 'call', _22 => _22(";", 1), 'access', _23 => _23[0], 'optionalAccess', _24 => _24.trim, 'call', _25 => _25(), 'access', _26 => _26.toLowerCase, 'call', _27 => _27()]);
+  return isCompressibleMediaType(mediaType);
+}
+function appendVary(headers, value) {
+  const current = headers.get("vary");
+  const values = current ? current.split(",").map((item) => item.trim()).filter(Boolean) : [];
+  if (values.includes("*")) return;
+  if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
+    values.push(value);
+  }
+  headers.set("vary", values.join(", "));
+}
+var BROTLI_QUALITY = 5;
+function compressedHeaders(response, encoding) {
+  const headers = new Headers(response.headers);
+  headers.set("content-encoding", encoding);
+  headers.delete("content-length");
+  appendVary(headers, "Accept-Encoding");
+  const etag = headers.get("etag");
+  if (etag && !etag.startsWith("W/")) {
+    headers.set("etag", `W/${etag}`);
+  }
+  return headers;
+}
+function compressBufferedResponse(response, text, encoding, lazyBody) {
+  const headers = compressedHeaders(response, encoding);
+  if (!lazyBody) _optionalChain([response, 'access', _28 => _28.body, 'optionalAccess', _29 => _29.cancel, 'call', _30 => _30(), 'access', _31 => _31.catch, 'call', _32 => _32(() => {
+  })]);
+  const input = Buffer.from(text);
+  let cancelled = false;
+  const body = new ReadableStream({
+    start(controller) {
+      const done = (error, output) => {
+        if (cancelled) return;
+        if (error) {
+          controller.error(error);
+          return;
+        }
+        controller.enqueue(new Uint8Array(output.buffer, output.byteOffset, output.byteLength));
+        controller.close();
+      };
+      if (encoding === "br") {
+        _zlib.brotliCompress.call(void 0, 
+          input,
+          { params: { [_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY } },
+          done
+        );
+      } else {
+        _zlib.gzip.call(void 0, input, done);
+      }
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function compressResponse(response, encoding) {
+  const compressor = encoding === "br" ? _zlib.createBrotliCompress.call(void 0, {
+    flush: _zlib.constants.BROTLI_OPERATION_FLUSH,
+    params: { [_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY }
+  }) : _zlib.createGzip.call(void 0, { flush: _zlib.constants.Z_SYNC_FLUSH });
+  const input = _stream.Readable.fromWeb(response.body);
+  const output = _stream.pipeline.call(void 0, input, compressor, () => {
+  });
+  const headers = compressedHeaders(response, encoding);
+  return new Response(_stream.Readable.toWeb(output), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function varyIdentityResponse(response) {
+  return _chunkA25FXJ7Dcjs._withFarmResponseHeaders.call(void 0, response, (headers) => appendVary(headers, "Accept-Encoding"));
+}
+function compressFarmResponse(request, response, bufferedText, lazyBody = false) {
+  if (!isCompressionEligible(request, response, bufferedText)) return response;
+  if (request.method === "HEAD") return varyIdentityResponse(response);
+  const encoding = selectEncoding(_nullishCoalesce(request.headers.get("accept-encoding"), () => ( "")));
+  if (!encoding) return varyIdentityResponse(response);
+  return bufferedText === void 0 ? compressResponse(response, encoding) : compressBufferedResponse(response, bufferedText, encoding, lazyBody);
+}
+function createCompressionPlugin({
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse
+} = {}) {
+  return {
+    name: "farm:compression",
+    enforce: "post",
+    runtime: {
+      after({ request, response, isProd }) {
+        if (!isProd) return;
+        return compressFarmResponse(request, response);
+      }
+    },
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+
+
+
+exports.compressFarmResponse = compressFarmResponse; exports.createCompressionPlugin = createCompressionPlugin;