@farm.js/core 0.1.17 → 0.1.18

package/dist/server-plugins.cjs

@@ -1,899 +1,30 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/server-plugins.ts
-var server_plugins_exports = {};
-__export(server_plugins_exports, {
-  createCompressionPlugin: () => createCompressionPlugin,
-  createEnvPlugin: () => createEnvPlugin,
-  createHeadersPlugin: () => createHeadersPlugin,
-  createLoggerPlugin: () => createLoggerPlugin,
-  createRedirectsPlugin: () => createRedirectsPlugin,
-  createRewritesPlugin: () => createRewritesPlugin
-});
-module.exports = __toCommonJS(server_plugins_exports);
 
-// src/navigation-errors.ts
-function isFarmRedirectStatus(status) {
-  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-__name(isFarmRedirectStatus, "isFarmRedirectStatus");
 
-// src/redirect-query.ts
-function appendFarmRedirectQuery(destination, search) {
-  if (!search || search === "?") return destination;
-  const hashIndex = destination.indexOf("#");
-  const pathAndQuery = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
-  if (pathAndQuery.includes("?")) return destination;
-  if (hashIndex === -1) return `${destination}${search}`;
-  return `${pathAndQuery}${search}${destination.slice(hashIndex)}`;
-}
-__name(appendFarmRedirectQuery, "appendFarmRedirectQuery");
 
-// src/server/request.ts
-var import_node_async_hooks = require("async_hooks");
-var import_node_stream = require("stream");
+var _chunkQZRVZSPNcjs = require('./chunk-QZRVZSPN.cjs');
 
-// src/server/request-bridge.ts
-var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
-function getGlobalState() {
-  return globalThis;
-}
-__name(getGlobalState, "getGlobalState");
-function _setCurrentRequestResolver(resolver) {
-  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
-}
-__name(_setCurrentRequestResolver, "_setCurrentRequestResolver");
 
-// src/server/request.ts
-var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
-function getRequestStore() {
-  const runtime = globalThis;
-  const existing = runtime[REQUEST_STORAGE_KEY];
-  if (existing instanceof import_node_async_hooks.AsyncLocalStorage) {
-    return existing;
-  }
-  const storage = new import_node_async_hooks.AsyncLocalStorage();
-  runtime[REQUEST_STORAGE_KEY] = storage;
-  return storage;
-}
-__name(getRequestStore, "getRequestStore");
-var requestStore = getRequestStore();
-_setCurrentRequestResolver(() => requestStore.getStore());
-function resolveFarmRequestURL(req, options = {}) {
-  if (options.origin) {
-    return new URL(req.url || "/", options.origin);
-  }
-  const forwardedHost = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-host"]) : void 0;
-  const fallbackHost = firstForwardedHeaderValue(req.headers.host) || "localhost";
-  const forwardedProto = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-proto"]) : void 0;
-  const normalizedProto = forwardedProto?.toLowerCase();
-  const proto = normalizedProto === "https" || normalizedProto === "http" ? normalizedProto : isEncryptedFarmRequest(req) ? "https" : "http";
-  return new URL(req.url || "/", resolveRequestOrigin(proto, forwardedHost, fallbackHost));
-}
-__name(resolveFarmRequestURL, "resolveFarmRequestURL");
-function isEncryptedFarmRequest(req) {
-  return Boolean(req.socket?.encrypted);
-}
-__name(isEncryptedFarmRequest, "isEncryptedFarmRequest");
-function firstForwardedHeaderValue(value) {
-  const first = Array.isArray(value) ? value[0] : value;
-  const token = first?.split(",", 1)[0]?.trim();
-  return token || void 0;
-}
-__name(firstForwardedHeaderValue, "firstForwardedHeaderValue");
-function resolveRequestOrigin(proto, host, fallback) {
-  for (const candidate of [host, fallback, "localhost"]) {
-    if (!candidate) continue;
-    if (/[\s/?#@\\]/u.test(candidate)) continue;
-    try {
-      const url = new URL(`${proto}://${candidate}`);
-      if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) continue;
-      return url.origin;
-    } catch {
-    }
-  }
-  return `${proto}://localhost`;
-}
-__name(resolveRequestOrigin, "resolveRequestOrigin");
+var _chunkR6AIILIIcjs = require('./chunk-R6AIILII.cjs');
 
-// src/base-path.ts
-var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
-function getFarmGlobalState() {
-  return globalThis;
-}
-__name(getFarmGlobalState, "getFarmGlobalState");
-function getFarmBasePath() {
-  return getFarmGlobalState()[FARM_BASE_PATH] ?? "";
-}
-__name(getFarmBasePath, "getFarmBasePath");
-function applyFarmBasePath(href, basePath = getFarmBasePath()) {
-  const normalizedBasePath = normalizeFarmBasePath(basePath);
-  if (!normalizedBasePath || !href.startsWith("/") || href.startsWith("//")) return href;
-  const canonicalHref = canonicalizeAppRelativeHref(href);
-  if (canonicalHref === normalizedBasePath || canonicalHref.startsWith(`${normalizedBasePath}/`) || canonicalHref.startsWith(`${normalizedBasePath}?`) || canonicalHref.startsWith(`${normalizedBasePath}#`)) {
-    return canonicalHref;
-  }
-  return `${normalizedBasePath}${canonicalHref}`;
-}
-__name(applyFarmBasePath, "applyFarmBasePath");
-function canonicalizeAppRelativeHref(href) {
-  const origin = "http://farm.local";
-  const resolved = new URL(href, origin);
-  if (resolved.origin !== origin) {
-    throw new Error("Farm app-relative href cannot change the URL origin.");
-  }
-  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
-}
-__name(canonicalizeAppRelativeHref, "canonicalizeAppRelativeHref");
-function stripFarmBasePath(pathname, basePath = getFarmBasePath()) {
-  const normalizedBasePath = normalizeFarmBasePath(basePath);
-  if (!normalizedBasePath) return pathname || "/";
-  if (pathname === normalizedBasePath) return "/";
-  if (!pathname.startsWith(`${normalizedBasePath}/`)) return pathname || "/";
-  return pathname.slice(normalizedBasePath.length) || "/";
-}
-__name(stripFarmBasePath, "stripFarmBasePath");
-function normalizeFarmBasePath(basePath) {
-  if (!basePath || basePath === "/") return "";
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  if (hasUnstableCharacters(basePath)) {
-    throw new Error("Farm basePath cannot contain backslashes or control characters.");
-  }
-  const pathname = basePath.trim();
-  if (!pathname || pathname === "/") return "";
-  if (pathname.includes("?") || pathname.includes("#")) {
-    throw new Error("Farm basePath cannot contain a query string or hash.");
-  }
-  if (pathname.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(pathname)) {
-    throw new Error('Farm basePath must be a pathname such as "/docs", not a URL.');
-  }
-  for (const segment of pathname.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("Farm basePath cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("Farm basePath cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('Farm basePath cannot contain "." or ".." path segments.');
-    }
-  }
-  return `/${pathname}`.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
-}
-__name(normalizeFarmBasePath, "normalizeFarmBasePath");
 
-// src/i18n/routing.ts
-function resolveFarmLocalePath(pathname, config) {
-  const normalized = normalizePathname(stripFarmBasePath(pathname, config.basePath));
-  if (config.routing === "none") {
-    return { pathname: normalized, explicit: false };
-  }
-  const segments = normalized.split("/").filter(Boolean);
-  const firstSegment = segments[0];
-  const locale = config.locales.find(
-    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
-  );
-  if (!locale) {
-    return { pathname: normalized, explicit: false };
-  }
-  const remaining = segments.slice(1);
-  return {
-    locale,
-    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
-    explicit: true
-  };
-}
-__name(resolveFarmLocalePath, "resolveFarmLocalePath");
-function localizeFarmPathname(pathname, locale, config) {
-  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
-  let localizedPathname = internalPathname;
-  if (config.routing === "none") {
-    return applyFarmBasePath(localizedPathname, config.basePath);
-  }
-  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
-    return applyFarmBasePath(localizedPathname, config.basePath);
-  }
-  localizedPathname = internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
-  return applyFarmBasePath(localizedPathname, config.basePath);
-}
-__name(localizeFarmPathname, "localizeFarmPathname");
-function localizeFarmHref(href, locale, config) {
-  if (!href.startsWith("/") || href.startsWith("//")) return href;
-  const url = new URL(href, "http://farm.local");
-  url.pathname = localizeFarmPathname(url.pathname, locale, config);
-  return `${url.pathname}${url.search}${url.hash}`;
-}
-__name(localizeFarmHref, "localizeFarmHref");
-function normalizePathname(pathname) {
-  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  if (withLeadingSlash === "/") return "/";
-  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
-}
-__name(normalizePathname, "normalizePathname");
+var _chunkYZTASLPQcjs = require('./chunk-YZTASLPQ.cjs');
+require('./chunk-YX3DBN4M.cjs');
+require('./chunk-DVM4FKZL.cjs');
+require('./chunk-OX6O6WVA.cjs');
+require('./chunk-5ZSWG4UX.cjs');
+require('./chunk-US2QVW3E.cjs');
+require('./chunk-U4KT7QP3.cjs');
+require('./chunk-BIDYX3SL.cjs');
+require('./chunk-I57LW5VZ.cjs');
+require('./chunk-NO3WWW3N.cjs');
+require('./chunk-S3JO3N4H.cjs');
 
-// src/routing/specificity.ts
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
 
-// src/utils/decode.ts
-function decodeRouteSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodeRouteSegment, "decodeRouteSegment");
-function canonicalizeRequestPathname(pathname) {
-  const encoded = pathname.includes("%");
-  if (!encoded && !pathname.includes("//")) return pathname;
-  const collapsed = pathname.replace(/\/{2,}/g, "/");
-  if (!encoded) return collapsed;
-  return collapsed.split("/").map((segment) => {
-    const decoded = decodeRouteSegment(segment);
-    return decoded === segment ? segment : decoded.replace(/\//g, "%2F");
-  }).join("/");
-}
-__name(canonicalizeRequestPathname, "canonicalizeRequestPathname");
 
-// src/plugins/route-pattern.ts
-function validateConfigRouteSource(source, field = "Config route source") {
-  if (typeof source !== "string" || source.length === 0) {
-    throw new TypeError(`${field} must be a non-empty pathname pattern.`);
-  }
-  if (source.trim() !== source) {
-    throw new Error(`${field} cannot contain leading or trailing whitespace.`);
-  }
-  if (!source.startsWith("/")) {
-    throw new Error(`${field} must start with "/".`);
-  }
-  if (source.includes("?") || source.includes("#")) {
-    throw new Error(`${field} must be a pathname without a query string or hash.`);
-  }
-  if (source.includes("\\") || Array.from(source).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  })) {
-    throw new Error(`${field} cannot contain backslashes or control characters.`);
-  }
-  assertBrowserStableRoutePath(source);
-  return source;
-}
-__name(validateConfigRouteSource, "validateConfigRouteSource");
-function resolveConfigRoutePathname(pathname, i18n) {
-  const localizedPathname = i18n?.enabled ? resolveFarmLocalePath(pathname, i18n) : { pathname };
-  return {
-    pathname: normalizeConfigRoutePathname(canonicalizeRequestPathname(localizedPathname.pathname)),
-    ...i18n?.enabled && "locale" in localizedPathname ? { locale: localizedPathname.locale } : {}
-  };
-}
-__name(resolveConfigRoutePathname, "resolveConfigRoutePathname");
-function normalizeConfigRoutePathname(pathname) {
-  if (!pathname || pathname === "/") return "/";
-  return pathname.endsWith("/") ? pathname.replace(/\/+$/, "") || "/" : pathname;
-}
-__name(normalizeConfigRoutePathname, "normalizeConfigRoutePathname");
-function localizeConfigRouteDestination(destination, locale, i18n) {
-  return locale && i18n?.enabled ? localizeFarmHref(destination, locale, i18n) : destination;
-}
-__name(localizeConfigRouteDestination, "localizeConfigRouteDestination");
-function appendCatchAll(pattern) {
-  return pattern.endsWith("/") ? `${pattern.slice(0, -1)}(?:/(.*))?` : `${pattern}(.*)`;
-}
-__name(appendCatchAll, "appendCatchAll");
-function escapeRegexCharacter(character) {
-  return /[\\^$.*+?()[\]{}|]/.test(character) ? `\\${character}` : character;
-}
-__name(escapeRegexCharacter, "escapeRegexCharacter");
-function compileConfigRoutePattern(source) {
-  validateConfigRouteSource(source);
-  const tokens = [];
-  let pattern = "";
-  let captureIndex = 1;
-  for (let index = 0; index < source.length; ) {
-    const rest = source.slice(index);
-    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
-    if (parameter) {
-      tokens.push({
-        kind: "param",
-        name: parameter[1],
-        captureIndex,
-        catchAll: parameter[2] === "*"
-      });
-      pattern = parameter[2] ? appendCatchAll(pattern) : `${pattern}([^/]+)`;
-      captureIndex += 1;
-      index += parameter[0].length;
-      continue;
-    }
-    if (source[index] === "*") {
-      tokens.push({ kind: "wildcard", captureIndex });
-      pattern = appendCatchAll(pattern);
-      captureIndex += 1;
-      index += 1;
-      continue;
-    }
-    pattern += escapeRegexCharacter(source[index]);
-    index += 1;
-  }
-  return { regex: new RegExp(`^${pattern}$`), tokens };
-}
-__name(compileConfigRoutePattern, "compileConfigRoutePattern");
-function interpolateConfigRouteDestination(destination, match, tokens) {
-  const namedCaptures = /* @__PURE__ */ new Map();
-  const wildcardCaptures = [];
-  const captures = /* @__PURE__ */ new Map();
-  for (const token of tokens) {
-    const value = normalizeConfigRouteCapture(
-      match[token.captureIndex] || "",
-      token.kind === "wildcard" || token.catchAll
-    );
-    captures.set(token.captureIndex, value);
-    if (token.kind === "param") {
-      namedCaptures.set(token.name, value);
-    } else {
-      wildcardCaptures.push(value);
-    }
-  }
-  let result = "";
-  let wildcardIndex = 0;
-  for (let index = 0; index < destination.length; ) {
-    const rest = destination.slice(index);
-    const parameter = rest.match(/^:([A-Za-z0-9_]+)(\*)?/);
-    if (parameter) {
-      const value = namedCaptures.get(parameter[1]);
-      result += value === void 0 ? parameter[0] : value;
-      index += parameter[0].length;
-      continue;
-    }
-    const capture = rest.match(/^\$(\d+)/);
-    if (capture) {
-      result += captures.get(Number(capture[1])) ?? "";
-      index += capture[0].length;
-      continue;
-    }
-    if (destination[index] === "*") {
-      result += wildcardCaptures[wildcardIndex] || "";
-      wildcardIndex += 1;
-      index += 1;
-      continue;
-    }
-    result += destination[index];
-    index += 1;
-  }
-  return result;
-}
-__name(interpolateConfigRouteDestination, "interpolateConfigRouteDestination");
-function normalizeConfigRouteCapture(value, catchAll) {
-  const segments = catchAll ? value.split("/").filter(Boolean) : [value];
-  return segments.map((segment) => encodeConfigRouteSegment(decodeConfigRouteSegment(segment))).join("/");
-}
-__name(normalizeConfigRouteCapture, "normalizeConfigRouteCapture");
-function decodeConfigRouteSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodeConfigRouteSegment, "decodeConfigRouteSegment");
-function encodeConfigRouteSegment(segment) {
-  return encodeURIComponent(segment).replace(
-    /[!'()*]/g,
-    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
-  );
-}
-__name(encodeConfigRouteSegment, "encodeConfigRouteSegment");
 
-// src/plugins/redirects.ts
-function createRedirectsPlugin(redirects, {
-  beforeRequest: overrideBeforeRequest,
-  afterResponse: overrideAfterResponse,
-  i18n
-} = {}) {
-  for (const redirect of redirects) {
-    if (redirect.statusCode !== void 0 && !isFarmRedirectStatus(redirect.statusCode)) {
-      throw new RangeError(
-        `Redirect "${redirect.source}" statusCode must be one of 301, 302, 303, 307, or 308.`
-      );
-    }
-  }
-  const compiledRedirects = redirects.map((redirect) => ({
-    redirect,
-    pattern: compileConfigRoutePattern(redirect.source)
-  }));
-  return {
-    name: "farm:redirects",
-    enforce: "pre",
-    async beforeRequest(req, res, context) {
-      if (overrideBeforeRequest) {
-        await overrideBeforeRequest(req, res, context);
-      }
-      const url = resolveFarmRequestURL(req);
-      const routePath = resolveConfigRoutePathname(url.pathname, i18n);
-      const pathname = routePath.pathname;
-      for (const { redirect, pattern } of compiledRedirects) {
-        const match = pathname.match(pattern.regex);
-        if (match) {
-          const localizedDestination = localizeConfigRouteDestination(
-            interpolateConfigRouteDestination(redirect.destination, match, pattern.tokens),
-            routePath.locale,
-            i18n
-          );
-          const destination = appendFarmRedirectQuery(localizedDestination, url.search);
-          const statusCode = redirect.statusCode ?? (redirect.permanent ? 308 : 307);
-          res.writeHead(statusCode, {
-            Location: destination
-          });
-          res.end();
-          return;
-        }
-      }
-    },
-    async afterResponse(req, res, context) {
-      if (overrideAfterResponse) {
-        await overrideAfterResponse(req, res, context);
-      }
-    }
-  };
-}
-__name(createRedirectsPlugin, "createRedirectsPlugin");
 
-// src/plugins/headers.ts
-var FARM_CONFIG_HEADERS_FINALIZER = /* @__PURE__ */ Symbol.for("farm.configHeadersFinalizer");
-function appendConfiguredLinkHeader(res, value) {
-  const current = res.getHeader("Link");
-  if (current === void 0) {
-    res.setHeader("Link", value);
-    return;
-  }
-  const currentValue = Array.isArray(current) ? current.join(", ") : String(current);
-  if (currentValue !== value && !currentValue.endsWith(`, ${value}`)) {
-    res.setHeader("Link", `${currentValue}, ${value}`);
-  }
-}
-__name(appendConfiguredLinkHeader, "appendConfiguredLinkHeader");
-function appendConfiguredSetCookieHeader(res, value) {
-  const current = res.getHeader("Set-Cookie");
-  if (current === void 0) {
-    res.setHeader("Set-Cookie", value);
-    return;
-  }
-  const values = (Array.isArray(current) ? current : [current]).map(String);
-  if (!values.includes(value)) {
-    res.setHeader("Set-Cookie", [...values, value]);
-  }
-}
-__name(appendConfiguredSetCookieHeader, "appendConfiguredSetCookieHeader");
-function applyResponseHeaders(res, matchedHeaders) {
-  for (const headers of matchedHeaders) {
-    for (const header of headers) {
-      const key = header.key.toLowerCase();
-      if (key === "link") {
-        appendConfiguredLinkHeader(res, header.value);
-      } else if (key === "set-cookie") {
-        appendConfiguredSetCookieHeader(res, header.value);
-      } else {
-        res.setHeader(header.key, header.value);
-      }
-    }
-  }
-}
-__name(applyResponseHeaders, "applyResponseHeaders");
-function applyWriteHeadHeaders(res, headers) {
-  if (Array.isArray(headers)) {
-    let setCookieWritten = false;
-    for (let index = 0; index + 1 < headers.length; index += 2) {
-      const key = String(headers[index]);
-      const value = headers[index + 1];
-      if (key.toLowerCase() === "set-cookie" && setCookieWritten) {
-        const current = res.getHeader("Set-Cookie");
-        const values = (Array.isArray(current) ? current : [current]).filter(
-          (entry) => entry !== void 0
-        );
-        res.setHeader("Set-Cookie", [...values, ...Array.isArray(value) ? value : [value]]);
-      } else {
-        res.setHeader(key, value);
-        if (key.toLowerCase() === "set-cookie") setCookieWritten = true;
-      }
-    }
-    return;
-  }
-  if (!headers || typeof headers !== "object") return;
-  for (const [key, value] of Object.entries(headers)) {
-    if (value !== void 0) res.setHeader(key, value);
-  }
-}
-__name(applyWriteHeadHeaders, "applyWriteHeadHeaders");
-function createHeadersPlugin(headers, {
-  beforeRequest: overrideBeforeRequest,
-  afterResponse: overrideAfterResponse,
-  i18n
-} = {}) {
-  const compiledHeaders = headers.map((config) => ({
-    config,
-    pattern: compileConfigRoutePattern(config.source)
-  }));
-  return {
-    name: "farm:headers",
-    enforce: "pre",
-    async beforeRequest(req, res, context) {
-      if (overrideBeforeRequest) {
-        await overrideBeforeRequest(req, res, context);
-      }
-      const url = resolveFarmRequestURL(req);
-      const pathname = resolveConfigRoutePathname(url.pathname, i18n).pathname;
-      const matchedHeaders = compiledHeaders.filter(({ pattern }) => pattern.regex.test(pathname)).map(({ config }) => config.headers);
-      applyResponseHeaders(res, matchedHeaders);
-      const responseWithFinalizer = res;
-      if (matchedHeaders.length === 0 || responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER]) {
-        return;
-      }
-      responseWithFinalizer[FARM_CONFIG_HEADERS_FINALIZER] = true;
-      const writeHead = res.writeHead;
-      res.writeHead = ((statusCode, ...args) => {
-        const statusMessage = typeof args[0] === "string" ? args.shift() : void 0;
-        applyWriteHeadHeaders(res, args[0]);
-        applyResponseHeaders(res, matchedHeaders);
-        return statusMessage === void 0 ? writeHead.call(res, statusCode) : writeHead.call(res, statusCode, statusMessage);
-      });
-    },
-    async afterResponse(req, res, context) {
-      if (overrideAfterResponse) {
-        await overrideAfterResponse(req, res, context);
-      }
-    }
-  };
-}
-__name(createHeadersPlugin, "createHeadersPlugin");
 
