@farm.js/core 0.1.16 → 0.1.18

package/dist/i18n/server.cjs

@@ -1,756 +1,33 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/i18n/server.ts
-var server_exports = {};
-__export(server_exports, {
-  FarmI18nRuntime: () => FarmI18nRuntime,
-  _runWithFarmI18nRequest: () => _runWithFarmI18nRequest,
-  _setDefaultFarmI18nRuntime: () => _setDefaultFarmI18nRuntime,
-  createFarmI18nRuntime: () => createFarmI18nRuntime,
-  createTranslator: () => createTranslator,
-  format: () => format,
-  getFarmI18nClientSnapshot: () => getFarmI18nClientSnapshot,
-  getLocale: () => getLocale,
-  getLocaleSource: () => getLocaleSource,
-  runWithLocale: () => runWithLocale,
-  t: () => t
-});
-module.exports = __toCommonJS(server_exports);
-var import_node_async_hooks = require("async_hooks");
 
-// src/i18n/bridge.ts
-var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
-function _setFarmI18nSnapshotResolver(resolver) {
-  globalThis[FARM_I18N_SNAPSHOT_RESOLVER] = resolver;
-}
-__name(_setFarmI18nSnapshotResolver, "_setFarmI18nSnapshotResolver");
 
-// src/i18n/runtime.ts
-var import_intl_messageformat = __toESM(require("intl-messageformat"));
 
-// src/i18n/catalog.ts
-var import_promises = require("fs/promises");
-var import_icu_messageformat_parser = require("@formatjs/icu-messageformat-parser");
 
-// src/i18n/config.ts
-var import_node_path = __toESM(require("path"));
-var DEFAULT_FARM_I18N_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
-function resolveFarmI18nMessagePath(config, locale) {
-  return config.messages.includes("{locale}") ? config.messages.split("{locale}").join(locale) : import_node_path.default.join(config.messages, `${locale}.json`);
-}
-__name(resolveFarmI18nMessagePath, "resolveFarmI18nMessagePath");
 
