@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-CDTIXBKN.mjs

@@ -0,0 +1,40 @@
+import {
+  useRouter
+} from "./chunk-HAH4FBTA.mjs";
+import {
+  getRouter
+} from "./chunk-VCFBQFOV.mjs";
+import {
+  applyFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/navigation.ts
+function useRouter2() {
+  const router = useRouter();
+  return {
+    push: router.push,
+    replace: router.replace,
+    back: router.back,
+    forward: router.forward,
+    refresh() {
+      if (typeof window === "undefined") return Promise.resolve();
+      return getRouter().refresh();
+    },
+    prefetch(href) {
+      if (typeof window === "undefined") return Promise.resolve();
+      return getRouter().prefetch(applyFarmBasePath(href));
+    }
+  };
+}
+function usePathname() {
+  return useRouter().pathname;
+}
+function useSearchParams() {
+  return useRouter().searchParams;
+}
+
+export {
+  useRouter2 as useRouter,
+  usePathname,
+  useSearchParams
+};

package/dist/chunk-CL2ONP73.cjs

@@ -0,0 +1,180 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkA25FXJ7Dcjs = require('./chunk-A25FXJ7D.cjs');
+
+// src/plugins/compression.ts
+var _stream = require('stream');
+var _zlib = require('zlib');
+var Q_VALUE = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/;
+function parseEncodingQuality(header) {
+  const qualities = /* @__PURE__ */ new Map();
+  for (const item of header.split(",")) {
+    const [rawEncoding, ...parameters] = item.trim().split(";");
+    const encoding = _optionalChain([rawEncoding, 'optionalAccess', _ => _.trim, 'call', _2 => _2(), 'access', _3 => _3.toLowerCase, 'call', _4 => _4()]);
+    if (!encoding) continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [rawName, rawValue] = parameter.split("=", 2);
+      if (_optionalChain([rawName, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6(), 'access', _7 => _7.toLowerCase, 'call', _8 => _8()]) !== "q") continue;
+      const value = _nullishCoalesce(_optionalChain([rawValue, 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]), () => ( ""));
+      quality = Q_VALUE.test(value) ? Number(value) : 0;
+    }
+    qualities.set(encoding, Math.max(_nullishCoalesce(qualities.get(encoding), () => ( 0)), quality));
+  }
+  return qualities;
+}
+function selectEncoding(header) {
+  if (!header.trim()) return void 0;
+  const qualities = parseEncodingQuality(header);
+  const wildcard = _nullishCoalesce(qualities.get("*"), () => ( 0));
+  const quality = (encoding) => _nullishCoalesce(qualities.get(encoding), () => ( wildcard));
+  const brotli = quality("br");
+  const gzip2 = quality("gzip");
+  if (brotli <= 0 && gzip2 <= 0) return void 0;
+  return brotli >= gzip2 ? "br" : "gzip";
+}
+var COMPRESSIBLE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "application/javascript",
+  "application/json",
+  "application/ndjson",
+  "application/wasm",
+  "application/x-ndjson",
+  "application/xml",
+  // Font formats that store raw glyph tables. `font/woff` and `font/woff2` are
+  // deliberately absent: their payloads are already deflate and brotli streams.
+  "application/vnd.ms-fontobject",
+  "font/otf",
+  "font/ttf"
+]);
+var COMPRESSIBLE_MEDIA_TYPE_SUFFIXES = ["+json", "+xml"];
+function isCompressibleMediaType(mediaType) {
+  if (!mediaType) return false;
+  if (mediaType === "text/event-stream") return false;
+  if (mediaType.startsWith("text/")) return true;
+  if (COMPRESSIBLE_MEDIA_TYPES.has(mediaType)) return true;
+  return COMPRESSIBLE_MEDIA_TYPE_SUFFIXES.some((suffix) => mediaType.endsWith(suffix));
+}
+function isCompressionEligible(request, response, bufferedText) {
+  if (
+    // Known buffered text proves a body without reading response.body, which
+    // would create a lazy response's Web stream.
+    request.method !== "HEAD" && bufferedText === void 0 && !response.body || response.status === 204 || response.status === 205 || response.status === 304 || response.headers.has("content-encoding") || response.headers.has("content-range") || _optionalChain([response, 'access', _11 => _11.headers, 'access', _12 => _12.get, 'call', _13 => _13("cache-control"), 'optionalAccess', _14 => _14.toLowerCase, 'call', _15 => _15(), 'access', _16 => _16.includes, 'call', _17 => _17("no-transform")])
+  ) {
+    return false;
+  }
+  const mediaType = _optionalChain([response, 'access', _18 => _18.headers, 'access', _19 => _19.get, 'call', _20 => _20("content-type"), 'optionalAccess', _21 => _21.split, 'call', _22 => _22(";", 1), 'access', _23 => _23[0], 'optionalAccess', _24 => _24.trim, 'call', _25 => _25(), 'access', _26 => _26.toLowerCase, 'call', _27 => _27()]);
+  return isCompressibleMediaType(mediaType);
+}
+function appendVary(headers, value) {
+  const current = headers.get("vary");
+  const values = current ? current.split(",").map((item) => item.trim()).filter(Boolean) : [];
+  if (values.includes("*")) return;
+  if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
+    values.push(value);
+  }
+  headers.set("vary", values.join(", "));
+}
+var BROTLI_QUALITY = 5;
+function compressedHeaders(response, encoding) {
+  const headers = new Headers(response.headers);
+  headers.set("content-encoding", encoding);
+  headers.delete("content-length");
+  appendVary(headers, "Accept-Encoding");
+  const etag = headers.get("etag");
+  if (etag && !etag.startsWith("W/")) {
+    headers.set("etag", `W/${etag}`);
+  }
+  return headers;
+}
+function compressBufferedResponse(response, text, encoding, lazyBody) {
+  const headers = compressedHeaders(response, encoding);
+  if (!lazyBody) _optionalChain([response, 'access', _28 => _28.body, 'optionalAccess', _29 => _29.cancel, 'call', _30 => _30(), 'access', _31 => _31.catch, 'call', _32 => _32(() => {
+  })]);
+  const input = Buffer.from(text);
+  let cancelled = false;
+  const body = new ReadableStream({
+    start(controller) {
+      const done = (error, output) => {
+        if (cancelled) return;
+        if (error) {
+          controller.error(error);
+          return;
+        }
+        controller.enqueue(new Uint8Array(output.buffer, output.byteOffset, output.byteLength));
+        controller.close();
+      };
+      if (encoding === "br") {
+        _zlib.brotliCompress.call(void 0, 
+          input,
+          { params: { [_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY } },
+          done
+        );
+      } else {
+        _zlib.gzip.call(void 0, input, done);
+      }
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function compressResponse(response, encoding) {
+  const compressor = encoding === "br" ? _zlib.createBrotliCompress.call(void 0, {
+    flush: _zlib.constants.BROTLI_OPERATION_FLUSH,
+    params: { [_zlib.constants.BROTLI_PARAM_QUALITY]: BROTLI_QUALITY }
+  }) : _zlib.createGzip.call(void 0, { flush: _zlib.constants.Z_SYNC_FLUSH });
+  const input = _stream.Readable.fromWeb(response.body);
+  const output = _stream.pipeline.call(void 0, input, compressor, () => {
+  });
+  const headers = compressedHeaders(response, encoding);
+  return new Response(_stream.Readable.toWeb(output), {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function varyIdentityResponse(response) {
+  return _chunkA25FXJ7Dcjs._withFarmResponseHeaders.call(void 0, response, (headers) => appendVary(headers, "Accept-Encoding"));
+}
+function compressFarmResponse(request, response, bufferedText, lazyBody = false) {
+  if (!isCompressionEligible(request, response, bufferedText)) return response;
+  if (request.method === "HEAD") return varyIdentityResponse(response);
+  const encoding = selectEncoding(_nullishCoalesce(request.headers.get("accept-encoding"), () => ( "")));
+  if (!encoding) return varyIdentityResponse(response);
+  return bufferedText === void 0 ? compressResponse(response, encoding) : compressBufferedResponse(response, bufferedText, encoding, lazyBody);
+}
+function createCompressionPlugin({
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse
+} = {}) {
+  return {
+    name: "farm:compression",
+    enforce: "post",
+    runtime: {
+      after({ request, response, isProd }) {
+        if (!isProd) return;
+        return compressFarmResponse(request, response);
+      }
+    },
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+
+
+
+exports.compressFarmResponse = compressFarmResponse; exports.createCompressionPlugin = createCompressionPlugin;

package/dist/chunk-CQL5ZGFU.cjs

@@ -0,0 +1,50 @@
+"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/client/island-value-protocol.ts
+var FARM_ISLAND_ELEMENT = "f-island";
+var FARM_PROPS_SCRIPT_TYPE = "f/props";
+var FARM_VALUE_SCRIPT_TYPE = "f/value";
+var FARM_SLOT_ELEMENT = "f-slot";
+var FARM_TAG = "$";
+var FARM_TAG_VALUE = "v";
+var FARM_REFERENCE_TAG = "r";
+var FARM_SLOT_TAG = "s";
+var FARM_ACTION_TAG = "a";
+var FARM_OBJECT_TAG = "o";
+var FARM_VALUES_HEADER = "F-Values";
+function getFarmTag(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const tag = value[FARM_TAG];
+  if (typeof tag !== "string") return void 0;
+  const keys = Object.keys(value);
+  return keys.length === 1 || keys.length === 2 && FARM_TAG_VALUE in value ? tag : void 0;
+}
+var FARM_VALUE_KEY_PATTERN = /^[0-9a-z]{14}$/;
+var FARM_MAX_HELD_VALUES = 128;
+var FARM_ISLAND_VALUE_STORE_KEY = /* @__PURE__ */ Symbol.for("islx.values");
+var ISLAND_VALUES_SERVER_KEY = /* @__PURE__ */ Symbol.for("farm.island-values.server");
+function getFarmIslandValuesServer() {
+  return globalThis[ISLAND_VALUES_SERVER_KEY];
+}
+function getFarmIslandValueHeaders() {
+  const scope = globalThis;
+  const held = _optionalChain([scope, 'access', _ => _[FARM_ISLAND_VALUE_STORE_KEY], 'optionalAccess', _2 => _2.heldHeader, 'call', _3 => _3()]);
+  return held ? { [FARM_VALUES_HEADER]: held } : {};
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_ISLAND_ELEMENT = FARM_ISLAND_ELEMENT; exports.FARM_PROPS_SCRIPT_TYPE = FARM_PROPS_SCRIPT_TYPE; exports.FARM_VALUE_SCRIPT_TYPE = FARM_VALUE_SCRIPT_TYPE; exports.FARM_SLOT_ELEMENT = FARM_SLOT_ELEMENT; exports.FARM_TAG = FARM_TAG; exports.FARM_TAG_VALUE = FARM_TAG_VALUE; exports.FARM_REFERENCE_TAG = FARM_REFERENCE_TAG; exports.FARM_SLOT_TAG = FARM_SLOT_TAG; exports.FARM_ACTION_TAG = FARM_ACTION_TAG; exports.FARM_OBJECT_TAG = FARM_OBJECT_TAG; exports.FARM_VALUES_HEADER = FARM_VALUES_HEADER; exports.getFarmTag = getFarmTag; exports.FARM_VALUE_KEY_PATTERN = FARM_VALUE_KEY_PATTERN; exports.FARM_MAX_HELD_VALUES = FARM_MAX_HELD_VALUES; exports.getFarmIslandValuesServer = getFarmIslandValuesServer; exports.getFarmIslandValueHeaders = getFarmIslandValueHeaders;

package/dist/chunk-CSLUBKGG.mjs

@@ -0,0 +1,44 @@
+// src/deployment-environment.ts
+function isFarmProductionDeploymentEnvironment(env = process.env) {
+  const environment = normalizeEnvironment(env.VERCEL_ENV);
+  const targetEnvironment = normalizeEnvironment(env.VERCEL_TARGET_ENV);
+  if (environment && environment !== "production") return false;
+  if (targetEnvironment && targetEnvironment !== "production") return false;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context && context !== "production") return false;
+  }
+  if (isTrue(env.IS_PULL_REQUEST)) return false;
+  return true;
+}
+function isFarmPreviewDeploymentEnvironment(env) {
+  return resolveFarmPreviewDeployment(env, false);
+}
+function resolveFarmPreviewDeployment(env, builtAsPreview) {
+  const explicit = env?.FARM_PREVIEW;
+  if (isTrue(explicit)) return true;
+  if (isFalse(explicit)) return false;
+  if (builtAsPreview || !env) return builtAsPreview;
+  if (normalizeEnvironment(env.VERCEL_ENV) === "preview") return true;
+  if (isTrue(env.NETLIFY)) {
+    const context = normalizeEnvironment(env.CONTEXT);
+    if (context === "deploy-preview" || context === "branch-deploy") return true;
+  }
+  return isTrue(env.IS_PULL_REQUEST);
+}
+function normalizeEnvironment(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized || void 0;
+}
+function isTrue(value) {
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function isFalse(value) {
+  return value !== void 0 && ["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+
+export {
+  isFarmProductionDeploymentEnvironment,
+  isFarmPreviewDeploymentEnvironment,
+  resolveFarmPreviewDeployment
+};

package/dist/chunk-CU5SYTJG.mjs

@@ -0,0 +1,23 @@
+// src/devtools-config.ts
+var DEFAULT_FARM_DEVTOOLS_SHORTCUT = "mod+shift+.";
+var FARM_DEVTOOLS_PATH = "/__farm/devtools";
+var FARM_DEVTOOLS_LAUNCH_PARAM = "__farm_devtools";
+function resolveFarmDevtoolsConfig(config, mode = "development") {
+  if (mode !== "development" || config === false) {
+    return { enabled: false, shortcut: false };
+  }
+  const options = config === true || config === void 0 ? {} : config;
+  const enabled = options.enabled ?? true;
+  if (!enabled) {
+    return { enabled: false, shortcut: false };
+  }
+  const shortcut = typeof options.shortcut === "string" && options.shortcut.trim() ? options.shortcut.toLowerCase().split("+").map((part) => part.trim()).filter(Boolean).join("+") : options.shortcut === false ? false : DEFAULT_FARM_DEVTOOLS_SHORTCUT;
+  return { enabled: true, shortcut };
+}
+
+export {
+  DEFAULT_FARM_DEVTOOLS_SHORTCUT,
+  FARM_DEVTOOLS_PATH,
+  FARM_DEVTOOLS_LAUNCH_PARAM,
+  resolveFarmDevtoolsConfig
+};

package/dist/chunk-CV6MFQ4Y.mjs

@@ -0,0 +1,259 @@
+import {
+  readFarmI18nCatalogs
+} from "./chunk-DU4VHHPJ.mjs";
+import {
+  resolveFarmLocaleRequest
+} from "./chunk-K76CBYQM.mjs";
+import {
+  _setFarmI18nSnapshotResolver
+} from "./chunk-M25IONJP.mjs";
+import {
+  getFarmLocaleDirection
+} from "./chunk-7S7AAK2D.mjs";
+
+// src/i18n/server.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/i18n/runtime.ts
+import IntlMessageFormat from "intl-messageformat";
+var FarmI18nRuntime = class {
+  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 IntlMessageFormat(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;
+  }
+};
+function createFarmI18nRuntime(config, catalogs) {
+  return new FarmI18nRuntime(config, catalogs);
+}
+
+// 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 AsyncLocalStorage());
+}
+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;
+}
+function _setDefaultFarmI18nRuntime(runtime) {
+  globalThis[FARM_I18N_DEFAULT_RUNTIME] = runtime;
+}
+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));
+}
+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);
+}
+function getLocale() {
+  return getState().resolution.locale;
+}
+function getLocaleSource() {
+  return getState().resolution.source;
+}
+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
+    })
+  }));
+}
+function getFarmI18nClientSnapshot() {
+  return getRequestStore().getStore()?.snapshot;
+}
+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;
+}
+function assertLocale(runtime, locale) {
+  if (!runtime.config.locales.includes(locale)) {
+    throw new Error(`Unsupported Farm i18n locale "${locale}".`);
+  }
+}
+function createTranslatorFromState(resolveState) {
+  const translator = ((key, values) => {
+    const state = resolveState();
+    return state.runtime.translate(state.resolution.locale, key, values);
+  });
+  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;
+}
+_setFarmI18nSnapshotResolver(() => getFarmI18nClientSnapshot());
+
+export {
+  FarmI18nRuntime,
+  createFarmI18nRuntime,
+  _setDefaultFarmI18nRuntime,
+  _runWithFarmI18nRequest,
+  runWithLocale,
+  getLocale,
+  getLocaleSource,
+  t,
+  createTranslator,
+  getFarmI18nClientSnapshot,
+  format
+};

