@farm.js/core 0.1.0-beta.0

package/dist/i18n/server.cjs

@@ -0,0 +1,637 @@
+"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);
+
+// 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 (key in output) 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) => !(key in catalog));
+    const extra = localeKeys.filter((key) => !(key in signatures));
+    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/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(pathname);
+  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;
+  if (config.routing === "none") return internalPathname;
+  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
+    return internalPathname;
+  }
+  return internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
+}
+__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 redirect = options.redirect !== false && canonicalPath !== url.pathname ? `${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(url.pathname) && 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();
+  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 candidates = header.split(",").map((entry, index) => {
+    const [locale = "", ...parameters] = entry.trim().split(";");
+    const qualityValue = parameters.map((parameter) => parameter.trim()).find((parameter) => parameter.startsWith("q="));
+    const quality = qualityValue ? Number(qualityValue.slice(2)) : 1;
+    return { locale, quality: Number.isFinite(quality) ? quality : 0, index };
+  }).filter((candidate) => candidate.locale && candidate.locale !== "*" && candidate.quality > 0).sort((a, b) => b.quality - a.quality || a.index - b.index);
+  for (const candidate of candidates) {
+    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.catalogs[locale]?.[key] ?? this.catalogs[this.config.fallbackLocale]?.[key]) !== void 0;
+  }
+  getClientSnapshot(resolution) {
+    return {
+      locale: resolution.locale,
+      source: resolution.source,
+      locales: this.config.locales,
+      defaultLocale: this.config.defaultLocale,
+      routing: this.config.routing,
+      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);
+  }
+  resolveMessage(locale, key) {
+    const message = this.catalogs[locale]?.[key] ?? this.catalogs[this.config.fallbackLocale]?.[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
+});
+//# sourceMappingURL=server.cjs.map