-// src/i18n/catalog.ts
-async function readFarmI18nCatalogs(config) {
-  if (!config.enabled) {
-    return { catalogs: {}, signatures: {} };
-  }
-  const catalogs = {};
-  for (const locale of config.locales) {
-    const filePath = resolveFarmI18nMessagePath(config, locale);
-    let source;
-    try {
-      source = await (0, import_promises.readFile)(filePath, "utf8");
-    } catch (error) {
-      throw new Error(
-        `Unable to read Farm i18n catalog for "${locale}" at ${filePath}: ${messageOf(error)}`
-      );
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(source);
-    } catch (error) {
-      throw new Error(`Invalid JSON in Farm i18n catalog ${filePath}: ${messageOf(error)}`);
-    }
-    catalogs[locale] = flattenFarmI18nCatalog(parsed, filePath);
-  }
-  const reference = catalogs[config.defaultLocale] || {};
-  const signatures = {};
-  for (const [key, message] of Object.entries(reference)) {
-    signatures[key] = analyzeFarmI18nMessage(message, `${config.defaultLocale}:${key}`);
-  }
-  validateFarmI18nCatalogs(config, catalogs, signatures);
-  return { catalogs, signatures };
-}
-__name(readFarmI18nCatalogs, "readFarmI18nCatalogs");
-function flattenFarmI18nCatalog(input, source = "i18n catalog") {
-  if (!isPlainObject(input)) {
-    throw new Error(`${source} must contain a JSON object at its root.`);
-  }
-  const output = {};
-  const visit = /* @__PURE__ */ __name((value, segments) => {
-    if (typeof value === "string") {
-      const key = segments.join(".");
-      if (!key) throw new Error(`${source} contains an empty message key.`);
-      if (Object.prototype.hasOwnProperty.call(output, key)) {
-        throw new Error(`${source} contains duplicate message key "${key}".`);
-      }
-      output[key] = value;
-      return;
-    }
-    if (!isPlainObject(value)) {
-      const key = segments.join(".") || "<root>";
-      throw new Error(`${source} message "${key}" must be a string or nested object.`);
-    }
-    for (const [key, nested] of Object.entries(value)) {
-      if (!key.trim()) throw new Error(`${source} contains an empty message key.`);
-      visit(nested, [...segments, key]);
-    }
-  }, "visit");
-  visit(input, []);
-  return output;
-}
-__name(flattenFarmI18nCatalog, "flattenFarmI18nCatalog");
-function analyzeFarmI18nMessage(message, label = "message") {
-  let ast;
-  try {
-    ast = (0, import_icu_messageformat_parser.parse)(message, { captureLocation: false });
-  } catch (error) {
-    throw new Error(`Invalid ICU syntax in ${label}: ${messageOf(error)}`);
-  }
-  const signature = {};
-  collectArguments(ast, signature, label);
-  return signature;
-}
-__name(analyzeFarmI18nMessage, "analyzeFarmI18nMessage");
-function validateFarmI18nCatalogs(config, catalogs, signatures) {
-  const referenceKeys = Object.keys(catalogs[config.defaultLocale] || {}).sort();
-  for (const locale of config.locales) {
-    const catalog = catalogs[locale] || {};
-    const localeKeys = Object.keys(catalog).sort();
-    const missing = referenceKeys.filter(
-      (key) => !Object.prototype.hasOwnProperty.call(catalog, key)
-    );
-    const extra = localeKeys.filter(
-      (key) => !Object.prototype.hasOwnProperty.call(signatures, key)
-    );
-    if (config.strict && (missing.length > 0 || extra.length > 0)) {
-      const details = [
-        missing.length ? `missing: ${missing.join(", ")}` : "",
-        extra.length ? `extra: ${extra.join(", ")}` : ""
-      ].filter(Boolean).join("; ");
-      throw new Error(
-        `Farm i18n catalog "${locale}" does not match the default catalog (${details}).`
-      );
-    }
-    for (const [key, message] of Object.entries(catalog)) {
-      const actual = analyzeFarmI18nMessage(message, `${locale}:${key}`);
-      const expected = signatures[key];
-      if (!expected || sameSignature(expected, actual)) continue;
-      throw new Error(
-        `Farm i18n message "${key}" in "${locale}" uses different variables than "${config.defaultLocale}".`
-      );
-    }
-  }
-}
-__name(validateFarmI18nCatalogs, "validateFarmI18nCatalogs");
-function collectArguments(elements, signature, label) {
-  for (const element of elements) {
-    switch (element.type) {
-      case import_icu_messageformat_parser.TYPE.argument:
-        addArgument(signature, element.value, "string", label);
-        break;
-      case import_icu_messageformat_parser.TYPE.number:
-      case import_icu_messageformat_parser.TYPE.plural:
-        addArgument(signature, element.value, "number", label);
-        break;
-      case import_icu_messageformat_parser.TYPE.date:
-      case import_icu_messageformat_parser.TYPE.time:
-        addArgument(signature, element.value, "date", label);
-        break;
-      case import_icu_messageformat_parser.TYPE.select:
-        addArgument(signature, element.value, "select", label);
-        break;
-      case import_icu_messageformat_parser.TYPE.tag:
-        addArgument(signature, element.value, "rich", label);
-        collectArguments(element.children, signature, label);
-        break;
-    }
-    if (element.type === import_icu_messageformat_parser.TYPE.plural || element.type === import_icu_messageformat_parser.TYPE.select) {
-      for (const option of Object.values(element.options)) {
-        collectArguments(option.value, signature, label);
-      }
-    }
-  }
-}
-__name(collectArguments, "collectArguments");
-function addArgument(signature, name, kind, label) {
-  const existing = signature[name];
-  if (existing && existing !== kind) {
-    throw new Error(`Farm i18n ${label} uses variable "${name}" as both ${existing} and ${kind}.`);
-  }
-  signature[name] = kind;
-}
-__name(addArgument, "addArgument");
-function sameSignature(expected, actual) {
-  const expectedEntries = Object.entries(expected).sort(([a], [b]) => a.localeCompare(b));
-  const actualEntries = Object.entries(actual).sort(([a], [b]) => a.localeCompare(b));
-  return JSON.stringify(expectedEntries) === JSON.stringify(actualEntries);
-}
-__name(sameSignature, "sameSignature");
-function isPlainObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-__name(isPlainObject, "isPlainObject");
-function messageOf(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(messageOf, "messageOf");
 
-// src/base-path.ts
-var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
-function getFarmGlobalState() {
-  return globalThis;
-}
-__name(getFarmGlobalState, "getFarmGlobalState");
-function getFarmBasePath() {
-  return getFarmGlobalState()[FARM_BASE_PATH] ?? "";
-}
-__name(getFarmBasePath, "getFarmBasePath");
-function applyFarmBasePath(href, basePath = getFarmBasePath()) {
-  const normalizedBasePath = normalizeFarmBasePath(basePath);
-  if (!normalizedBasePath || !href.startsWith("/") || href.startsWith("//")) return href;
-  const canonicalHref = canonicalizeAppRelativeHref(href);
-  if (canonicalHref === normalizedBasePath || canonicalHref.startsWith(`${normalizedBasePath}/`) || canonicalHref.startsWith(`${normalizedBasePath}?`) || canonicalHref.startsWith(`${normalizedBasePath}#`)) {
-    return canonicalHref;
-  }
-  return `${normalizedBasePath}${canonicalHref}`;
-}
-__name(applyFarmBasePath, "applyFarmBasePath");
-function canonicalizeAppRelativeHref(href) {
-  const origin = "http://farm.local";
-  const resolved = new URL(href, origin);
-  if (resolved.origin !== origin) {
-    throw new Error("Farm app-relative href cannot change the URL origin.");
-  }
-  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
-}
-__name(canonicalizeAppRelativeHref, "canonicalizeAppRelativeHref");
-function stripFarmBasePath(pathname, basePath = getFarmBasePath()) {
-  const normalizedBasePath = normalizeFarmBasePath(basePath);
-  if (!normalizedBasePath) return pathname || "/";
-  if (pathname === normalizedBasePath) return "/";
-  if (!pathname.startsWith(`${normalizedBasePath}/`)) return pathname || "/";
-  return pathname.slice(normalizedBasePath.length) || "/";
-}
-__name(stripFarmBasePath, "stripFarmBasePath");
-function normalizeFarmBasePath(basePath) {
-  if (!basePath || basePath === "/") return "";
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  if (hasUnstableCharacters(basePath)) {
-    throw new Error("Farm basePath cannot contain backslashes or control characters.");
-  }
-  const pathname = basePath.trim();
-  if (!pathname || pathname === "/") return "";
-  if (pathname.includes("?") || pathname.includes("#")) {
-    throw new Error("Farm basePath cannot contain a query string or hash.");
-  }
-  if (pathname.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(pathname)) {
-    throw new Error('Farm basePath must be a pathname such as "/docs", not a URL.');
-  }
-  for (const segment of pathname.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("Farm basePath cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("Farm basePath cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('Farm basePath cannot contain "." or ".." path segments.');
-    }
-  }
-  return `/${pathname}`.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
-}
-__name(normalizeFarmBasePath, "normalizeFarmBasePath");
 
-// src/i18n/routing.ts
-var RTL_LANGUAGES = /* @__PURE__ */ new Set([
-  "ar",
-  "arc",
-  "ckb",
-  "dv",
-  "fa",
-  "he",
-  "ku",
-  "nqo",
-  "ps",
-  "sd",
-  "syr",
-  "ug",
-  "ur",
-  "yi"
-]);
-function resolveFarmLocalePath(pathname, config) {
-  const normalized = normalizePathname(stripFarmBasePath(pathname, config.basePath));
-  if (config.routing === "none") {
-    return { pathname: normalized, explicit: false };
-  }
-  const segments = normalized.split("/").filter(Boolean);
-  const firstSegment = segments[0];
-  const locale = config.locales.find(
-    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
-  );
-  if (!locale) {
-    return { pathname: normalized, explicit: false };
-  }
-  const remaining = segments.slice(1);
-  return {
-    locale,
-    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
-    explicit: true
-  };
-}
-__name(resolveFarmLocalePath, "resolveFarmLocalePath");
-function localizeFarmPathname(pathname, locale, config) {
-  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
-  let localizedPathname = internalPathname;
-  if (config.routing === "none") {
-    return applyFarmBasePath(localizedPathname, config.basePath);
-  }
-  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
-    return applyFarmBasePath(localizedPathname, config.basePath);
-  }
-  localizedPathname = internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
-  return applyFarmBasePath(localizedPathname, config.basePath);
-}
-__name(localizeFarmPathname, "localizeFarmPathname");
-function getFarmLocaleDirection(locale, direction) {
-  const configured = direction?.[locale];
-  if (configured) return configured;
-  const language = locale.split("-")[0]?.toLowerCase() || locale.toLowerCase();
-  return RTL_LANGUAGES.has(language) ? "rtl" : "ltr";
-}
-__name(getFarmLocaleDirection, "getFarmLocaleDirection");
-function normalizePathname(pathname) {
-  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  if (withLeadingSlash === "/") return "/";
-  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
-}
-__name(normalizePathname, "normalizePathname");
 