package/dist/chunk-D22BUQKW.cjs

@@ -0,0 +1,82 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/base-path.ts
+var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
+function getFarmGlobalState() {
+  return globalThis;
+}
+function setFarmBasePath(basePath) {
+  getFarmGlobalState()[FARM_BASE_PATH] = normalizeFarmBasePath(basePath);
+}
+function getFarmBasePath() {
+  return _nullishCoalesce(getFarmGlobalState()[FARM_BASE_PATH], () => ( ""));
+}
+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}`;
+}
+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}`;
+}
+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) || "/";
+}
+function normalizeFarmBasePath(basePath) {
+  if (!basePath || basePath === "/") return "";
+  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+  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 (e) {
+    }
+    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(/\/+$/, "");
+}
+function normalizeFarmConfigBasePath(basePath) {
+  return normalizeFarmBasePath(basePath) || "/";
+}
+
+
+
+
+
+
+
+
+exports.setFarmBasePath = setFarmBasePath; exports.getFarmBasePath = getFarmBasePath; exports.applyFarmBasePath = applyFarmBasePath; exports.stripFarmBasePath = stripFarmBasePath; exports.normalizeFarmBasePath = normalizeFarmBasePath; exports.normalizeFarmConfigBasePath = normalizeFarmConfigBasePath;