-// src/plugins/rewrites.ts
-var FARM_CONFIG_REWRITES_PLUGIN_NAME = "farm:rewrites";
-function createRewritesPlugin(rewrites, {
-  beforeRequest: overrideBeforeRequest,
-  afterResponse: overrideAfterResponse,
-  i18n
-} = {}) {
-  const compiledRewrites = rewrites.map((rewrite) => ({
-    rewrite,
-    pattern: compileConfigRoutePattern(rewrite.source)
-  }));
-  return {
-    name: FARM_CONFIG_REWRITES_PLUGIN_NAME,
-    enforce: "pre",
-    async beforeRequest(req, res, context) {
-      if (overrideBeforeRequest) {
-        await overrideBeforeRequest(req, res, context);
-      }
-      const url = resolveFarmRequestURL(req);
-      const routePath = resolveConfigRoutePathname(url.pathname, i18n);
-      const pathname = routePath.pathname;
-      for (const { rewrite, pattern } of compiledRewrites) {
-        const match = pathname.match(pattern.regex);
-        if (match) {
-          const newPath = localizeConfigRouteDestination(
-            interpolateConfigRouteDestination(rewrite.destination, match, pattern.tokens),
-            routePath.locale,
-            i18n
-          );
-          const destinationUrl = new URL(newPath, url);
-          if (!destinationUrl.search && url.search) {
-            destinationUrl.search = url.search;
-          }
-          req.url = destinationUrl.origin === url.origin ? destinationUrl.pathname + destinationUrl.search : destinationUrl.href;
-          break;
-        }
-      }
-    },
-    async afterResponse(req, res, context) {
-      if (overrideAfterResponse) {
-        await overrideAfterResponse(req, res, context);
-      }
-    }
-  };
-}
-__name(createRewritesPlugin, "createRewritesPlugin");
 
