@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-G2KY33I6.mjs

@@ -0,0 +1,202 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/image-config.ts
+var DEFAULT_FARM_IMAGE_PATH = "/_farm/image";
+var DEFAULT_FARM_IMAGE_DEVICE_SIZES = [
+  640,
+  750,
+  828,
+  1080,
+  1200,
+  1920,
+  2048,
+  3840
+];
+var DEFAULT_FARM_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
+var DEFAULT_FARM_IMAGE_QUALITIES = [75];
+var DEFAULT_FARM_IMAGE_FORMATS = ["image/webp"];
+var SIZE_UNITS = {
+  b: 1,
+  kb: 1e3,
+  mb: 1e6,
+  gb: 1e9,
+  kib: 1024,
+  mib: 1048576,
+  gib: 1073741824
+};
+function resolveFarmImageConfig(config) {
+  const path = normalizeImagePath(config?.path ?? DEFAULT_FARM_IMAGE_PATH);
+  const deviceSizes = normalizeIntegerList(
+    config?.deviceSizes ?? DEFAULT_FARM_IMAGE_DEVICE_SIZES,
+    "images.deviceSizes"
+  );
+  const imageSizes = normalizeIntegerList(
+    config?.imageSizes ?? DEFAULT_FARM_IMAGE_SIZES,
+    "images.imageSizes"
+  );
+  const qualities = normalizeIntegerList(
+    config?.qualities ?? DEFAULT_FARM_IMAGE_QUALITIES,
+    "images.qualities",
+    100
+  );
+  const formats = [...new Set(config?.formats ?? DEFAULT_FARM_IMAGE_FORMATS)];
+  if (formats.some((format) => format !== "image/avif" && format !== "image/webp")) {
+    throw new TypeError('images.formats only supports "image/avif" and "image/webp"');
+  }
+  const minimumCacheTTL = normalizeNonNegativeInteger(
+    config?.minimumCacheTTL ?? 60,
+    "images.minimumCacheTTL"
+  );
+  const maximumRedirects = normalizeNonNegativeInteger(
+    config?.maximumRedirects ?? 3,
+    "images.maximumRedirects"
+  );
+  return Object.freeze({
+    provider: config?.provider ?? "auto",
+    path,
+    domains: Object.freeze([
+      ...new Set(
+        (config?.domains ?? []).map((domain) => domain.trim().toLowerCase()).filter(Boolean)
+      )
+    ]),
+    remotePatterns: Object.freeze(
+      (config?.remotePatterns ?? []).map((pattern) => normalizeRemotePattern(pattern))
+    ),
+    localPatterns: Object.freeze(
+      (config?.localPatterns ?? [{ pathname: "/**" }]).map(
+        (pattern) => normalizeLocalPattern(pattern)
+      )
+    ),
+    deviceSizes: Object.freeze(deviceSizes),
+    imageSizes: Object.freeze(imageSizes),
+    qualities: Object.freeze(qualities),
+    formats: Object.freeze(formats),
+    minimumCacheTTL,
+    maximumResponseBody: parseSize(
+      config?.maximumResponseBody ?? "10mb",
+      "images.maximumResponseBody"
+    ),
+    maximumRedirects,
+    dangerouslyAllowSVG: config?.dangerouslyAllowSVG ?? false,
+    dangerouslyAllowLocalIP: config?.dangerouslyAllowLocalIP ?? false
+  });
+}
+__name(resolveFarmImageConfig, "resolveFarmImageConfig");
+function getPublicFarmImageConfig(config) {
+  return {
+    provider: config.provider,
+    path: config.path,
+    deviceSizes: config.deviceSizes,
+    imageSizes: config.imageSizes,
+    qualities: config.qualities,
+    formats: config.formats
+  };
+}
+__name(getPublicFarmImageConfig, "getPublicFarmImageConfig");
+function normalizeImagePath(value) {
+  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(value)) {
+    throw new TypeError("images.path cannot contain backslashes or control characters");
+  }
+  const path = value.trim().replace(/\/+$/, "") || "/";
+  if (!path.startsWith("/") || path.startsWith("//") || path.includes("?") || path.includes("#")) {
+    throw new TypeError("images.path must be an absolute pathname without a query or hash");
+  }
+  for (const segment of path.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new TypeError("images.path cannot contain backslashes or control characters");
+    }
+    if (decoded.includes("/")) {
+      throw new TypeError("images.path cannot contain percent-encoded path separators");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new TypeError('images.path cannot contain "." or ".." path segments');
+    }
+  }
+  return path;
+}
+__name(normalizeImagePath, "normalizeImagePath");
+function normalizeIntegerList(values, name, max) {
+  if (values.length === 0) {
+    throw new TypeError(`${name} must contain at least one value`);
+  }
+  const normalized = [...new Set(values)].sort((left, right) => left - right);
+  for (const value of normalized) {
+    if (!Number.isSafeInteger(value) || value <= 0 || max !== void 0 && value > max) {
+      throw new TypeError(
+        `${name} must contain positive integers${max ? ` no greater than ${max}` : ""}`
+      );
+    }
+  }
+  return normalized;
+}
+__name(normalizeIntegerList, "normalizeIntegerList");
+function normalizeNonNegativeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  }
+  return value;
+}
+__name(normalizeNonNegativeInteger, "normalizeNonNegativeInteger");
+function parseSize(value, name) {
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`${name} 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(`${name} must be bytes or a size string such as "5mb"`);
+  }
+  const bytes = Number(match[1]) * SIZE_UNITS[match[2]];
+  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
+    throw new TypeError(`${name} must resolve to a positive safe integer`);
+  }
+  return bytes;
+}
+__name(parseSize, "parseSize");
+function normalizeRemotePattern(pattern) {
+  const hostname = pattern.hostname.trim().toLowerCase();
+  if (!hostname || hostname.includes("/") || hostname.includes(":")) {
+    throw new TypeError("images.remotePatterns[].hostname must be a hostname or wildcard hostname");
+  }
+  if (pattern.pathname && !pattern.pathname.startsWith("/")) {
+    throw new TypeError("images.remotePatterns[].pathname must start with /");
+  }
+  if (pattern.search && !pattern.search.startsWith("?")) {
+    throw new TypeError("images.remotePatterns[].search must start with ?");
+  }
+  return Object.freeze({ ...pattern, hostname });
+}
+__name(normalizeRemotePattern, "normalizeRemotePattern");
+function normalizeLocalPattern(pattern) {
+  if (!pattern.pathname.startsWith("/")) {
+    throw new TypeError("images.localPatterns[].pathname must start with /");
+  }
+  if (pattern.search && !pattern.search.startsWith("?")) {
+    throw new TypeError("images.localPatterns[].search must start with ?");
+  }
+  return Object.freeze({ ...pattern });
+}
+__name(normalizeLocalPattern, "normalizeLocalPattern");
+
+export {
+  DEFAULT_FARM_IMAGE_PATH,
+  DEFAULT_FARM_IMAGE_DEVICE_SIZES,
+  DEFAULT_FARM_IMAGE_SIZES,
+  DEFAULT_FARM_IMAGE_QUALITIES,
+  DEFAULT_FARM_IMAGE_FORMATS,
+  resolveFarmImageConfig,
+  getPublicFarmImageConfig
+};

package/dist/chunk-G4MWPDSE.mjs

@@ -0,0 +1,19 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/api/server-client-bridge.ts
+var API_RUNTIME_RESOLVER = /* @__PURE__ */ Symbol.for("farm.apiRequestRuntimeResolver");
+function setAPIRequestRuntimeResolver(resolver) {
+  globalThis[API_RUNTIME_RESOLVER] = resolver;
+}
+__name(setAPIRequestRuntimeResolver, "setAPIRequestRuntimeResolver");
+function resolveAPIRequestRuntime() {
+  return globalThis[API_RUNTIME_RESOLVER]?.();
+}
+__name(resolveAPIRequestRuntime, "resolveAPIRequestRuntime");
+
+export {
+  setAPIRequestRuntimeResolver,
+  resolveAPIRequestRuntime
+};

package/dist/chunk-G643DQCH.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/schema.ts
+function defineSchema(schema) {
+  return schema;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineSchema, "defineSchema");
+
+
+
+exports.defineSchema = defineSchema;

package/dist/chunk-G7HXGLEC.cjs

@@ -0,0 +1,175 @@
+"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; }
+
+var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/route-pattern.ts
+var compiledEntries = /* @__PURE__ */ new WeakMap();
+function createStaticAPIRouteMatcher(routes) {
+  const table = new Map(routes.map((route) => [route.path, Object.freeze({ ...route })]));
+  const root = { children: /* @__PURE__ */ new Map(), candidates: [] };
+  let order = 0;
+  for (const route of table.values()) {
+    const compiled = compileRouteEntry(route.path);
+    let node = root;
+    for (const segment of compiled.segments) {
+      if (segment.dynamic) break;
+      let child = node.children.get(segment.value);
+      if (!child) {
+        child = { children: /* @__PURE__ */ new Map(), candidates: [] };
+        node.children.set(segment.value, child);
+      }
+      node = child;
+    }
+    node.candidates.push({ route, compiled, order: order++ });
+  }
+  return (pathname) => {
+    const exactRoute = table.get(pathname);
+    if (exactRoute) return { route: exactRoute, params: {} };
+    const normalizedPathname = normalizePathname(pathname);
+    if (normalizedPathname !== pathname) {
+      const normalizedRoute = table.get(normalizedPathname);
+      if (normalizedRoute) return { route: normalizedRoute, params: {} };
+    }
+    const segments = getPathSegments(normalizedPathname).map(decodePathSegment);
+    let best;
+    let bestMatch = null;
+    let node = root;
+    let depth = 0;
+    while (node) {
+      for (const candidate of node.candidates) {
+        const params = matchRouteEntry(candidate.compiled, segments);
+        if (!params) continue;
+        const comparison = best ? _chunkNO3WWW3Ncjs.compareRouteSpecificity.call(void 0, candidate.compiled.specificity, best.compiled.specificity) : -1;
+        if (comparison < 0 || comparison === 0 && candidate.order < best.order) {
+          best = candidate;
+          bestMatch = { route: candidate.route, params };
+        }
+      }
+      node = depth < segments.length ? node.children.get(segments[depth++]) : void 0;
+    }
+    return bestMatch;
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createStaticAPIRouteMatcher, "createStaticAPIRouteMatcher");
+function matchAPIRoute(routes, pathname) {
+  const exactRoute = routes.get(pathname);
+  if (exactRoute) return { route: exactRoute, params: {} };
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname !== pathname) {
+    const normalizedRoute = routes.get(normalizedPathname);
+    if (normalizedRoute) return { route: normalizedRoute, params: {} };
+  }
+  const pathnameSegments = getPathSegments(normalizedPathname).map(decodePathSegment);
+  let bestMatch = null;
+  let bestSpecificity = null;
+  for (const route of routes.values()) {
+    const routePath = route.path;
+    let entry = compiledEntries.get(route);
+    if (!entry || entry.path !== routePath) {
+      entry = compileRouteEntry(routePath);
+      compiledEntries.set(route, entry);
+    }
+    const params = matchRouteEntry(entry, pathnameSegments);
+    if (!params) continue;
+    if (bestSpecificity === null || _chunkNO3WWW3Ncjs.compareRouteSpecificity.call(void 0, entry.specificity, bestSpecificity) < 0) {
+      bestMatch = { route, params };
+      bestSpecificity = entry.specificity;
+    }
+  }
+  return bestMatch;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchAPIRoute, "matchAPIRoute");
+function compileRouteEntry(path) {
+  const segments = getPathSegments(path).map((segment) => {
+    const dynamic = parseDynamicSegment(segment);
+    return dynamic ? { dynamic } : { value: decodePathSegment(segment) };
+  });
+  return {
+    path,
+    segments,
+    specificity: segments.map((segment) => {
+      const dynamic = segment.dynamic;
+      if (!dynamic) return "static";
+      if (!dynamic.catchAll) return "dynamic";
+      return dynamic.optional ? "optional-catch-all" : "catch-all";
+    })
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compileRouteEntry, "compileRouteEntry");
+function matchRouteEntry(entry, pathnameSegments) {
+  const params = {};
+  let pathIndex = 0;
+  for (const routeSegment of entry.segments) {
+    const dynamicSegment = routeSegment.dynamic;
+    if (_optionalChain([dynamicSegment, 'optionalAccess', _ => _.catchAll])) {
+      const remainingSegments = pathnameSegments.slice(pathIndex);
+      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
+        return null;
+      }
+      if (remainingSegments.length > 0) {
+        params[dynamicSegment.name] = remainingSegments;
+      }
+      pathIndex = pathnameSegments.length;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === void 0) {
+      return null;
+    }
+    if (dynamicSegment) {
+      params[dynamicSegment.name] = pathnameSegment;
+      pathIndex++;
+      continue;
+    }
+    if (routeSegment.value !== pathnameSegment) {
+      return null;
+    }
+    pathIndex++;
+  }
+  return pathIndex === pathnameSegments.length ? params : null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRouteEntry, "matchRouteEntry");
+function getPathSegments(pathname) {
+  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getPathSegments, "getPathSegments");
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.replace(/\/+$/, "");
+  }
+  return pathname;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizePathname, "normalizePathname");
+function parseDynamicSegment(segment) {
+  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+  if (_optionalChain([optionalCatchAll, 'optionalAccess', _2 => _2[1]])) {
+    return { name: optionalCatchAll[1], catchAll: true, optional: true };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (_optionalChain([catchAll, 'optionalAccess', _3 => _3[1]])) {
+    return { name: catchAll[1], catchAll: true, optional: false };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (_optionalChain([dynamic, 'optionalAccess', _4 => _4[1]])) {
+    return { name: dynamic[1], catchAll: false, optional: false };
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseDynamicSegment, "parseDynamicSegment");
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch (e) {
+    return segment;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodePathSegment, "decodePathSegment");
+
+
+
+
+
+exports.createStaticAPIRouteMatcher = createStaticAPIRouteMatcher; exports.matchAPIRoute = matchAPIRoute; exports.parseDynamicSegment = parseDynamicSegment;

package/dist/chunk-GC3SUL6M.mjs

@@ -0,0 +1,109 @@
+import {
+  matchSegmentParts,
+  normalizePathname,
+  parseRoutePattern,
+  splitNormalizedPathname
+} from "./chunk-OT6ZEW74.mjs";
+import {
+  getRouteGroupScope,
+  isInRouteGroupScope
+} from "./chunk-LSZAVSGY.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/nitro/native-mcp-source.ts
+function generateNativeMCPPluginSource(mcp) {
+  if (mcp?.enabled !== true) {
+    return { importSource: "", registerSource: "", pluginSource: "" };
+  }
+  return {
+    importSource: `import { createFarmMCPPlugin as __farmCreateMCPPlugin } from "@farm.js/mcp/internal";`,
+    registerSource: `function __farmMCPIsPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function __farmMergeMCPConfig(base, override) {
+  const output = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === undefined) continue;
+    output[key] =
+      __farmMCPIsPlainObject(output[key]) && __farmMCPIsPlainObject(value)
+        ? __farmMergeMCPConfig(output[key], value)
+        : value;
+  }
+  return output;
+}
+
+const farmNativeMCPConfig = farmRuntimeConfigs.reduce((merged, runtimeConfig) => {
+  const value = runtimeConfig?.mcp;
+  if (value === undefined) return merged;
+  if (value === false) return false;
+  return __farmMergeMCPConfig(merged && merged !== false ? merged : {}, value);
+}, undefined);
+const farmNativeMCPPlugin =
+  farmNativeMCPConfig && farmNativeMCPConfig.enabled !== false
+    ? __farmCreateMCPPlugin(farmNativeMCPConfig)
+    : null;`,
+    pluginSource: `...(farmNativeMCPPlugin ? [farmNativeMCPPlugin] : []),`
+  };
+}
+__name(generateNativeMCPPluginSource, "generateNativeMCPPluginSource");
+
+// src/routing/layout-selector.ts
+function createFarmLayoutSelector(layouts, resolveRouteDirectory) {
+  const prepared = layouts.map((layout) => {
+    const segments = layout.pattern === "/" ? [] : parseRoutePattern(layout.pattern);
+    return {
+      layout,
+      segments: segments.length === 0 ? null : segments,
+      groupScope: getRouteGroupScope(layout.pattern)
+    };
+  });
+  return (pathname, routeDirectory) => {
+    const applicable = [];
+    let parts;
+    let directory = routeDirectory;
+    for (const { layout, segments, groupScope } of prepared) {
+      if (segments !== null) {
+        parts ?? (parts = splitNormalizedPathname(normalizePathname(pathname.replace(/\/$/, "") || "/")));
+        if (matchSegmentParts(segments, parts, true) === null) continue;
+      }
+      if (groupScope !== null) {
+        if (directory === void 0) directory = resolveRouteDirectory?.(pathname) ?? null;
+        if (!isInRouteGroupScope(directory, groupScope)) continue;
+      }
+      applicable.push(layout);
+    }
+    return applicable;
+  };
+}
+__name(createFarmLayoutSelector, "createFarmLayoutSelector");
+function layoutsCanCoverSamePage(a, b) {
+  const scopeA = getRouteGroupScope(a);
+  const scopeB = getRouteGroupScope(b);
+  if (scopeA !== null && scopeB !== null && !isInRouteGroupScope(scopeA, scopeB) && !isInRouteGroupScope(scopeB, scopeA)) {
+    return false;
+  }
+  const segmentsA = a === "/" ? [] : parseRoutePattern(a);
+  const segmentsB = b === "/" ? [] : parseRoutePattern(b);
+  const length = Math.min(segmentsA.length, segmentsB.length);
+  for (let index = 0; index < length; index++) {
+    const segmentA = segmentsA[index];
+    const segmentB = segmentsB[index];
+    if (segmentA.type === "dynamic" && segmentA.catchAll) return true;
+    if (segmentB.type === "dynamic" && segmentB.catchAll) return true;
+    if (segmentA.type === "dynamic" || segmentB.type === "dynamic") continue;
+    if (segmentA.value !== segmentB.value) return false;
+  }
+  return true;
+}
+__name(layoutsCanCoverSamePage, "layoutsCanCoverSamePage");
+
+export {
+  generateNativeMCPPluginSource,
+  createFarmLayoutSelector,
+  layoutsCanCoverSamePage
+};

package/dist/chunk-GCXWJJKH.mjs

@@ -0,0 +1,169 @@
+import {
+  decodeCookieName
+} from "./chunk-JM5XPKWH.mjs";
+import {
+  localizeFarmPathname,
+  resolveFarmLocalePath
+} from "./chunk-L3KT7IXV.mjs";
+import {
+  stripFarmBasePath
+} from "./chunk-4RB44K6Z.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/i18n/resolver.ts
+function getFarmLocaleVaryHeaders(config, resolution) {
+  if (!config.enabled || resolution.source === "url") return [];
+  const headers = [];
+  if (config.detection.includes("cookie")) headers.push("Cookie");
+  if (config.detection.includes("accept-language")) headers.push("Accept-Language");
+  return headers;
+}
+__name(getFarmLocaleVaryHeaders, "getFarmLocaleVaryHeaders");
+function resolveFarmLocaleRequest(request, config, options = {}) {
+  const url = new URL(request.url);
+  if (!config.enabled) {
+    return {
+      locale: config.defaultLocale,
+      source: "default",
+      pathname: url.pathname,
+      persist: false
+    };
+  }
+  const pathMatch = resolveFarmLocalePath(url.pathname, config);
+  if (pathMatch.explicit && pathMatch.locale) {
+    const canonicalPath = localizeFarmPathname(pathMatch.pathname, pathMatch.locale, config);
+    const differsOnlyByTrailingSlash = canonicalPath !== url.pathname && (url.pathname.length > 1 ? url.pathname.replace(/\/+$/, "") : url.pathname) === canonicalPath;
+    const redirect = options.redirect !== false && canonicalPath !== url.pathname && !differsOnlyByTrailingSlash ? `${canonicalPath}${url.search}${url.hash}` : void 0;
+    return {
+      locale: pathMatch.locale,
+      source: "url",
+      pathname: pathMatch.pathname,
+      redirect,
+      // Locale-prefixed pages are canonical and can be cached publicly. Locale
+      // switchers persist the same choice before navigating in the browser.
+      persist: false
+    };
+  }
+  const detected = detectLocale(request, config);
+  const shouldRedirect = options.redirect !== false && !isInternalOrApiPath(stripFarmBasePath(url.pathname, config.basePath)) && config.routing !== "none" && (config.routing === "prefix-always" || detected.locale !== config.defaultLocale);
+  return {
+    locale: detected.locale,
+    source: detected.source,
+    pathname: pathMatch.pathname,
+    redirect: shouldRedirect ? `${localizeFarmPathname(pathMatch.pathname, detected.locale, config)}${url.search}${url.hash}` : void 0,
+    persist: detected.source !== "default"
+  };
+}
+__name(resolveFarmLocaleRequest, "resolveFarmLocaleRequest");
+function createFarmLocaleCookie(locale, config) {
+  const cookie = config.cookie;
+  let value = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(locale)}`;
+  value += `; Max-Age=${cookie.maxAge}`;
+  value += `; Path=${cookie.path}`;
+  value += `; SameSite=${capitalize(cookie.sameSite)}`;
+  if (cookie.secure) value += "; Secure";
+  return value;
+}
+__name(createFarmLocaleCookie, "createFarmLocaleCookie");
+function matchFarmLocale(requested, locales) {
+  if (!requested) return void 0;
+  let canonical;
+  try {
+    canonical = Intl.getCanonicalLocales(requested)[0];
+  } catch {
+    return void 0;
+  }
+  const exact = locales.find((locale) => locale.toLowerCase() === canonical.toLowerCase());
+  if (exact) return exact;
+  const language = canonical.split("-")[0]?.toLowerCase();
+  const base = locales.find((locale) => locale.toLowerCase() === language);
+  if (base) return base;
+  return locales.find((locale) => locale.split("-")[0]?.toLowerCase() === language);
+}
+__name(matchFarmLocale, "matchFarmLocale");
+function detectLocale(request, config) {
+  for (const signal of config.detection) {
+    if (signal === "url") continue;
+    if (signal === "cookie") {
+      const locale = matchFarmLocale(
+        readCookie(request.headers.get("cookie"), config.cookie.name),
+        config.locales
+      );
+      if (locale) return { locale, source: "cookie" };
+    }
+    if (signal === "accept-language") {
+      const locale = resolveAcceptLanguage(request.headers.get("accept-language"), config.locales);
+      if (locale) return { locale, source: "accept-language" };
+    }
+  }
+  return { locale: config.defaultLocale, source: "default" };
+}
+__name(detectLocale, "detectLocale");
+function resolveAcceptLanguage(header, locales) {
+  if (!header) return void 0;
+  const byRange = /* @__PURE__ */ new Map();
+  for (const [index, entry] of header.split(",").entries()) {
+    const [rawLocale = "", ...parameters] = entry.trim().split(";");
+    const locale = rawLocale.trim();
+    if (!locale) continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [rawName, rawValue] = parameter.trim().split("=", 2);
+      if (rawName?.trim().toLowerCase() !== "q") continue;
+      const value = rawValue?.trim() ?? "";
+      quality = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/.test(value) ? Number(value) : 0;
+    }
+    const key = locale.toLowerCase();
+    const previous = byRange.get(key);
+    if (!previous || quality > previous.quality) {
+      byRange.set(key, { locale, quality, index: previous?.index ?? index });
+    }
+  }
+  const candidates = [...byRange.values()].filter((candidate) => candidate.quality > 0).sort((a, b) => b.quality - a.quality || a.index - b.index);
+  const explicitRanges = [...byRange.values()].filter(({ locale }) => locale !== "*");
+  for (const candidate of candidates) {
+    if (candidate.locale === "*") {
+      const wildcardMatch = locales.find(
+        (locale2) => !explicitRanges.some((range) => matchFarmLocale(range.locale, [locale2]) !== void 0)
+      );
+      if (wildcardMatch) return wildcardMatch;
+      continue;
+    }
+    const locale = matchFarmLocale(candidate.locale, locales);
+    if (locale) return locale;
+  }
+  return void 0;
+}
+__name(resolveAcceptLanguage, "resolveAcceptLanguage");
+function readCookie(header, name) {
+  if (!header) return void 0;
+  for (const part of header.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator < 0) continue;
+    if (decodeCookieName(part.slice(0, separator).trim()) !== name) continue;
+    try {
+      return decodeURIComponent(part.slice(separator + 1).trim());
+    } catch {
+      return part.slice(separator + 1).trim();
+    }
+  }
+  return void 0;
+}
+__name(readCookie, "readCookie");
+function isInternalOrApiPath(pathname) {
+  return pathname === "/api" || pathname.startsWith("/api/") || pathname.startsWith("/__farm/") || pathname.startsWith("/_farm/");
+}
+__name(isInternalOrApiPath, "isInternalOrApiPath");
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+__name(capitalize, "capitalize");
+
+export {
+  getFarmLocaleVaryHeaders,
+  resolveFarmLocaleRequest,
+  createFarmLocaleCookie,
+  matchFarmLocale
+};