@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-MFQGU5CC.mjs

@@ -0,0 +1,127 @@
+import {
+  assertBrowserStableRoutePath,
+  assertTerminalCatchAll,
+  assertUniqueRouteParameters
+} from "./chunk-AYP2YFVN.mjs";
+
+// src/routing/matcher.ts
+function parseRoutePattern(pattern) {
+  assertBrowserStableRoutePath(pattern);
+  assertTerminalCatchAll(pattern, "router");
+  assertUniqueRouteParameters(pattern, "router");
+  return splitRoutePattern(pattern).filter((part) => !isRouteGroup(part)).map((part) => {
+    const optionalCatchAll = part.match(/^\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]$/);
+    if (optionalCatchAll) {
+      return {
+        type: "dynamic",
+        name: optionalCatchAll[1],
+        catchAll: true,
+        optional: true
+      };
+    }
+    const catchAll = part.match(/^\[\.\.\.([A-Za-z0-9_$-]+)\]$/);
+    if (catchAll) {
+      return {
+        type: "dynamic",
+        name: catchAll[1],
+        catchAll: true,
+        optional: false
+      };
+    }
+    const dynamic = part.match(/^\[([A-Za-z0-9_$-]+)\]$/) || part.match(/^:([A-Za-z0-9_$-]+)$/);
+    if (dynamic) {
+      return {
+        type: "dynamic",
+        name: dynamic[1],
+        catchAll: false,
+        optional: false
+      };
+    }
+    const star = part.match(/^\*([A-Za-z0-9_$-]+)(\?)?$/);
+    if (star) {
+      return {
+        type: "dynamic",
+        name: star[1],
+        catchAll: true,
+        optional: !!star[2]
+      };
+    }
+    return {
+      type: "static",
+      value: decodePathSegment(part)
+    };
+  });
+}
+function matchSegmentParts(segments, parts, allowTrailingSegments = false) {
+  const params = {};
+  if (segments.length === 0) {
+    return parts.length === 0 ? params : null;
+  }
+  let pathIndex = 0;
+  for (const segment of segments) {
+    if (segment.type === "static") {
+      if (decodePathSegment(parts[pathIndex] || "") !== segment.value) return null;
+      pathIndex++;
+      continue;
+    }
+    if (segment.catchAll) {
+      const remaining = parts.slice(pathIndex).map(decodePathSegment);
+      if (remaining.length === 0 && !segment.optional) return null;
+      params[segment.name] = remaining.join("/");
+      pathIndex = parts.length;
+      continue;
+    }
+    const value = parts[pathIndex];
+    if (!value) return null;
+    params[segment.name] = decodePathSegment(value);
+    pathIndex++;
+  }
+  return allowTrailingSegments || pathIndex === parts.length ? params : null;
+}
+function normalizePathname(value) {
+  const raw = value || "/";
+  let pathname = raw;
+  try {
+    pathname = new URL(raw, "http://farm.local").pathname;
+  } catch {
+    pathname = raw.split(/[?#]/, 1)[0] || "/";
+  }
+  pathname = pathname.replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
+  return pathname || "/";
+}
+function splitPathname(pathname) {
+  return splitNormalizedPathname(normalizePathname(pathname));
+}
+function splitNormalizedPathname(pathname) {
+  return pathname.split("/").filter(Boolean);
+}
+function normalizeRoutePattern(value) {
+  let pathname = (value || "/").replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
+  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
+  return pathname || "/";
+}
+function splitRoutePattern(pattern) {
+  return normalizeRoutePattern(pattern).split("/").filter(Boolean);
+}
+function isRouteGroup(part) {
+  return part.startsWith("(") && part.endsWith(")");
+}
+function decodePathSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export {
+  parseRoutePattern,
+  matchSegmentParts,
+  normalizePathname,
+  splitPathname,
+  splitNormalizedPathname,
+  normalizeRoutePattern
+};

package/dist/chunk-MJ6IC4K2.mjs

@@ -0,0 +1,34 @@
+import {
+  runWithServerActionRequest
+} from "./chunk-JOHXK4BB.mjs";
+import {
+  getFarmRedirectError,
+  isFarmNotFoundError
+} from "./chunk-JNYFXL7X.mjs";
+
+// src/form-actions.ts
+import { handleAction, registerServerReference } from "@farm.js/islx/server";
+var FARM_FORM_ACTION_HEADER = "F-Action";
+function registerFarmFormAction(action, id) {
+  return registerServerReference(action, id);
+}
+function handleFarmFormActionRequest(request, config) {
+  return handleAction(request, {
+    allowedOrigins: config.allowedOrigins,
+    bodySizeLimit: config.bodySizeLimit,
+    run: (actionRequest, action) => runWithServerActionRequest(actionRequest, action),
+    mapError(error) {
+      const redirect = getFarmRedirectError(error);
+      if (redirect) return { redirect: redirect.url };
+      if (isFarmNotFoundError(error)) return { status: 404 };
+      return void 0;
+    },
+    onError: (error) => console.error("[Farm.js] Server action failed:", error)
+  });
+}
+
+export {
+  FARM_FORM_ACTION_HEADER,
+  registerFarmFormAction,
+  handleFarmFormActionRequest
+};

package/dist/chunk-MNIR7I7B.mjs

@@ -0,0 +1,217 @@
+import {
+  FARM_ACTION_TAG,
+  FARM_OBJECT_TAG,
+  FARM_REFERENCE_TAG,
+  FARM_SLOT_TAG,
+  FARM_TAG,
+  FARM_TAG_VALUE,
+  getFarmTag
+} from "./chunk-NBIVGHAT.mjs";
+
+// src/client/island-codec.ts
+var TYPED_ARRAYS = {
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+};
+function toBase64(bytes) {
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+  }
+  return btoa(binary);
+}
+function fromBase64(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function farmTagged(tag, value) {
+  return value === void 0 ? { [FARM_TAG]: tag } : { [FARM_TAG]: tag, [FARM_TAG_VALUE]: value };
+}
+function needsFarmObjectTag(object) {
+  return Object.prototype.hasOwnProperty.call(object, FARM_TAG);
+}
+function encodeFarmLeaf(value) {
+  switch (typeof value) {
+    case "undefined":
+      return farmTagged("u");
+    case "bigint":
+      return farmTagged("B", value.toString());
+    case "number":
+      if (Number.isNaN(value)) return farmTagged("n", "NaN");
+      if (value === Infinity) return farmTagged("n", "Infinity");
+      if (value === -Infinity) return farmTagged("n", "-Infinity");
+      if (Object.is(value, -0)) return farmTagged("n", "-0");
+      return void 0;
+    case "object":
+      break;
+    default:
+      return void 0;
+  }
+  if (value === null) return void 0;
+  if (value instanceof Date) {
+    return farmTagged("D", Number.isNaN(value.getTime()) ? null : value.toISOString());
+  }
+  if (typeof URL === "function" && value instanceof URL) return farmTagged("U", value.href);
+  if (value instanceof RegExp) return farmTagged("R", [value.source, value.flags]);
+  if (value instanceof ArrayBuffer) {
+    return farmTagged("Y", ["ArrayBuffer", toBase64(new Uint8Array(value))]);
+  }
+  if (ArrayBuffer.isView(value)) {
+    const name = value instanceof DataView ? "DataView" : value.constructor.name;
+    if (name !== "DataView" && !(name in TYPED_ARRAYS)) return void 0;
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return farmTagged("Y", [name, toBase64(bytes)]);
+  }
+  return void 0;
+}
+var NOT_A_FARM_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
+function farmPlainObject(entries) {
+  const object = {};
+  for (const [key, value] of entries) {
+    Object.defineProperty(object, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return object;
+}
+function decodeFarmTagged(object, decodeChild) {
+  const tag = object[FARM_TAG];
+  const data = object[FARM_TAG_VALUE];
+  switch (tag) {
+    case FARM_REFERENCE_TAG:
+    case FARM_SLOT_TAG:
+    case FARM_ACTION_TAG:
+      return NOT_A_FARM_MARKER;
+    case FARM_OBJECT_TAG:
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        return farmPlainObject(
+          Object.entries(data).map(([key, value]) => [key, decodeChild(value)])
+        );
+      }
+      break;
+    case "u":
+      return void 0;
+    case "n":
+      if (data === "NaN") return Number.NaN;
+      if (data === "Infinity") return Infinity;
+      if (data === "-Infinity") return -Infinity;
+      if (data === "-0") return -0;
+      break;
+    case "B":
+      if (typeof data === "string" && /^-?\d+$/.test(data)) return BigInt(data);
+      break;
+    case "D":
+      if (data === null) return new Date(Number.NaN);
+      if (typeof data === "string") return new Date(data);
+      break;
+    case "U":
+      if (typeof data === "string") return new URL(data);
+      break;
+    case "R":
+      if (Array.isArray(data) && typeof data[0] === "string" && typeof data[1] === "string") {
+        return new RegExp(data[0], data[1]);
+      }
+      break;
+    case "Y": {
+      if (!Array.isArray(data) || typeof data[0] !== "string" || typeof data[1] !== "string") break;
+      const bytes = fromBase64(data[1]);
+      if (data[0] === "ArrayBuffer") return bytes.buffer;
+      if (data[0] === "DataView") return new DataView(bytes.buffer);
+      const TypedArray = Object.prototype.hasOwnProperty.call(TYPED_ARRAYS, data[0]) ? TYPED_ARRAYS[data[0]] : void 0;
+      if (!TypedArray || bytes.byteLength % TypedArray.BYTES_PER_ELEMENT !== 0) break;
+      return new TypedArray(
+        bytes.buffer,
+        0,
+        bytes.byteLength / TypedArray.BYTES_PER_ELEMENT
+      );
+    }
+    case "M":
+      if (Array.isArray(data) && data.every((entry) => Array.isArray(entry) && entry.length === 2)) {
+        return new Map(data.map(([key, value]) => [decodeChild(key), decodeChild(value)]));
+      }
+      break;
+    case "S":
+      if (Array.isArray(data)) return new Set(data.map(decodeChild));
+      break;
+    default:
+      throw new TypeError(`unknown ${JSON.stringify(tag)} tag`);
+  }
+  throw new TypeError(`malformed ${JSON.stringify(tag)} tag`);
+}
+function encodeFarmJson(value, seen = /* @__PURE__ */ new Set()) {
+  const leaf = encodeFarmLeaf(value);
+  if (leaf) return leaf;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return value;
+  if (typeof value !== "object") throw new TypeError(`${typeof value} values are not serializable`);
+  if (seen.has(value)) throw new TypeError("circular values are not serializable");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((entry) => encodeFarmJson(entry, seen));
+    if (value instanceof Map) {
+      return farmTagged(
+        "M",
+        Array.from(value, ([key, entry]) => [
+          encodeFarmJson(key, seen),
+          encodeFarmJson(entry, seen)
+        ])
+      );
+    }
+    if (value instanceof Set) {
+      return farmTagged(
+        "S",
+        Array.from(value, (entry) => encodeFarmJson(entry, seen))
+      );
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("class instances are not serializable");
+    }
+    const encoded = Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, encodeFarmJson(entry, seen)])
+    );
+    return needsFarmObjectTag(value) ? farmTagged(FARM_OBJECT_TAG, encoded) : encoded;
+  } finally {
+    seen.delete(value);
+  }
+}
+function decodeFarmJson(value) {
+  if (Array.isArray(value)) return value.map(decodeFarmJson);
+  if (!value || typeof value !== "object") return value;
+  if (getFarmTag(value) !== void 0) {
+    const decoded = decodeFarmTagged(value, decodeFarmJson);
+    if (decoded === NOT_A_FARM_MARKER) {
+      throw new TypeError(
+        `a ${JSON.stringify(value[FARM_TAG])} reference is not allowed here`
+      );
+    }
+    return decoded;
+  }
+  if (needsFarmObjectTag(value)) throw new TypeError('malformed "$" tag');
+  return farmPlainObject(Object.entries(value).map(([key, entry]) => [key, decodeFarmJson(entry)]));
+}
+
+export {
+  farmTagged,
+  needsFarmObjectTag,
+  encodeFarmLeaf,
+  NOT_A_FARM_MARKER,
+  farmPlainObject,
+  decodeFarmTagged,
+  encodeFarmJson,
+  decodeFarmJson
+};

