@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-QPJ4MZTO.mjs

@@ -0,0 +1,60 @@
+import {
+  compileConfigRoutePattern,
+  interpolateConfigRouteDestination,
+  localizeConfigRouteDestination,
+  resolveConfigRoutePathname
+} from "./chunk-ONG4RDW3.mjs";
+import {
+  resolveFarmRequestURL
+} from "./chunk-6HRAK7I5.mjs";
+
+// 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);
+      }
+    }
+  };
+}
+
+export {
+  FARM_CONFIG_REWRITES_PLUGIN_NAME,
+  createRewritesPlugin
+};

package/dist/chunk-QPNVDSFZ.mjs

@@ -0,0 +1,18 @@
+// src/theme/bridge.ts
+var FALLBACK_SERVER_SNAPSHOT = Object.freeze({
+  theme: "system",
+  resolvedTheme: void 0,
+  mounted: false
+});
+var FARM_THEME_SERVER_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.js.theme.server-snapshot-resolver");
+function _setFarmThemeServerSnapshotResolver(resolver) {
+  globalThis[FARM_THEME_SERVER_SNAPSHOT_RESOLVER] = resolver;
+}
+function getFarmThemeServerSnapshot() {
+  return globalThis[FARM_THEME_SERVER_SNAPSHOT_RESOLVER]?.() ?? FALLBACK_SERVER_SNAPSHOT;
+}
+
+export {
+  _setFarmThemeServerSnapshotResolver,
+  getFarmThemeServerSnapshot
+};

package/dist/chunk-QQ44FYRO.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/client/navigation-url.ts
+var FARM_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+function isFarmBlockedNavigationURL(url) {
+  if (FARM_NAVIGATION_PROTOCOLS.has(url.protocol)) return false;
+  console.error(`[Farm.js] Blocked navigation to a ${url.protocol} URL as a security precaution.`);
+  return true;
+}
+function isFarmScriptURL(href) {
+  try {
+    return new URL(href, "http://farm.invalid").protocol === "javascript:";
+  } catch (e) {
+    return false;
+  }
+}
+function isFarmExternalNavigationURL(url, currentOrigin) {
+  return url.protocol !== "http:" && url.protocol !== "https:" || url.origin !== currentOrigin;
+}
+function resolveFarmNavigationURL(href, documentUrl) {
+  return new URL(href, documentUrl);
+}
+
+
+
+
+
+
+exports.isFarmBlockedNavigationURL = isFarmBlockedNavigationURL; exports.isFarmScriptURL = isFarmScriptURL; exports.isFarmExternalNavigationURL = isFarmExternalNavigationURL; exports.resolveFarmNavigationURL = resolveFarmNavigationURL;

package/dist/chunk-QSTRBKHZ.mjs

