@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-BYODCJD6.cjs

@@ -0,0 +1,663 @@
+"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 _chunkXGC343EYcjs = require('./chunk-XGC343EY.cjs');
+
+
+var _chunkE3UK5IIBcjs = require('./chunk-E3UK5IIB.cjs');
+
+
+
+
+var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
+
+
+var _chunkBIDYX3SLcjs = require('./chunk-BIDYX3SL.cjs');
+
+
+var _chunkI57LW5VZcjs = require('./chunk-I57LW5VZ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/middleware/production-runtime.ts
+var FARM_SET_COOKIE_HEADERS = /* @__PURE__ */ Symbol("farm.setCookieHeaders");
+var _WebResponseHeaderMap = class _WebResponseHeaderMap extends Map {
+  constructor() {
+    super(...arguments);
+    this.setCookies = [];
+  }
+  set(key, value) {
+    if (key.toLowerCase() === "set-cookie") {
+      this.setCookies = [value];
+      super.set("Set-Cookie", value);
+      return this;
+    }
+    return super.set(key, value);
+  }
+  delete(key) {
+    if (key.toLowerCase() === "set-cookie") {
+      this.setCookies = [];
+      return super.delete("Set-Cookie") || super.delete("set-cookie");
+    }
+    return super.delete(key);
+  }
+  clear() {
+    this.setCookies = [];
+    super.clear();
+  }
+  appendSetCookie(value) {
+    this.setCookies.push(value);
+    super.set("Set-Cookie", value);
+  }
+  replaceSetCookies(values) {
+    this.setCookies = [...values];
+    super.delete("Set-Cookie");
+    super.delete("set-cookie");
+    if (this.setCookies.length > 0) {
+      super.set("Set-Cookie", this.setCookies[this.setCookies.length - 1]);
+    }
+  }
+  getSetCookies() {
+    return this.setCookies;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _WebResponseHeaderMap, "WebResponseHeaderMap");
+var WebResponseHeaderMap = _WebResponseHeaderMap;
+var _WebCookieJar = class _WebCookieJar {
+  constructor(request, headers) {
+    this.headers = headers;
+    this.cookies = _chunkXGC343EYcjs.parseMiddlewareCookieHeader.call(void 0, request.headers.get("cookie"));
+  }
+  get(name) {
+    return this.cookies[name];
+  }
+  set(name, value, options = {}) {
+    this.cookies[name] = value;
+    const cookieString = _chunkXGC343EYcjs.serializeMiddlewareCookie.call(void 0, name, value, options);
+    this.headers.appendSetCookie(cookieString);
+  }
+  delete(name, options = {}) {
+    delete this.cookies[name];
+    this.headers.appendSetCookie(_chunkXGC343EYcjs.serializeMiddlewareCookieDeletion.call(void 0, name, options));
+  }
+  getAll() {
+    return { ...this.cookies };
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _WebCookieJar, "WebCookieJar");
+var WebCookieJar = _WebCookieJar;
+function mapToHeaders(map) {
+  const headers = new Headers();
+  for (const [key, value] of map) {
+    if (key.toLowerCase() === "set-cookie") continue;
+    headers.set(key, value);
+  }
+  for (const cookie of map.getSetCookies()) {
+    headers.append("Set-Cookie", cookie);
+  }
+  return headers;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mapToHeaders, "mapToHeaders");
+function headersToRecord(headers) {
+  return Object.fromEntries(headers);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, headersToRecord, "headersToRecord");
+function isMiddlewareResponse(value) {
+  return value instanceof Response;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isMiddlewareResponse, "isMiddlewareResponse");
+function findHeaderName(headers, name) {
+  const normalizedName = name.toLowerCase();
+  return [...headers.keys()].find((key) => key.toLowerCase() === normalizedName);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findHeaderName, "findHeaderName");
+function createResponseShim(headers) {
+  const bodyChunks = [];
+  const encoder = new TextEncoder();
+  const response = {
+    headersSent: false,
+    writableEnded: false,
+    statusCode: 200,
+    statusMessage: "",
+    setHeader(name, value) {
+      const existingName = findHeaderName(headers, name);
+      if (existingName) headers.delete(existingName);
+      if (name.toLowerCase() === "set-cookie") {
+        headers.replaceSetCookies(Array.isArray(value) ? value.map(String) : [String(value)]);
+      } else {
+        headers.set(name, Array.isArray(value) ? value.join(", ") : String(value));
+      }
+      return this;
+    },
+    getHeader(name) {
+      if (name.toLowerCase() === "set-cookie") {
+        const cookies = headers.getSetCookies();
+        return cookies.length > 0 ? [...cookies] : void 0;
+      }
+      const existingName = findHeaderName(headers, name);
+      return existingName ? headers.get(existingName) : void 0;
+    },
+    hasHeader(name) {
+      return name.toLowerCase() === "set-cookie" ? headers.getSetCookies().length > 0 : findHeaderName(headers, name) !== void 0;
+    },
+    getHeaderNames() {
+      return [...headers.keys()].map((name) => name.toLowerCase());
+    },
+    getHeaders() {
+      return Object.fromEntries(
+        [...headers.keys()].map((name) => [name.toLowerCase(), this.getHeader(name)])
+      );
+    },
+    removeHeader(name) {
+      const existingName = findHeaderName(headers, name);
+      if (existingName) headers.delete(existingName);
+    },
+    appendHeader(name, value) {
+      const values = Array.isArray(value) ? value.map(String) : [String(value)];
+      if (name.toLowerCase() === "set-cookie") {
+        for (const item of values) headers.appendSetCookie(item);
+        return this;
+      }
+      const existing = this.getHeader(name);
+      return this.setHeader(name, existing ? `${String(existing)}, ${values.join(", ")}` : values);
+    },
+    writeHead(status, statusMessageOrHeaders, responseHeaders) {
+      this.statusCode = status;
+      const nextHeaders = typeof statusMessageOrHeaders === "string" ? responseHeaders : statusMessageOrHeaders;
+      if (typeof statusMessageOrHeaders === "string") {
+        this.statusMessage = statusMessageOrHeaders;
+      }
+      if (nextHeaders) {
+        for (const [key, value] of Object.entries(nextHeaders)) {
+          this.setHeader(key, value);
+        }
+      }
+      this.headersSent = true;
+      return this;
+    },
+    flushHeaders() {
+      this.headersSent = true;
+    },
+    write(chunk, encodingOrCallback, callback) {
+      bodyChunks.push(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
+      this.headersSent = true;
+      const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+      _optionalChain([done, 'optionalCall', _ => _()]);
+      return true;
+    },
+    end(chunk, encodingOrCallback, callback) {
+      if (typeof chunk === "string" || chunk instanceof Uint8Array) {
+        bodyChunks.push(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
+      }
+      this.headersSent = true;
+      this.writableEnded = true;
+      const done = typeof chunk === "function" ? chunk : typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+      _optionalChain([done, 'optionalCall', _2 => _2()]);
+      return this;
+    }
+  };
+  return {
+    response,
+    getResponse(method) {
+      if (!response.headersSent && !response.writableEnded) return null;
+      const bodyLength = bodyChunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+      const body = new Uint8Array(bodyLength);
+      let offset = 0;
+      for (const chunk of bodyChunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      const bodyAllowed = method.toUpperCase() !== "HEAD" && response.statusCode !== 204 && response.statusCode !== 205 && response.statusCode !== 304;
+      return new Response(bodyAllowed && bodyLength > 0 ? body : null, {
+        status: response.statusCode,
+        statusText: response.statusMessage || void 0,
+        headers: mapToHeaders(headers)
+      });
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createResponseShim, "createResponseShim");
+function withNodeRequestShape(request, trustProxy, clientAddress) {
+  const requestWithShape = request;
+  if (!requestWithShape.socket) {
+    const forwardedFor = trustProxy ? _optionalChain([request, 'access', _3 => _3.headers, 'access', _4 => _4.get, 'call', _5 => _5("x-forwarded-for"), 'optionalAccess', _6 => _6.split, 'call', _7 => _7(","), 'access', _8 => _8[0], 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]) : void 0;
+    try {
+      requestWithShape.socket = { remoteAddress: forwardedFor || clientAddress || void 0 };
+    } catch (e) {
+    }
+  }
+  return requestWithShape;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withNodeRequestShape, "withNodeRequestShape");
+function createHandledResponse(body, init, headers) {
+  const responseHeaders = new Headers();
+  for (const [key, value] of headers) {
+    if (key.toLowerCase() === "set-cookie") continue;
+    responseHeaders.set(key, value);
+  }
+  for (const [key, value] of new Headers(init.headers)) {
+    responseHeaders.set(key, value);
+  }
+  for (const cookie of headers.getSetCookies()) {
+    responseHeaders.append("Set-Cookie", cookie);
+  }
+  return new Response(body, { ...init, headers: responseHeaders });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createHandledResponse, "createHandledResponse");
+function createWebMiddlewareContext(request, parent, trustProxy = false, clientAddress) {
+  let currentRequest = withNodeRequestShape(request, trustProxy, clientAddress);
+  let handledResponse = null;
+  const url = new URL(currentRequest.url);
+  const data = _optionalChain([parent, 'optionalAccess', _11 => _11.data]) ? new Map(parent.data) : /* @__PURE__ */ new Map();
+  const locals = _optionalChain([parent, 'optionalAccess', _12 => _12.locals]) ? new Map(parent.locals) : /* @__PURE__ */ new Map();
+  const headers = new WebResponseHeaderMap();
+  if (_optionalChain([parent, 'optionalAccess', _13 => _13.headers])) {
+    for (const [key, value] of Object.entries(parent.headers)) {
+      if (key.toLowerCase() === "set-cookie") continue;
+      headers.set(key, value);
+    }
+  }
+  const parentCookies = _optionalChain([parent, 'optionalAccess', _14 => _14[FARM_SET_COOKIE_HEADERS]]);
+  if (parentCookies) headers.replaceSetCookies(parentCookies);
+  const responseShim = createResponseShim(headers);
+  const ctx = {
+    request: currentRequest,
+    response: responseShim.response,
+    url,
+    pathname: url.pathname,
+    searchParams: url.searchParams,
+    method: currentRequest.method || "GET",
+    params: {},
+    route: url.pathname,
+    parent,
+    vite: {
+      isDev: false,
+      hmr: false
+    },
+    data,
+    locals,
+    headers,
+    cookies: new WebCookieJar(currentRequest, headers),
+    _handled: false,
+    _redirectUrl: void 0,
+    _rewriteUrl: void 0,
+    redirect(redirectUrl, status = 307) {
+      ctx._redirectUrl = redirectUrl;
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        `Redirecting to ${redirectUrl}`,
+        {
+          status,
+          headers: {
+            Location: redirectUrl,
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    rewrite(rewriteUrl) {
+      ctx._rewriteUrl = rewriteUrl;
+      const nextUrl = new URL(rewriteUrl, currentRequest.url);
+      currentRequest = withNodeRequestShape(
+        new Request(nextUrl, currentRequest),
+        trustProxy,
+        clientAddress
+      );
+      ctx.request = currentRequest;
+      ctx.url = nextUrl;
+      ctx.pathname = nextUrl.pathname;
+      ctx.searchParams = nextUrl.searchParams;
+      ctx.route = nextUrl.pathname;
+    },
+    json(jsonData, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        JSON.stringify(jsonData),
+        {
+          status,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        },
+        headers
+      );
+    },
+    text(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    html(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/html"
+          }
+        },
+        headers
+      );
+    }
+  };
+  return {
+    ctx,
+    headers,
+    getRequest: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => currentRequest, "getRequest"),
+    getResponse: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => handledResponse || responseShim.getResponse(currentRequest.method), "getResponse")
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createWebMiddlewareContext, "createWebMiddlewareContext");
+function matchesMiddlewareConfig2(pathname, config, ctx) {
+  return _chunkXGC343EYcjs.matchesMiddlewareConfig.call(void 0, pathname, config, ctx);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchesMiddlewareConfig2, "matchesMiddlewareConfig");
+function getConfigHandlers(entry) {
+  const handlers = [];
+  if ("handler" in entry && typeof entry.handler === "function") {
+    handlers.push(entry.handler);
+  }
+  if ("handlers" in entry && Array.isArray(entry.handlers)) {
+    handlers.push(...entry.handlers.filter((handler) => typeof handler === "function"));
+  }
+  return handlers;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getConfigHandlers, "getConfigHandlers");
+function toMiddlewareConfig(entry) {
+  const { matcher, exclude, runtime } = entry;
+  return { matcher, exclude, runtime };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toMiddlewareConfig, "toMiddlewareConfig");
+function normalizeConfigMiddleware(config) {
+  const entries = [];
+  let globalConfig;
+  if (!config) {
+    return { entries, globalConfig };
+  }
+  const configEntries = Array.isArray(config) ? config : [config];
+  for (const [index, entry] of configEntries.entries()) {
+    const handlers = getConfigHandlers(entry);
+    const middlewareConfig = toMiddlewareConfig(entry);
+    if (handlers.length === 0) {
+      globalConfig = middlewareConfig;
+      continue;
+    }
+    _chunkXGC343EYcjs.compileMiddlewareConfig.call(void 0, middlewareConfig);
+    entries.push({
+      path: "/",
+      filePath: `farm.config.ts#middleware-${index}`,
+      handlers,
+      config: middlewareConfig,
+      source: "config"
+    });
+  }
+  return { entries, globalConfig };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeConfigMiddleware, "normalizeConfigMiddleware");
+function normalizeFileMiddleware(modules = []) {
+  const entries = [];
+  for (const moduleEntry of modules) {
+    const normalized = _chunkXGC343EYcjs.normalizeMiddlewareModule.call(void 0, moduleEntry.module, moduleEntry.path);
+    if (!normalized) {
+      continue;
+    }
+    if (normalized.config) _chunkXGC343EYcjs.compileMiddlewareConfig.call(void 0, normalized.config);
+    entries.push({
+      path: moduleEntry.path,
+      filePath: moduleEntry.filePath || moduleEntry.path,
+      handlers: normalized.handlers,
+      config: normalized.config,
+      source: "file"
+    });
+  }
+  return entries;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFileMiddleware, "normalizeFileMiddleware");
+async function executeHandlers(handlers, ctx) {
+  let handlerIndex = 0;
+  let returnedResponse;
+  const executeNext = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+    if (handlerIndex < handlers.length) {
+      const handler = handlers[handlerIndex++];
+      const result2 = await handler(ctx, executeNext);
+      if (isMiddlewareResponse(result2)) {
+        returnedResponse = result2;
+        return result2;
+      }
+    }
+    return returnedResponse;
+  }, "executeNext");
+  const result = await executeNext();
+  return isMiddlewareResponse(result) ? result : returnedResponse;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, executeHandlers, "executeHandlers");
+function emptyResult(request) {
+  return {
+    request,
+    response: null,
+    data: /* @__PURE__ */ new Map(),
+    context: /* @__PURE__ */ new Map(),
+    headers: new Headers(),
+    handled: false
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, emptyResult, "emptyResult");
+function createProductionMiddlewareRunner(options = {}) {
+  const configMiddleware = normalizeConfigMiddleware(options.config);
+  const fileMiddleware = normalizeFileMiddleware(options.modules);
+  for (const entry of fileMiddleware) _chunkXGC343EYcjs.compileMiddlewareRoute.call(void 0, entry);
+  const entries = [...configMiddleware.entries, ...fileMiddleware];
+  const globalConfig = configMiddleware.globalConfig;
+  if (globalConfig) _chunkXGC343EYcjs.compileMiddlewareConfig.call(void 0, globalConfig);
+  return /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async function runProductionMiddleware(request, requestOptions = {}) {
+    if (!globalConfig && entries.length === 0) {
+      return emptyResult(request);
+    }
+    let contextState = createWebMiddlewareContext(
+      request,
+      void 0,
+      _optionalChain([options, 'access', _15 => _15.server, 'optionalAccess', _16 => _16.trustProxy]) === true,
+      requestOptions.clientAddress
+    );
+    let ctx = contextState.ctx;
+    let currentRequest = contextState.getRequest();
+    const initialPathname = _optionalChain([options, 'access', _17 => _17.i18n, 'optionalAccess', _18 => _18.enabled]) ? _chunkBIDYX3SLcjs.stripFarmLocaleFromPathname.call(void 0, ctx.pathname, options.i18n) : _chunkI57LW5VZcjs.stripFarmBasePath.call(void 0, ctx.pathname, _nullishCoalesce(_optionalChain([options, 'access', _19 => _19.i18n, 'optionalAccess', _20 => _20.basePath]), () => ( "/")));
+    let parentData;
+    if (globalConfig) {
+      const globalMatch = _chunkXGC343EYcjs.matchesMiddlewareConfig.call(void 0, initialPathname, globalConfig, ctx);
+      if (!globalMatch.matched) {
+        return emptyResult(request);
+      }
+      if (globalMatch.params) {
+        ctx.params = { ...ctx.params, ...globalMatch.params };
+      }
+    }
+    const applicable = entries.map((entry) => ({
+      entry,
+      routeMatch: entry.source === "config" ? { matched: true } : _chunkXGC343EYcjs.matchesMiddlewareRoute.call(void 0, initialPathname, entry)
+    })).filter((candidate) => candidate.routeMatch.matched);
+    if (applicable.length === 0) {
+      return {
+        request: currentRequest,
+        response: null,
+        data: new Map(ctx.data),
+        context: new Map(ctx.locals),
+        headers: mapToHeaders(contextState.headers),
+        handled: false
+      };
+    }
+    for (const candidate of applicable) {
+      const { entry, routeMatch } = candidate;
+      const configMatch = entry.config ? _chunkXGC343EYcjs.matchesMiddlewareConfig.call(void 0, initialPathname, entry.config, ctx) : { matched: true };
+      if (!configMatch.matched) {
+        continue;
+      }
+      if (parentData) {
+        contextState = createWebMiddlewareContext(
+          currentRequest,
+          parentData,
+          _optionalChain([options, 'access', _21 => _21.server, 'optionalAccess', _22 => _22.trustProxy]) === true,
+          requestOptions.clientAddress
+        );
+        ctx = contextState.ctx;
+      }
+      if (routeMatch.params) {
+        ctx.params = { ...ctx.params, ...routeMatch.params };
+      }
+      if (configMatch.params) {
+        ctx.params = { ...ctx.params, ...configMatch.params };
+      }
+      const middlewareStartTime = Date.now();
+      const middlewareEvent = {
+        route: entry.path,
+        pathname: initialPathname,
+        name: entry.filePath
+      };
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "middleware.start", ...middlewareEvent });
+      try {
+        const returnedResponse = await executeHandlers(entry.handlers, ctx);
+        currentRequest = contextState.getRequest();
+        if (returnedResponse) {
+          const response = applyProductionMiddlewareHeaders(
+            returnedResponse,
+            mapToHeaders(contextState.headers)
+          );
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true
+          };
+        }
+        if (ctx._handled || ctx.response.headersSent || ctx.response.writableEnded) {
+          const response = contextState.getResponse() || new Response(null);
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true
+          };
+        }
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+          type: "middleware.complete",
+          ...middlewareEvent,
+          durationMs: Date.now() - middlewareStartTime
+        });
+      } catch (error) {
+        currentRequest = contextState.getRequest();
+        if (_chunkOX6O6WVAcjs.isFarmRedirectError.call(void 0, error)) {
+          const redirect = _chunkOX6O6WVAcjs.getFarmRedirectError.call(void 0, error);
+          const response = applyProductionMiddlewareHeaders(
+            new Response(null, { status: redirect.status, headers: { Location: redirect.url } }),
+            mapToHeaders(contextState.headers)
+          );
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true
+          };
+        }
+        if (_chunkOX6O6WVAcjs.isFarmNotFoundError.call(void 0, error)) {
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "middleware.shortCircuit", ...middlewareEvent, status: 404 });
+          return {
+            request: currentRequest,
+            response: null,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true,
+            notFound: true
+          };
+        }
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+          type: "middleware.error",
+          ...middlewareEvent,
+          error
+        });
+        throw error;
+      }
+      parentData = {
+        data: new Map(ctx.data),
+        locals: new Map(ctx.locals),
+        headers: headersToRecord(contextState.headers),
+        [FARM_SET_COOKIE_HEADERS]: [...contextState.headers.getSetCookies()]
+      };
+    }
+    return {
+      request: currentRequest,
+      response: null,
+      data: new Map(ctx.data),
+      context: new Map(ctx.locals),
+      headers: mapToHeaders(contextState.headers),
+      handled: false
+    };
+  }, "runProductionMiddleware");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createProductionMiddlewareRunner, "createProductionMiddlewareRunner");
+function applyProductionMiddlewareHeaders(response, middlewareHeaders) {
+  if (!middlewareHeaders || Array.from(middlewareHeaders.keys()).length === 0) {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  const getSetCookie = middlewareHeaders.getSetCookie;
+  const setCookies = getSetCookie ? getSetCookie.call(middlewareHeaders) : middlewareHeaders.get("set-cookie") ? [middlewareHeaders.get("set-cookie")] : [];
+  for (const [key, value] of middlewareHeaders) {
+    if (key.toLowerCase() === "set-cookie") continue;
+    if (headers.has(key)) continue;
+    headers.set(key, value);
+  }
+  for (const cookie of setCookies) {
+    headers.append("Set-Cookie", cookie);
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyProductionMiddlewareHeaders, "applyProductionMiddlewareHeaders");
+
+
+
+
+
+exports.matchesMiddlewareConfig = matchesMiddlewareConfig2; exports.createProductionMiddlewareRunner = createProductionMiddlewareRunner; exports.applyProductionMiddlewareHeaders = applyProductionMiddlewareHeaders;