package/dist/chunk-MPU5DOXX.cjs

@@ -0,0 +1,21 @@
+"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/server-query-protocol.ts
+var FARM_SERVER_QUERY_RESULT_VERSION = 1;
+function createFarmServerQueryResult(data, metadata) {
+  return {
+    __farmServerQuery: {
+      version: FARM_SERVER_QUERY_RESULT_VERSION,
+      ...metadata
+    },
+    data
+  };
+}
+function isFarmServerQueryResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const metadata = value.__farmServerQuery;
+  return _optionalChain([metadata, 'optionalAccess', _ => _.version]) === FARM_SERVER_QUERY_RESULT_VERSION && typeof metadata.key === "string" && (metadata.staleTime === false || typeof metadata.staleTime === "number") && typeof metadata.updatedAt === "number" && "data" in value;
+}
+
+
+
+
+exports.createFarmServerQueryResult = createFarmServerQueryResult; exports.isFarmServerQueryResult = isFarmServerQueryResult;

package/dist/chunk-MTB57GOK.mjs

@@ -0,0 +1,81 @@
+import {
+  attachRevalidationListeners,
+  createServerQueryCallKey,
+  fetchServerQuery
+} from "./chunk-BNMHXVLL.mjs";
+import {
+  getFarmClientDataCache
+} from "./chunk-C64XOPBZ.mjs";
+
+// src/server-query-client.ts
+import { useCallback, useEffect, useRef, useSyncExternalStore } from "react";
+function useServerQuery(query, input, options = {}) {
+  const cache = getFarmClientDataCache();
+  const key = createServerQueryCallKey(query, input);
+  const inputRef = useRef(input);
+  const optionsRef = useRef(options);
+  const mountedKeyRef = useRef(void 0);
+  const pendingInvalidationRef = useRef(false);
+  inputRef.current = input;
+  optionsRef.current = options;
+  const subscribe = useCallback(
+    (listener) => cache.subscribe(key, (event) => {
+      if (event === "invalidate") pendingInvalidationRef.current = true;
+      else if (cache.get(key)?.fetching) {
+        pendingInvalidationRef.current = false;
+      }
+      listener();
+    }),
+    [cache, key]
+  );
+  const getSnapshot = useCallback(() => cache.get(key), [cache, key]);
+  const entry = useSyncExternalStore(subscribe, getSnapshot, () => void 0);
+  const run = useCallback(
+    (force = false) => {
+      pendingInvalidationRef.current = false;
+      return fetchServerQuery(query, inputRef.current, {
+        ...optionsRef.current,
+        force
+      });
+    },
+    [query]
+  );
+  useEffect(() => {
+    if (options.enabled === false) {
+      mountedKeyRef.current = void 0;
+      return;
+    }
+    const firstReadForKey = mountedKeyRef.current !== key;
+    if (firstReadForKey) mountedKeyRef.current = key;
+    if (firstReadForKey && (!entry || cache.isStale(key)) || pendingInvalidationRef.current && entry?.invalidatedAt !== void 0 && !entry.fetching) {
+      void run().catch(() => void 0);
+    }
+  }, [cache, entry, key, options.enabled, run]);
+  useEffect(() => {
+    if (options.enabled === false) return;
+    return attachRevalidationListeners(
+      () => {
+        if (cache.isStale(key)) void run().catch(() => void 0);
+      },
+      {
+        refetchOnWindowFocus: options.refetchOnWindowFocus,
+        refetchOnReconnect: options.refetchOnReconnect
+      }
+    );
+  }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);
+  const status = entry?.status ?? (entry ? "success" : "idle");
+  const fetching = entry?.fetching ?? false;
+  return {
+    data: entry?.data,
+    error: entry?.error ?? null,
+    status,
+    pending: status === "pending" && (entry?.updatedAt ?? 0) === 0,
+    fetching,
+    stale: cache.isStale(key),
+    refetch: () => run(true)
+  };
+}
+
+export {
+  useServerQuery
+};