-// src/i18n/resolver.ts
-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 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;
-    let key;
-    try {
-      key = decodeURIComponent(part.slice(0, separator).trim());
-    } catch {
-      continue;
-    }
-    if (key !== 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");
 
-// src/i18n/runtime.ts
-var _FarmI18nRuntime = class _FarmI18nRuntime {
-  constructor(config, catalogs = {}) {
-    this.compiled = /* @__PURE__ */ new Map();
-    this.warnedMissing = /* @__PURE__ */ new Set();
-    this.config = config;
-    this.catalogs = catalogs;
-  }
-  async initialize() {
-    if (!this.config.enabled) return;
-    const bundle = await readFarmI18nCatalogs(this.config);
-    this.replaceCatalogs(bundle.catalogs);
-  }
-  async reload() {
-    await this.initialize();
-  }
-  replaceCatalogs(catalogs) {
-    this.catalogs = catalogs;
-    this.compiled.clear();
-    this.warnedMissing.clear();
-  }
-  getCatalogs() {
-    return Object.fromEntries(
-      Object.entries(this.catalogs).map(([locale, catalog]) => [locale, { ...catalog }])
-    );
-  }
-  resolveRequest(request, options = {}) {
-    return resolveFarmLocaleRequest(request, this.config, options);
-  }
-  translate(locale, key, values) {
-    const result = this.formatMessage(locale, key, values);
-    if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
-      throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
-    }
-    return Array.isArray(result) ? result.join("") : String(result);
-  }
-  translateRich(locale, key, values) {
-    const result = this.formatMessage(locale, key, values);
-    return Array.isArray(result) && result.length === 1 ? result[0] : result;
-  }
-  getRawMessage(locale, key) {
-    return this.resolveMessage(locale, key);
-  }
-  hasMessage(locale, key) {
-    return this.readOwnMessage(locale, key) !== void 0;
-  }
-  getClientSnapshot(resolution) {
-    return {
-      locale: resolution.locale,
-      source: resolution.source,
-      locales: this.config.locales,
-      defaultLocale: this.config.defaultLocale,
-      routing: this.config.routing,
-      basePath: this.config.basePath,
-      cookie: this.config.cookie,
-      direction: getFarmLocaleDirection(resolution.locale, this.config.direction),
-      messages: {
-        ...this.catalogs[this.config.fallbackLocale],
-        ...this.catalogs[resolution.locale]
-      }
-    };
-  }
-  formatMessage(locale, key, values) {
-    const message = this.resolveMessage(locale, key);
-    const cacheKey = `${locale}\0${key}\0${message}`;
-    let formatter = this.compiled.get(cacheKey);
-    if (!formatter) {
-      formatter = new import_intl_messageformat.default(message, locale);
-      this.compiled.set(cacheKey, formatter);
-    }
-    return formatter.format(values);
-  }
-  // Look up a message by own-property only. A key named after an
-  // Object.prototype member (toString, valueOf, constructor, ...) must resolve
-  // to a real catalog entry or undefined, never the inherited prototype value
-  // (mirrors the own-property handling added to catalog.ts in #454).
-  readOwnMessage(locale, key) {
-    const direct = this.catalogs[locale];
-    if (direct && Object.prototype.hasOwnProperty.call(direct, key)) return direct[key];
-    const fallback = this.catalogs[this.config.fallbackLocale];
-    if (fallback && Object.prototype.hasOwnProperty.call(fallback, key)) return fallback[key];
-    return void 0;
-  }
-  resolveMessage(locale, key) {
-    const message = this.readOwnMessage(locale, key);
-    if (message !== void 0) return message;
-    if (this.config.strict) {
-      throw new Error(`Missing Farm i18n message "${key}" for locale "${locale}".`);
-    }
-    const warningKey = `${locale}:${key}`;
-    if (!this.warnedMissing.has(warningKey)) {
-      this.warnedMissing.add(warningKey);
-      console.warn(`[Farm.js] Missing i18n message "${key}" for locale "${locale}".`);
-    }
-    return key;
-  }
-};
-__name(_FarmI18nRuntime, "FarmI18nRuntime");
-var FarmI18nRuntime = _FarmI18nRuntime;
-function createFarmI18nRuntime(config, catalogs) {
-  return new FarmI18nRuntime(config, catalogs);
-}
-__name(createFarmI18nRuntime, "createFarmI18nRuntime");
 