@@ -0,0 +1,102 @@
+// src/request-origin.ts
+function getRequestSourceOrigin(request) {
+  const origin = request.headers.get("origin")?.trim();
+  if (origin) {
+    return parseSourceOrigin(origin);
+  }
+  const referer = request.headers.get("referer")?.trim();
+  if (referer) {
+    return parseSourceOrigin(referer);
+  }
+  return { ok: true, origin: null };
+}
+function parseSourceOrigin(value) {
+  if (value === "null") {
+    return { ok: false, reason: "opaque-origin" };
+  }
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return { ok: false, reason: "invalid-origin" };
+    }
+    return { ok: true, origin: parsed.origin };
+  } catch {
+    return { ok: false, reason: "invalid-origin" };
+  }
+}
+function matchesHostHeader(sourceOrigin, request) {
+  const host = request.headers.get("host")?.trim().toLowerCase();
+  if (!host) return false;
+  try {
+    const source = new URL(sourceOrigin);
+    const target = new URL(request.url);
+    return source.protocol === target.protocol && source.host.toLowerCase() === host;
+  } catch {
+    return false;
+  }
+}
+function matchesAllowedOrigin(sourceOrigin, pattern) {
+  const source = new URL(sourceOrigin);
+  if (!pattern.includes("*")) {
+    return pattern.includes("://") ? source.origin === pattern : source.host === pattern;
+  }
+  const schemeEnd = pattern.indexOf("://");
+  const scheme = schemeEnd === -1 ? null : pattern.slice(0, schemeEnd + 1);
+  const hostPattern = pattern.slice(schemeEnd === -1 ? 0 : schemeEnd + 3);
+  const [wildcardHost, port] = splitHostAndPort(hostPattern);
+  const baseHost = wildcardHost.slice(2);
+  if (scheme && source.protocol !== scheme) return false;
+  if (port && getEffectivePort(source) !== port) return false;
+  if (!port && source.port) return false;
+  return source.hostname.endsWith(`.${baseHost}`) && source.hostname !== baseHost;
+}
+function normalizeAllowedOriginPattern(value, label) {
+  const pattern = value.trim().toLowerCase();
+  if (!pattern) {
+    throw new TypeError(`${label} cannot contain empty values`);
+  }
+  if (pattern.includes("*")) {
+    if (!/^(?:https?:\/\/)?\*\.[a-z0-9.-]+(?::\d+)?$/.test(pattern)) {
+      throw new TypeError(`Invalid ${label} pattern: ${JSON.stringify(value)}`);
+    }
+    return pattern;
+  }
+  if (pattern.includes("://")) {
+    let parsed;
+    try {
+      parsed = new URL(pattern);
+    } catch {
+      throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      throw new TypeError(`${label} must contain origins without paths: ${JSON.stringify(value)}`);
+    }
+    return parsed.origin;
+  }
+  if (/[/@?#]/.test(pattern)) {
+    throw new TypeError(`${label} must contain origins or hosts: ${JSON.stringify(value)}`);
+  }
+  try {
+    return new URL(`http://${pattern}`).host;
+  } catch {
+    throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+  }
+}
+function splitHostAndPort(value) {
+  const separator = value.lastIndexOf(":");
+  if (separator === -1) return [value, null];
+  return [value.slice(0, separator), value.slice(separator + 1)];
+}
+function getEffectivePort(url) {
+  if (url.port) return url.port;
+  if (url.protocol === "https:") return "443";
+  if (url.protocol === "http:") return "80";
+  return "";
+}
+
+export {
+  getRequestSourceOrigin,
+  matchesHostHeader,
+  matchesAllowedOrigin,
+  normalizeAllowedOriginPattern
+};

package/dist/chunk-R2SEZEBC.cjs

@@ -0,0 +1,453 @@
+"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 _chunk5C7XMKQ4cjs = require('./chunk-5C7XMKQ4.cjs');
+
+
+var _chunkJXIYH2NOcjs = require('./chunk-JXIYH2NO.cjs');
+
+
+var _chunk4DCWVSL2cjs = require('./chunk-4DCWVSL2.cjs');
+
+
+
+
+var _chunkITV4QQL2cjs = require('./chunk-ITV4QQL2.cjs');
+
+
+
+
+var _chunk5566GNEGcjs = require('./chunk-5566GNEG.cjs');
+
+
+var _chunkB5BBTPJQcjs = require('./chunk-B5BBTPJQ.cjs');
+
+
+
+var _chunkCA7DNRHOcjs = require('./chunk-CA7DNRHO.cjs');
+
+
+
+var _chunkIWFV5ZEDcjs = require('./chunk-IWFV5ZED.cjs');
+
+
+
+
+var _chunkUZCMMJJTcjs = require('./chunk-UZCMMJJT.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+// src/api/plugin-route-runtime.ts
+function mergePluginAPIRoutes(existing, plugins, expected, options = {}) {
+  const routes = /* @__PURE__ */ new Map();
+  const shapes = /* @__PURE__ */ new Map();
+  for (const route of existing) {
+    _chunkJXIYH2NOcjs.registerAPIRouteShape.call(void 0, shapes, route.path, route.filePath || route.path, "app");
+    routes.set(route.path, {
+      ...route,
+      filePath: route.filePath || "",
+      methods: [...route.methods],
+      endpoints: { ...route.endpoints }
+    });
+  }
+  const api = createPluginLocalAPI(existing, options.bodySizeLimit, options.dispatch);
+  for (const definition of _chunk5C7XMKQ4cjs.resolvePluginRoutes.call(void 0, plugins, { api })) {
+    _chunkJXIYH2NOcjs.registerAPIRouteShape.call(void 0, shapes, definition.path, `plugin:${definition.path}`, "app");
+    let route = routes.get(definition.path);
+    if (_optionalChain([route, 'optionalAccess', _ => _.methods, 'access', _2 => _2.includes, 'call', _3 => _3(definition.method)])) {
+      throw new Error(
+        `Duplicate API route for ${definition.method} ${definition.path}. Plugin routes cannot override app or other plugin endpoints.`
+      );
+    }
+    if (!route) {
+      route = { path: definition.path, filePath: "", methods: [], endpoints: {} };
+      routes.set(definition.path, route);
+    }
+    route.methods.push(definition.method);
+    route.pluginMethods = [..._nullishCoalesce(route.pluginMethods, () => ( [])), definition.method];
+    route.endpoints[definition.method] = definition.endpoint;
+  }
+  const result = [...routes.values()];
+  if (expected) {
+    const signature = (entries) => entries.map(({ path, methods }) => `${path}:${[...methods].sort().join(",")}`).sort().join("\n");
+    const actualSignature = signature(result);
+    const expectedSignature = signature(expected);
+    if (actualSignature !== expectedSignature) {
+      throw new Error(
+        `Plugin API routes changed between build and runtime. Route paths and methods must be stable across environments; rebuild the app.
+Expected:
+${expectedSignature || "(none)"}
+Received:
+${actualSignature || "(none)"}`
+      );
+    }
+  }
+  return result;
+}
+var DISPATCH_DROPPED_HEADERS = [
+  "accept-encoding",
+  "connection",
+  "content-length",
+  "keep-alive",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+function createPluginLocalAPI(routes, bodySizeLimit, dispatch) {
+  const endpoints = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    for (const method of route.methods) {
+      const normalizedMethod = method.toUpperCase();
+      const endpoint = route.endpoints[normalizedMethod];
+      if (typeof endpoint !== "function") continue;
+      const descriptor = Object.freeze({
+        path: route.path,
+        method: normalizedMethod,
+        input: Object.freeze({
+          body: _optionalChain([endpoint, 'access', _4 => _4.__types, 'optionalAccess', _5 => _5.body]),
+          query: _optionalChain([endpoint, 'access', _6 => _6.__types, 'optionalAccess', _7 => _7.query]),
+          params: _optionalChain([endpoint, 'access', _8 => _8.__types, 'optionalAccess', _9 => _9.params]),
+          headers: _optionalChain([endpoint, 'access', _10 => _10.__types, 'optionalAccess', _11 => _11.headers])
+        }),
+        output: endpoint.__output,
+        mcp: endpoint.__mcp === true ? true : endpoint.__mcp ? Object.freeze({ ...endpoint.__mcp }) : void 0,
+        async invoke(request, params = {}) {
+          if (!dispatch)
+            return invokeAPIRouteEndpoint(endpoint, request, { ...params }, bodySizeLimit);
+          const headers = new Headers(request.headers);
+          for (const name of DISPATCH_DROPPED_HEADERS) headers.delete(name);
+          return dispatch(new Request(request, { headers }));
+        }
+      });
+      endpoints.set(`${normalizedMethod} ${route.path}`, descriptor);
+    }
+  }
+  const listedEndpoints = Object.freeze(Array.from(endpoints.values()));
+  return Object.freeze({
+    available: true,
+    get(method, path) {
+      return endpoints.get(`${method.toUpperCase()} ${path}`);
+    },
+    list() {
+      return listedEndpoints;
+    }
+  });
+}
+
+// src/api/runtime.ts
+var API_ROUTE_METHODS = [
+  "GET",
+  "HEAD",
+  "QUERY",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+function resolveAPIRouteEndpoint(route, method) {
+  const normalizedMethod = method.toUpperCase();
+  return _nullishCoalesce(route.endpoints[normalizedMethod], () => ( (normalizedMethod === "HEAD" ? route.endpoints.GET : void 0)));
+}
+function getAllowedAPIRouteMethods(route) {
+  const methods = [...route.methods];
+  const getIndex = methods.indexOf("GET");
+  if (getIndex >= 0 && !methods.includes("HEAD")) {
+    methods.splice(getIndex + 1, 0, "HEAD");
+  }
+  return methods;
+}
+function matchAPIRouteAtBasePath(routes, pathname, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const directMatch = _chunkCA7DNRHOcjs.matchAPIRoute.call(void 0, routes, pathname);
+  if (directMatch) return directMatch;
+  const canonicalPathname = _chunkB5BBTPJQcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+  return canonicalPathname === pathname ? null : _chunkCA7DNRHOcjs.matchAPIRoute.call(void 0, routes, canonicalPathname);
+}
+function createStaticAPIRouteMatcherAtBasePath(routes, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const match = _chunkCA7DNRHOcjs.createStaticAPIRouteMatcher.call(void 0, routes);
+  return (pathname) => {
+    const directMatch = match(pathname);
+    if (directMatch) return directMatch;
+    const canonicalPathname = _chunkB5BBTPJQcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+    return canonicalPathname === pathname ? null : match(canonicalPathname);
+  };
+}
+function isFarmAPIPathname(pathname, serverBasePath = _chunkIWFV5ZEDcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = _chunkIWFV5ZEDcjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
+  return basePath !== "/" && (pathname === basePath || pathname.startsWith(`${basePath}/`));
+}
+async function invokeAPIRouteEndpoint(endpoint, request, params = {}, bodySizeLimit = _chunk5566GNEGcjs.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT) {
+  try {
+    request = await _chunk5566GNEGcjs.bufferFarmRequestBody.call(void 0, request, bodySizeLimit);
+  } catch (error) {
+    const response2 = _chunk5566GNEGcjs.createFarmRequestBodyErrorResponse.call(void 0, error);
+    if (response2) return response2;
+    throw error;
+  }
+  const response = await _chunkHNAISJFDcjs._runWithCurrentRequest.call(void 0, 
+    request,
+    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
+  );
+  if (request.method.toUpperCase() !== "HEAD") {
+    return response;
+  }
+  return _chunk4DCWVSL2cjs.omitFarmResponseBody.call(void 0, response);
+}
+async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
+  const queryContentTypeError = validateQueryContentType(request);
+  if (queryContentTypeError) {
+    return queryContentTypeError;
+  }
+  const farmHandler = endpoint.__handler || null;
+  if (!farmHandler) {
+    const result = await endpoint(request, {
+      params: Promise.resolve(params)
+    });
+    return normalizeRouteResponse(result);
+  }
+  const url = new URL(request.url);
+  const query = {
+    ...searchParamsToObject(url.searchParams)
+  };
+  let body = void 0;
+  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
+    const parsedBody = await readRequestBody(request);
+    if (parsedBody.error) return parsedBody.error;
+    body = parsedBody.body;
+  }
+  const headers = Object.fromEntries(request.headers.entries());
+  const types = endpoint.__types || {};
+  const queryValidation = await validateInput(types.query, query, "Invalid query parameters");
+  if (queryValidation instanceof Response) {
+    return queryValidation;
+  }
+  const bodyValidation = await validateInput(types.body, body, "Invalid request body");
+  if (bodyValidation instanceof Response) {
+    return bodyValidation;
+  }
+  const headersValidation = await validateInput(types.headers, headers, "Invalid request headers");
+  if (headersValidation instanceof Response) {
+    return headersValidation;
+  }
+  const paramsValidation = await validateInput(types.params, params, "Invalid route parameters");
+  if (paramsValidation instanceof Response) return paramsValidation;
+  const handlerContext = {
+    query: queryValidation,
+    body: bodyValidation,
+    headers: headersValidation,
+    request,
+    context: {},
+    params: paramsValidation
+  };
+  let execution;
+  try {
+    execution = typeof endpoint.__farmInvoke === "function" ? await endpoint.__farmInvoke(handlerContext) : {
+      result: await farmHandler(handlerContext),
+      context: handlerContext.context,
+      handlerExecuted: true,
+      invalidations: []
+    };
+  } catch (error) {
+    if (_chunk5C7XMKQ4cjs.isEndpointFailure.call(void 0, error)) {
+      return createEndpointFailureResponse(error);
+    }
+    throw error;
+  }
+  if (execution.handlerExecuted && endpoint.__output && !isWebResponse(execution.result)) {
+    try {
+      execution.result = await _chunkITV4QQL2cjs.parseRouteSchema.call(void 0, endpoint.__output, execution.result);
+    } catch (e) {
+      throw new Error("API route returned a value that does not match its output schema.");
+    }
+  }
+  const response = normalizeRouteResponse(execution.result);
+  return attachEndpointInvalidations(response, execution.invalidations);
+}
+function validateQueryContentType(request) {
+  if (request.method.toUpperCase() !== "QUERY" || request.headers.has("content-type")) {
+    return null;
+  }
+  return new Response(
+    JSON.stringify({
+      error: "Invalid QUERY request",
+      message: "QUERY requests must include a Content-Type header."
+    }),
+    {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+function normalizeRouteResponse(result) {
+  if (isWebResponse(result)) {
+    return result;
+  }
+  if (result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  let body;
+  try {
+    body = JSON.stringify(result);
+  } catch (error) {
+    const serializationError = new TypeError(
+      "API route result must be a JSON-serializable value or a Response."
+    );
+    serializationError.cause = error;
+    throw serializationError;
+  }
+  if (body === void 0) {
+    throw new TypeError("API route result must be a JSON-serializable value or a Response.");
+  }
+  return new Response(body, {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function isWebResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+function attachEndpointInvalidations(response, keys) {
+  const existing = _chunkUZCMMJJTcjs.decodeFarmCacheInvalidations.call(void 0, 
+    response.headers.get(_chunkUZCMMJJTcjs.FARM_CACHE_INVALIDATION_HEADER)
+  );
+  const encoded = _chunkUZCMMJJTcjs.encodeFarmCacheInvalidations.call(void 0, [...existing, ...keys]);
+  if (!encoded) return response;
+  const headers = new Headers(response.headers);
+  headers.set(_chunkUZCMMJJTcjs.FARM_CACHE_INVALIDATION_HEADER, encoded);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function createEndpointFailureResponse(failure) {
+  return new Response(
+    JSON.stringify({
+      error: {
+        code: failure.code,
+        message: failure.message,
+        data: failure.data
+      }
+    }),
+    {
+      status: failure.status,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json"
+      }
+    }
+  );
+}
+async function readRequestBody(request) {
+  const contentType = _optionalChain([request, 'access', _12 => _12.headers, 'access', _13 => _13.get, 'call', _14 => _14("content-type"), 'optionalAccess', _15 => _15.split, 'call', _16 => _16(";", 1), 'access', _17 => _17[0], 'optionalAccess', _18 => _18.trim, 'call', _19 => _19(), 'access', _20 => _20.toLowerCase, 'call', _21 => _21()]);
+  if (contentType === "multipart/form-data") {
+    try {
+      return { body: formDataToObject(await request.clone().formData()) };
+    } catch (e2) {
+      return invalidRequestBody("The request body is not valid multipart form data.");
+    }
+  }
+  let text;
+  try {
+    text = await request.clone().text();
+  } catch (e3) {
+    if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _22 => _22.endsWith, 'call', _23 => _23("+json")])) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      return invalidRequestBody("The request body is not valid URL-encoded form data.");
+    }
+    return { body: void 0 };
+  }
+  if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _24 => _24.endsWith, 'call', _25 => _25("+json")])) {
+    if (!text && request.method.toUpperCase() === "QUERY") {
+      return { body: void 0 };
+    }
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e4) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    return { body: searchParamsToObject(new URLSearchParams(text)) };
+  }
+  if (!text) return { body: void 0 };
+  if (contentType === void 0) {
+    if (!_chunkITV4QQL2cjs.validateIntegrationRequestOrigin.call(void 0, request, { requireOriginMetadata: false }).ok) {
+      return { body: void 0 };
+    }
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e5) {
+      return { body: void 0 };
+    }
+  }
+  return { body: void 0 };
+}
+function invalidRequestBody(message) {
+  return {
+    error: new Response(
+      JSON.stringify({
+        error: "Invalid request body",
+        message
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    )
+  };
+}
+function formDataToObject(formData) {
+  return entriesToObject(formData.entries());
+}
+function searchParamsToObject(searchParams) {
+  return entriesToObject(searchParams.entries());
+}
+function entriesToObject(entries) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of entries) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    const current = output[key];
+    if (current === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      output[key] = [current, value];
+    }
+  }
+  return output;
+}
+async function validateInput(schema, value, error) {
+  if (!schema) return value;
+  try {
+    return await _chunkITV4QQL2cjs.parseRouteSchema.call(void 0, schema, value);
+  } catch (validationError) {
+    return Response.json(
+      {
+        error,
+        details: _chunkITV4QQL2cjs.toPublicValidationIssues.call(void 0, validationError)
+      },
+      { status: 400 }
+    );
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.API_ROUTE_METHODS = API_ROUTE_METHODS; exports.resolveAPIRouteEndpoint = resolveAPIRouteEndpoint; exports.getAllowedAPIRouteMethods = getAllowedAPIRouteMethods; exports.matchAPIRouteAtBasePath = matchAPIRouteAtBasePath; exports.createStaticAPIRouteMatcherAtBasePath = createStaticAPIRouteMatcherAtBasePath; exports.isFarmAPIPathname = isFarmAPIPathname; exports.invokeAPIRouteEndpoint = invokeAPIRouteEndpoint; exports.normalizeRouteResponse = normalizeRouteResponse; exports.isWebResponse = isWebResponse; exports.createEndpointFailureResponse = createEndpointFailureResponse; exports.mergePluginAPIRoutes = mergePluginAPIRoutes;

package/dist/chunk-R5U7OIPI.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/request-cookies.ts
+function parseRequestCookieHeader(header) {
+  if (!_optionalChain([header, 'optionalAccess', _ => _.trim, 'call', _2 => _2()])) return [];
+  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) {
+      return {
+        name: decodeCookieName(part),
+        value: ""
+      };
+    }
+    return {
+      name: decodeCookieName(part.slice(0, separatorIndex).trim()),
+      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
+    };
+  }).filter((cookie) => cookie.name.length > 0);
+}
+var RESERVED_PREFIX = /^__(host|secure)-/i;
+function decodeCookieName(raw) {
+  const decoded = decodeCookiePart(raw);
+  return RESERVED_PREFIX.test(decoded) && !RESERVED_PREFIX.test(raw) ? raw : decoded;
+}
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch (e) {
+    return value;
+  }
+}
+
+
+
+
+exports.parseRequestCookieHeader = parseRequestCookieHeader; exports.decodeCookieName = decodeCookieName;