@farm.js/core 0.1.61 → 0.1.63

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-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
+};

package/dist/chunk-N33DLJBC.mjs

@@ -0,0 +1,272 @@
+import {
+  readFarmEnvironmentValue
+} from "./chunk-WXFY5JIY.mjs";
+
+// src/env.ts
+var FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
+var FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
+var farmEnvGlobal = globalThis;
+var currentEnv = getInitialEnv();
+function resolveEnv(config, source = getProcessEnv()) {
+  const resolved = {
+    server: resolveEnvScope(config?.server, source, "server"),
+    public: resolveEnvScope(config?.public, source, "public")
+  };
+  return resolved;
+}
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(env2 ?? {});
+  const server = {};
+  const runtime = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    const raw = source[key];
+    const type = getRuntimeEnvType(value);
+    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
+      runtime[key] = type;
+    } else {
+      server[key] = value;
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime).length > 0 ? { runtime: { server: runtime } } : {}
+  };
+}
+function setEnv(env2) {
+  currentEnv = prepareEnv(env2);
+  if (typeof window === "undefined") {
+    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
+  }
+}
+function getResolvedEnv() {
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
+}
+function getEnv(key) {
+  const server = getEnvScope("server");
+  if (key === void 0) {
+    return server;
+  }
+  return readServerEnvKey(server, key);
+}
+function getPublicEnv(key) {
+  if (key === void 0) {
+    return getCurrentEnv().public;
+  }
+  return getCurrentEnv().public[key];
+}
+var env = createEnvProxy("server");
+var serverEnv = env;
+var publicEnv = createEnvProxy("public");
+function resolveEnvScope(shape, source, scope) {
+  if (!shape) {
+    return {};
+  }
+  const resolved = {};
+  for (const [key, parser] of Object.entries(shape)) {
+    try {
+      resolved[key] = parseEnvValue(parser, source[key], key, scope);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
+    }
+  }
+  return resolved;
+}
+function parseEnvValue(parser, value, key, scope) {
+  if (typeof parser === "function") {
+    return parser(value, { key, scope });
+  }
+  if (parser && typeof parser.parse === "function") {
+    return parser.parse(value);
+  }
+  throw new Error("expected a parser function or schema with parse()");
+}
+function createEnvProxy(scope) {
+  return new Proxy(
+    {},
+    {
+      get(_target, property) {
+        if (typeof property === "symbol") {
+          return void 0;
+        }
+        const env2 = getEnvScope(scope);
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
+      },
+      ownKeys() {
+        return Reflect.ownKeys(getEnvScope(scope));
+      },
+      getOwnPropertyDescriptor(_target, property) {
+        const env2 = getEnvScope(scope);
+        if (!(property in env2)) {
+          return void 0;
+        }
+        return {
+          enumerable: true,
+          configurable: true,
+          value: env2[property]
+        };
+      },
+      has(_target, property) {
+        return property in getEnvScope(scope);
+      }
+    }
+  );
+}
+function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
+  if (scope === "server") {
+    assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
+  }
+  return env2[scope] || {};
+}
+function readServerEnvKey(server, key) {
+  const value = server[key];
+  if (value === void 0) {
+    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
+    if (state && key in state.pending && !state.warned.has(key)) {
+      state.warned.add(key);
+      console.warn(
+        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
+      );
+    }
+  }
+  return value;
+}
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = readFarmEnvironmentValue(key);
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+function getRuntimeEnvType(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
+  return "string";
+}
+function coerceRuntimeEnvValue(raw, type) {
+  if (type === "number") {
+    const value = Number(raw);
+    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
+  }
+  if (type === "boolean") {
+    if (/^(true|1)$/i.test(raw.trim())) return true;
+    if (/^(false|0|)$/i.test(raw.trim())) return false;
+    return raw;
+  }
+  if (type === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+function isSameEnvValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => isSameEnvValue(item, right[index]));
+  }
+  if (!isPlainObject(left) || !isPlainObject(right)) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && isSameEnvValue(left[key], right[key])
+  );
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function prepareEnv(env2) {
+  const normalized = normalizeResolvedEnv(env2);
+  const runtime = env2.runtime?.server;
+  if (!isRecord(runtime) || Object.keys(runtime).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
+}
+function assertServerEnvAccess() {
+  if (typeof window !== "undefined") {
+    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
+  }
+}
+function getInitialEnv() {
+  const injectedEnv = getInjectedEnv();
+  if (injectedEnv) {
+    return injectedEnv;
+  }
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
+  }
+  return {
+    server: {},
+    public: getInjectedPublicEnv()
+  };
+}
+function getCurrentEnv() {
+  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
+    return farmEnvGlobal[FARM_ENV_SYMBOL];
+  }
+  return currentEnv;
+}
+function getInjectedEnv() {
+  try {
+    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
+      return prepareEnv(__FARM_ENV__);
+    }
+  } catch {
+  }
+  return null;
+}
+function getInjectedPublicEnv() {
+  try {
+    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
+      return __FARM_PUBLIC_ENV__;
+    }
+  } catch {
+  }
+  return {};
+}
+function normalizeResolvedEnv(env2) {
+  return {
+    server: isRecord(env2.server) ? env2.server : {},
+    public: isRecord(env2.public) ? env2.public : {}
+  };
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getProcessEnv() {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+}
+
+export {
+  resolveEnv,
+  createBundledEnv,
+  setEnv,
+  getResolvedEnv,
+  getEnv,
+  getPublicEnv,
+  env,
+  serverEnv,
+  publicEnv
+};