-// src/i18n/server.ts
-var FARM_I18N_REQUEST_STORE = /* @__PURE__ */ Symbol.for("farm.i18n.requestStore");
-var FARM_I18N_DEFAULT_RUNTIME = /* @__PURE__ */ Symbol.for("farm.i18n.defaultRuntime");
-function getRequestStore() {
-  const state = globalThis;
-  return state[FARM_I18N_REQUEST_STORE] ?? (state[FARM_I18N_REQUEST_STORE] = new import_node_async_hooks.AsyncLocalStorage());
-}
-__name(getRequestStore, "getRequestStore");
-function getState() {
-  const state = getRequestStore().getStore();
-  if (!state) {
-    throw new Error(
-      "No Farm i18n request context is active. Use this API while rendering, inside an API route, or use createTranslator(locale)."
-    );
-  }
-  return state;
-}
-__name(getState, "getState");
-function _setDefaultFarmI18nRuntime(runtime) {
-  globalThis[FARM_I18N_DEFAULT_RUNTIME] = runtime;
-}
-__name(_setDefaultFarmI18nRuntime, "_setDefaultFarmI18nRuntime");
-async function _runWithFarmI18nRequest(runtime, request, fn, options = {}) {
-  const resolution = runtime.resolveRequest(request, options);
-  const state = {
-    runtime,
-    resolution,
-    snapshot: runtime.getClientSnapshot(resolution)
-  };
-  return getRequestStore().run(state, () => fn(resolution));
-}
-__name(_runWithFarmI18nRequest, "_runWithFarmI18nRequest");
-async function runWithLocale(locale, fn) {
-  const runtime = getDefaultRuntime();
-  assertLocale(runtime, locale);
-  const resolution = {
-    locale,
-    source: "explicit",
-    pathname: "/",
-    persist: false
-  };
-  const state = {
-    runtime,
-    resolution,
-    snapshot: runtime.getClientSnapshot(resolution)
-  };
-  return getRequestStore().run(state, fn);
-}
-__name(runWithLocale, "runWithLocale");
-function getLocale() {
-  return getState().resolution.locale;
-}
-__name(getLocale, "getLocale");
-function getLocaleSource() {
-  return getState().resolution.source;
-}
-__name(getLocaleSource, "getLocaleSource");
-var t = createTranslatorFromState(() => getState());
-function createTranslator(locale) {
-  const runtime = getDefaultRuntime();
-  assertLocale(runtime, locale);
-  return createTranslatorFromState(() => ({
-    runtime,
-    resolution: {
-      locale,
-      source: "explicit",
-      pathname: "/",
-      persist: false
-    },
-    snapshot: runtime.getClientSnapshot({
-      locale,
-      source: "explicit",
-      pathname: "/",
-      persist: false
-    })
-  }));
-}
-__name(createTranslator, "createTranslator");
-function getFarmI18nClientSnapshot() {
-  return getRequestStore().getStore()?.snapshot;
-}
-__name(getFarmI18nClientSnapshot, "getFarmI18nClientSnapshot");
-var format = {
-  number(value, options) {
-    return new Intl.NumberFormat(getLocale(), options).format(value);
-  },
-  currency(value, currency, options = {}) {
-    return new Intl.NumberFormat(getLocale(), {
-      ...options,
-      style: "currency",
-      currency
-    }).format(value);
-  },
-  date(value, options) {
-    return new Intl.DateTimeFormat(getLocale(), options).format(value);
-  },
-  relativeTime(value, unit, options) {
-    return new Intl.RelativeTimeFormat(getLocale(), options).format(value, unit);
-  },
-  list(values, options) {
-    const ListFormat = Intl.ListFormat;
-    return new ListFormat(getLocale(), options).format(Array.from(values));
-  }
-};
-function getDefaultRuntime() {
-  const runtime = globalThis[FARM_I18N_DEFAULT_RUNTIME];
-  if (!runtime?.config.enabled) {
-    throw new Error("Farm i18n is not configured for this application.");
-  }
-  return runtime;
-}
-__name(getDefaultRuntime, "getDefaultRuntime");
-function assertLocale(runtime, locale) {
-  if (!runtime.config.locales.includes(locale)) {
-    throw new Error(`Unsupported Farm i18n locale "${locale}".`);
-  }
-}
-__name(assertLocale, "assertLocale");
-function createTranslatorFromState(resolveState) {
-  const translator = /* @__PURE__ */ __name(((key, values) => {
-    const state = resolveState();
-    return state.runtime.translate(state.resolution.locale, key, values);
-  }), "translator");
-  translator.rich = (key, values) => {
-    const state = resolveState();
-    return state.runtime.translateRich(state.resolution.locale, key, values);
-  };
-  translator.raw = (key) => {
-    const state = resolveState();
-    return state.runtime.getRawMessage(state.resolution.locale, key);
-  };
-  translator.has = (key) => {
-    const state = resolveState();
-    return state.runtime.hasMessage(state.resolution.locale, key);
-  };
-  return translator;
-}
-__name(createTranslatorFromState, "createTranslatorFromState");
-_setFarmI18nSnapshotResolver(() => getFarmI18nClientSnapshot());
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FarmI18nRuntime,
-  _runWithFarmI18nRequest,
-  _setDefaultFarmI18nRuntime,
-  createFarmI18nRuntime,
-  createTranslator,
-  format,
-  getFarmI18nClientSnapshot,
-  getLocale,
-  getLocaleSource,
-  runWithLocale,
-  t
-});
+var _chunkUJ2C4ICScjs = require('../chunk-UJ2C4ICS.cjs');
+require('../chunk-IQXFRNY2.cjs');
+require('../chunk-HBTUGXHS.cjs');
+require('../chunk-75BRBIFP.cjs');
+require('../chunk-LIUGYUX3.cjs');
+require('../chunk-BIDYX3SL.cjs');
+require('../chunk-I57LW5VZ.cjs');
+require('../chunk-S3JO3N4H.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FarmI18nRuntime = _chunkUJ2C4ICScjs.FarmI18nRuntime; exports._runWithFarmI18nRequest = _chunkUJ2C4ICScjs._runWithFarmI18nRequest; exports._setDefaultFarmI18nRuntime = _chunkUJ2C4ICScjs._setDefaultFarmI18nRuntime; exports.createFarmI18nRuntime = _chunkUJ2C4ICScjs.createFarmI18nRuntime; exports.createTranslator = _chunkUJ2C4ICScjs.createTranslator; exports.format = _chunkUJ2C4ICScjs.format; exports.getFarmI18nClientSnapshot = _chunkUJ2C4ICScjs.getFarmI18nClientSnapshot; exports.getLocale = _chunkUJ2C4ICScjs.getLocale; exports.getLocaleSource = _chunkUJ2C4ICScjs.getLocaleSource; exports.runWithLocale = _chunkUJ2C4ICScjs.runWithLocale; exports.t = _chunkUJ2C4ICScjs.t;