package/dist/chunk-MU5V7XHL.mjs

@@ -0,0 +1,172 @@
+// src/i18n/config.ts
+import path from "path";
+var DEFAULT_FARM_I18N_COOKIE = "farm_locale";
+var DEFAULT_FARM_I18N_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
+var DEFAULT_DETECTION = ["url", "cookie", "accept-language"];
+function resolveFarmI18nConfig(input, options = {}) {
+  const root = options.root || process.cwd();
+  const basePath = options.basePath || "/";
+  const strictByDefault = options.mode === "production";
+  if (!input) {
+    return {
+      enabled: false,
+      basePath,
+      locales: ["en"],
+      defaultLocale: "en",
+      messages: path.join(root, "src/messages"),
+      routing: "none",
+      detection: [],
+      fallbackLocale: "en",
+      strict: strictByDefault,
+      cookie: {
+        name: DEFAULT_FARM_I18N_COOKIE,
+        maxAge: DEFAULT_FARM_I18N_COOKIE_MAX_AGE,
+        path: "/",
+        sameSite: "lax",
+        secure: options.mode === "production"
+      },
+      direction: {}
+    };
+  }
+  if (!Array.isArray(input.locales) || input.locales.length === 0) {
+    throw new Error("i18n.locales must contain at least one locale.");
+  }
+  const locales = input.locales.map(canonicalizeLocale);
+  if (new Set(locales).size !== locales.length) {
+    throw new Error("i18n.locales must not contain duplicate locales.");
+  }
+  const defaultLocale = canonicalizeLocale(input.defaultLocale);
+  if (!locales.includes(defaultLocale)) {
+    throw new Error(`i18n.defaultLocale "${defaultLocale}" must be included in i18n.locales.`);
+  }
+  const fallbackLocale = canonicalizeLocale(input.fallbackLocale || defaultLocale);
+  if (!locales.includes(fallbackLocale)) {
+    throw new Error(`i18n.fallbackLocale "${fallbackLocale}" must be included in i18n.locales.`);
+  }
+  const detection = resolveDetection(input);
+  const sameSite = input.cookie?.sameSite ?? "lax";
+  if (sameSite !== "lax" && sameSite !== "strict" && sameSite !== "none") {
+    throw new Error('i18n.cookie.sameSite must be "lax", "strict", or "none".');
+  }
+  if (sameSite === "none" && input.cookie?.secure === false) {
+    throw new Error('i18n.cookie.secure cannot be false when i18n.cookie.sameSite is "none".');
+  }
+  const direction = {};
+  for (const [rawLocale, value] of Object.entries(input.direction || {})) {
+    const locale = canonicalizeLocale(rawLocale);
+    if (!locales.includes(locale)) {
+      throw new Error(`i18n.direction contains unknown locale "${rawLocale}".`);
+    }
+    if (value !== "ltr" && value !== "rtl") {
+      throw new Error(`i18n.direction.${rawLocale} must be "ltr" or "rtl".`);
+    }
+    direction[locale] = value;
+  }
+  return {
+    enabled: true,
+    basePath,
+    locales,
+    defaultLocale,
+    messages: path.resolve(root, input.messages || "src/messages"),
+    routing: input.routing || "prefix-except-default",
+    detection,
+    fallbackLocale,
+    strict: input.strict ?? strictByDefault,
+    cookie: {
+      name: input.cookie?.name?.trim() || DEFAULT_FARM_I18N_COOKIE,
+      maxAge: normalizePositiveInteger(
+        input.cookie?.maxAge,
+        DEFAULT_FARM_I18N_COOKIE_MAX_AGE,
+        "i18n.cookie.maxAge"
+      ),
+      path: normalizeCookiePath(input.cookie?.path),
+      sameSite,
+      secure: input.cookie?.secure ?? (sameSite === "none" || options.mode === "production")
+    },
+    direction
+  };
+}
+function resolveFarmI18nMessagePath(config, locale) {
+  return config.messages.includes("{locale}") ? config.messages.split("{locale}").join(locale) : path.join(config.messages, `${locale}.json`);
+}
+function isFarmI18nCatalogFile(config, file) {
+  if (!config.enabled) return false;
+  const normalizedFile = file.replace(/\\/g, "/");
+  return config.locales.some(
+    (locale) => resolveFarmI18nMessagePath(config, locale).replace(/\\/g, "/") === normalizedFile
+  );
+}
+function canonicalizeLocale(locale) {
+  if (!locale || typeof locale !== "string") {
+    throw new Error("Farm i18n locales must be non-empty strings.");
+  }
+  try {
+    return Intl.getCanonicalLocales(locale)[0];
+  } catch {
+    throw new Error(`Invalid i18n locale "${locale}".`);
+  }
+}
+function resolveDetection(input) {
+  if (input.detection === false || input.localeDetection === false) {
+    return ["url"];
+  }
+  const detection = input.detection || DEFAULT_DETECTION;
+  const allowed = /* @__PURE__ */ new Set(["url", "cookie", "accept-language"]);
+  const unique = [];
+  for (const signal of detection) {
+    if (!allowed.has(signal)) {
+      throw new Error(`Unsupported i18n detection signal "${signal}".`);
+    }
+    if (!unique.includes(signal)) unique.push(signal);
+  }
+  return unique;
+}
+function normalizePositiveInteger(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+  return value;
+}
+function normalizeCookiePath(value) {
+  if (value === void 0) return "/";
+  if (typeof value !== "string") {
+    throw new Error("i18n.cookie.path must be a root-relative pathname.");
+  }
+  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+  if (hasUnstableCharacters(value)) {
+    throw new Error("i18n.cookie.path cannot contain backslashes or control characters.");
+  }
+  const pathname = value.trim();
+  if (!pathname || !pathname.startsWith("/") || pathname.startsWith("//") || pathname.includes(";") || pathname.includes("?") || pathname.includes("#")) {
+    throw new Error(
+      "i18n.cookie.path must be a root-relative pathname without attributes, a query, or a hash."
+    );
+  }
+  for (const segment of pathname.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new Error("i18n.cookie.path cannot contain backslashes or control characters.");
+    }
+    if (decoded.includes("/")) {
+      throw new Error("i18n.cookie.path cannot contain percent-encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('i18n.cookie.path cannot contain "." or ".." path segments.');
+    }
+  }
+  return pathname;
+}
+
+export {
+  resolveFarmI18nConfig,
+  resolveFarmI18nMessagePath,
+  isFarmI18nCatalogFile
+};