-// src/plugins/env.ts
-function createEnvPlugin(env, {
-  beforeRequest: overrideBeforeRequest,
-  afterResponse: overrideAfterResponse
-} = {}) {
-  return {
-    name: "farm:env",
-    configResolved(config, context) {
-      for (const [key, value] of Object.entries(env)) {
-        process.env[key] = value;
-      }
-    },
-    async beforeRequest(req, res, context) {
-      if (overrideBeforeRequest) {
-        await overrideBeforeRequest(req, res, context);
-      }
-    },
-    async afterResponse(req, res, context) {
-      if (overrideAfterResponse) {
-        await overrideAfterResponse(req, res, context);
-      }
-    }
-  };
-}
-__name(createEnvPlugin, "createEnvPlugin");
-
-// src/plugins/compression.ts
-var import_node_stream2 = require("stream");
-var import_node_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 = rawEncoding?.trim().toLowerCase();
-    if (!encoding) continue;
-    let quality = 1;
-    for (const parameter of parameters) {
-      const [rawName, rawValue] = parameter.split("=", 2);
-      if (rawName?.trim().toLowerCase() !== "q") continue;
-      const value = rawValue?.trim() ?? "";
-      quality = Q_VALUE.test(value) ? Number(value) : 0;
-    }
-    qualities.set(encoding, Math.max(qualities.get(encoding) ?? 0, quality));
-  }
-  return qualities;
-}
-__name(parseEncodingQuality, "parseEncodingQuality");
-function selectEncoding(header) {
-  if (!header.trim()) return void 0;
-  const qualities = parseEncodingQuality(header);
-  const wildcard = qualities.get("*") ?? 0;
-  const quality = /* @__PURE__ */ __name((encoding) => qualities.get(encoding) ?? wildcard, "quality");
-  const brotli = quality("br");
-  const gzip2 = quality("gzip");
-  if (brotli <= 0 && gzip2 <= 0) return void 0;
-  return brotli >= gzip2 ? "br" : "gzip";
-}
-__name(selectEncoding, "selectEncoding");
-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));
-}
-__name(isCompressibleMediaType, "isCompressibleMediaType");
-function isCompressionEligible(request, response) {
-  if (request.method !== "HEAD" && !response.body || response.status === 204 || response.status === 205 || response.status === 304 || response.headers.has("content-encoding") || response.headers.has("content-range") || response.headers.get("cache-control")?.toLowerCase().includes("no-transform")) {
-    return false;
-  }
-  const mediaType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
-  return isCompressibleMediaType(mediaType);
-}
-__name(isCompressionEligible, "isCompressionEligible");
-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(", "));
-}
-__name(appendVary, "appendVary");
-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;
-}
-__name(compressedHeaders, "compressedHeaders");
-function compressBufferedResponse(response, text, encoding) {
-  const headers = compressedHeaders(response, encoding);
-  response.body?.cancel().catch(() => {
-  });
-  const input = Buffer.from(text);
-  let cancelled = false;
-  const body = new ReadableStream({
-    start(controller) {
-      const done = /* @__PURE__ */ __name((error, output) => {
-        if (cancelled) return;
-        if (error) {
-          controller.error(error);
-          return;
-        }
-        controller.enqueue(new Uint8Array(output.buffer, output.byteOffset, output.byteLength));
-        controller.close();
-      }, "done");
-      if (encoding === "br") {
-        (0, import_node_zlib.brotliCompress)(
-          input,
-          { params: { [import_node_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY } },
-          done
-        );
-      } else {
-        (0, import_node_zlib.gzip)(input, done);
-      }
-    },
-    cancel() {
-      cancelled = true;
-    }
-  });
-  return new Response(body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-__name(compressBufferedResponse, "compressBufferedResponse");
-function compressResponse(response, encoding) {
-  const compressor = encoding === "br" ? (0, import_node_zlib.createBrotliCompress)({
-    flush: import_node_zlib.constants.BROTLI_OPERATION_FLUSH,
-    params: { [import_node_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY }
-  }) : (0, import_node_zlib.createGzip)({ flush: import_node_zlib.constants.Z_SYNC_FLUSH });
-  const input = import_node_stream2.Readable.fromWeb(response.body);
-  const output = (0, import_node_stream2.pipeline)(input, compressor, () => {
-  });
-  const headers = compressedHeaders(response, encoding);
-  return new Response(import_node_stream2.Readable.toWeb(output), {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-__name(compressResponse, "compressResponse");
-function varyIdentityResponse(response) {
-  const headers = new Headers(response.headers);
-  appendVary(headers, "Accept-Encoding");
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-__name(varyIdentityResponse, "varyIdentityResponse");
-function compressFarmResponse(request, response, bufferedText) {
-  if (!isCompressionEligible(request, response)) return response;
-  if (request.method === "HEAD") return varyIdentityResponse(response);
-  const encoding = selectEncoding(request.headers.get("accept-encoding") ?? "");
-  if (!encoding) return varyIdentityResponse(response);
-  return bufferedText === void 0 ? compressResponse(response, encoding) : compressBufferedResponse(response, bufferedText, encoding);
-}
-__name(compressFarmResponse, "compressFarmResponse");
-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);
-      }
-    }
-  };
-}
-__name(createCompressionPlugin, "createCompressionPlugin");
-
-// src/plugins/logger.ts
-function createLoggerPlugin({
-  beforeRequest,
-  afterResponse
-} = {}) {
-  const plugin = {
-    name: "farm:logger",
-    enforce: "post"
-  };
-  if (beforeRequest) {
-    plugin.beforeRequest = async (req, res, context) => {
-      await beforeRequest(req, res, context);
-    };
-  }
-  if (afterResponse) {
-    plugin.afterResponse = async (req, res, context) => {
-      await afterResponse(req, res, context);
-    };
-  }
-  return plugin;
-}
-__name(createLoggerPlugin, "createLoggerPlugin");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createCompressionPlugin,
-  createEnvPlugin,
-  createHeadersPlugin,
-  createLoggerPlugin,
-  createRedirectsPlugin,
-  createRewritesPlugin
-});
+exports.createCompressionPlugin = _chunkR6AIILIIcjs.createCompressionPlugin; exports.createEnvPlugin = _chunkQZRVZSPNcjs.createEnvPlugin; exports.createHeadersPlugin = _chunkQZRVZSPNcjs.createHeadersPlugin; exports.createLoggerPlugin = _chunkQZRVZSPNcjs.createLoggerPlugin; exports.createRedirectsPlugin = _chunkQZRVZSPNcjs.createRedirectsPlugin; exports.createRewritesPlugin = _chunkYZTASLPQcjs.createRewritesPlugin;