@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-E5GNDG5F.mjs

@@ -0,0 +1,701 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/programmatic-routes-client.ts
+import { builtinModules } from "module";
+var ROUTE_IMPORT_SOURCES = /* @__PURE__ */ new Set(["@farm.js/core", "@farm.js/core/routes"]);
+var ROUTE_FACTORY_NAMES = {
+  createRoute: "page",
+  page: "page",
+  layout: "layout",
+  api: "api"
+};
+var SERVER_ONLY_KEYS = {
+  page: /* @__PURE__ */ new Set(["guard", "data", "staticPaths", "generateMetadata"]),
+  layout: /* @__PURE__ */ new Set(["generateMetadata"]),
+  api: /* @__PURE__ */ new Set(["GET", "HEAD", "QUERY", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
+};
+var MODULE_EXTENSION_RE = /\.[cm]?[jt]sx?$/;
+var NODE_BUILTINS = new Set(builtinModules);
+function transformProgrammaticRoutesForClient(options) {
+  if (!isTransformableModule(options.id) || !options.code.includes("@farm.js/core")) return null;
+  const ast = options.parse(options.code);
+  const bindings = findRouteFactoryBindings(ast);
+  if (!bindings) return null;
+  const calls = findRouteFactoryCalls(ast, bindings);
+  if (calls.length === 0 && !bindings.definesRoutes) return null;
+  const replacements = calls.flatMap((call) => {
+    const replacement = stripRouteOptions(options.code, call.kind, call.options);
+    return replacement ? [replacement] : [];
+  });
+  let code = applyReplacements(options.code, withoutNested(replacements));
+  if (replacements.length > 0) {
+    code = applyReplacements(code, removeUnusedTopLevel(code, options.parse(code)));
+  }
+  const builtin = findNodeBuiltinImport(options.parse(code));
+  if (builtin) {
+    throw new Error(
+      `[Farm.js] ${options.id} defines programmatic routes and is loaded in the browser to hydrate them, but it still imports the server-only module "${builtin}" after Farm removed the server route hooks (guard, data, staticPaths, generateMetadata, and API handlers). Use it only inside those hooks, or move it into a module that only they import.`
+    );
+  }
+  return { code, definesRoutes: true };
+}
+__name(transformProgrammaticRoutesForClient, "transformProgrammaticRoutesForClient");
+function findClientNodeBuiltinChain(entry, getImportedIds) {
+  const parents = /* @__PURE__ */ new Map([[entry, null]]);
+  const queue = [entry];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    for (const imported of getImportedIds(id) ?? []) {
+      if (isNodeBuiltinId(imported)) {
+        const chain = [imported];
+        for (let cursor = id; cursor; cursor = parents.get(cursor) ?? null) {
+          chain.unshift(cursor);
+        }
+        return chain;
+      }
+      if (parents.has(imported) || !isApplicationModuleId(imported)) continue;
+      parents.set(imported, id);
+      queue.push(imported);
+    }
+  }
+  return null;
+}
+__name(findClientNodeBuiltinChain, "findClientNodeBuiltinChain");
+function isTransformableModule(id) {
+  if (id.startsWith("\0") || id.includes("/node_modules/") || id.includes("\\node_modules\\")) {
+    return false;
+  }
+  return MODULE_EXTENSION_RE.test(id.split("?", 1)[0]);
+}
+__name(isTransformableModule, "isTransformableModule");
+function isApplicationModuleId(id) {
+  return !id.startsWith("\0") && isTransformableModule(id);
+}
+__name(isApplicationModuleId, "isApplicationModuleId");
+function isNodeBuiltinId(id) {
+  const external = id.indexOf("__vite-browser-external:");
+  const bare = external === 0 || external === 1 ? id.slice(external + 24) : id;
+  return bare.startsWith("node:") || NODE_BUILTINS.has(bare);
+}
+__name(isNodeBuiltinId, "isNodeBuiltinId");
+function findRouteFactoryBindings(ast) {
+  const factories = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  const defineRoutesNames = /* @__PURE__ */ new Set();
+  let definesRoutes = false;
+  for (const statement of asNodes(ast.body)) {
+    if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+    const source = isAstNode(statement.source) ? statement.source.value : void 0;
+    if (typeof source !== "string" || !ROUTE_IMPORT_SOURCES.has(source)) continue;
+    for (const specifier of asNodes(statement.specifiers)) {
+      const local = isAstNode(specifier.local) ? specifier.local.name : void 0;
+      if (typeof local !== "string") continue;
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        namespaces.add(local);
+      } else if (specifier.type === "ImportSpecifier" && isAstNode(specifier.imported)) {
+        const imported = String(specifier.imported.name ?? specifier.imported.value);
+        if (imported === "defineRoutes") defineRoutesNames.add(local);
+        const kind = ROUTE_FACTORY_NAMES[imported];
+        if (kind) factories.set(local, kind);
+      }
+    }
+  }
+  if (factories.size === 0 && namespaces.size === 0 && defineRoutesNames.size === 0) return null;
+  walk(ast, (node) => {
+    if (node.type !== "CallExpression" || !isAstNode(node.callee)) return;
+    const callee = node.callee;
+    const isDefineRoutes = callee.type === "Identifier" && defineRoutesNames.has(String(callee.name)) || callee.type === "MemberExpression" && callee.computed !== true && isAstNode(callee.object) && namespaces.has(String(callee.object.name)) && isAstNode(callee.property) && callee.property.name === "defineRoutes";
+    if (!isDefineRoutes) return;
+    definesRoutes = true;
+    const callback = asNodes(node.arguments)[0];
+    if (!callback || !isFunctionNode(callback)) return;
+    const builder = asNodes(callback.params)[0];
+    if (!builder) return;
+    if (builder.type === "Identifier") {
+      namespaces.add(String(builder.name));
+    } else if (builder.type === "ObjectPattern") {
+      for (const property of asNodes(builder.properties)) {
+        if (property.type !== "Property" || property.computed === true) continue;
+        const key = readPropertyName(property.key);
+        const value = isAstNode(property.value) ? property.value : void 0;
+        const kind = key ? ROUTE_FACTORY_NAMES[key] : void 0;
+        if (kind && key !== "createRoute" && value?.type === "Identifier") {
+          factories.set(String(value.name), kind);
+        }
+      }
+    }
+  });
+  return { factories, namespaces, definesRoutes };
+}
+__name(findRouteFactoryBindings, "findRouteFactoryBindings");
+function findRouteFactoryCalls(ast, bindings) {
+  const calls = [];
+  walk(ast, (node) => {
+    if (node.type !== "CallExpression" || !isAstNode(node.callee)) return;
+    const callee = node.callee;
+    let kind;
+    if (callee.type === "Identifier") {
+      kind = bindings.factories.get(String(callee.name));
+    } else if (callee.type === "MemberExpression" && callee.computed !== true && isAstNode(callee.object) && callee.object.type === "Identifier" && bindings.namespaces.has(String(callee.object.name)) && isAstNode(callee.property)) {
+      kind = ROUTE_FACTORY_NAMES[String(callee.property.name)];
+    }
+    const options = asNodes(node.arguments)[1];
+    if (kind && options?.type === "ObjectExpression") calls.push({ kind, options });
+  });
+  return calls;
+}
+__name(findRouteFactoryCalls, "findRouteFactoryCalls");
+function stripRouteOptions(code, kind, options) {
+  const serverOnlyKeys = SERVER_ONLY_KEYS[kind];
+  const kept = [];
+  const removed = [];
+  for (const property of asNodes(options.properties)) {
+    const key = property.type === "Property" && property.computed !== true ? readPropertyName(property.key) : void 0;
+    if (key && serverOnlyKeys.has(kind === "api" ? key.toUpperCase() : key)) {
+      removed.push(key);
+    } else {
+      kept.push(code.slice(property.start, property.end));
+    }
+  }
+  if (removed.length === 0) return null;
+  const propHooks = removed.filter((key) => key === "guard" || key === "data");
+  if (kind === "page" && propHooks.length > 0) {
+    kept.push(`__farmServerHooks: ${JSON.stringify(propHooks)}`);
+  }
+  return { start: options.start, end: options.end, code: `{ ${kept.join(", ")} }` };
+}
+__name(stripRouteOptions, "stripRouteOptions");
+function removeUnusedTopLevel(code, ast) {
+  const statements = asNodes(ast.body).map((node) => {
+    if (node.type === "ImportDeclaration") {
+      const declared = asNodes(node.specifiers).flatMap(
+        (specifier) => isAstNode(specifier.local) ? [String(specifier.local.name)] : []
+      );
+      return { node, declared, references: /* @__PURE__ */ new Set(), root: declared.length === 0 };
+    }
+    if (node.type === "VariableDeclaration") {
+      const declared = asNodes(node.declarations).flatMap((item) => patternNames(item.id));
+      const references2 = /* @__PURE__ */ new Set();
+      for (const item of asNodes(node.declarations)) collectReferences(item.init, references2);
+      return { node, declared, references: references2, root: false };
+    }
+    if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && isAstNode(node.id)) {
+      const references2 = /* @__PURE__ */ new Set();
+      collectReferences({ ...node, id: null }, references2);
+      return { node, declared: [String(node.id.name)], references: references2, root: false };
+    }
+    const references = /* @__PURE__ */ new Set();
+    collectReferences(node, references);
+    return { node, declared: [], references, root: true };
+  });
+  const declaredBy = /* @__PURE__ */ new Map();
+  for (const statement of statements) {
+    for (const name of statement.declared) declaredBy.set(name, statement);
+  }
+  const live = /* @__PURE__ */ new Set();
+  const queue = statements.filter((statement) => statement.root).flatMap((s) => [...s.references]);
+  while (queue.length > 0) {
+    const name = queue.pop();
+    if (live.has(name)) continue;
+    live.add(name);
+    const statement = declaredBy.get(name);
+    if (statement) queue.push(...statement.references);
+  }
+  const replacements = [];
+  for (const statement of statements) {
+    if (statement.root || statement.declared.some((name) => live.has(name))) {
+      if (statement.node.type === "ImportDeclaration") {
+        const rewritten = rewriteImport(code, statement.node, live);
+        if (rewritten) replacements.push(rewritten);
+      }
+      continue;
+    }
+    replacements.push({ start: statement.node.start, end: statement.node.end, code: "" });
+  }
+  return replacements;
+}
+__name(removeUnusedTopLevel, "removeUnusedTopLevel");
+function rewriteImport(code, node, live) {
+  const specifiers = asNodes(node.specifiers);
+  const kept = specifiers.filter(
+    (specifier) => isAstNode(specifier.local) && live.has(String(specifier.local.name))
+  );
+  if (kept.length === specifiers.length) return null;
+  const defaults = kept.filter((specifier) => specifier.type !== "ImportSpecifier");
+  const named = kept.filter((specifier) => specifier.type === "ImportSpecifier");
+  const clauses = defaults.map((specifier) => code.slice(specifier.start, specifier.end));
+  if (named.length > 0) {
+    clauses.push(`{ ${named.map((item) => code.slice(item.start, item.end)).join(", ")} }`);
+  }
+  const source = code.slice(node.source.start, node.source.end);
+  return { start: node.start, end: node.end, code: `import ${clauses.join(", ")} from ${source};` };
+}
+__name(rewriteImport, "rewriteImport");
+function findNodeBuiltinImport(ast) {
+  let found = null;
+  walk(ast, (node) => {
+    if (found) return;
+    if (node.type !== "ImportDeclaration" && node.type !== "ImportExpression" && node.type !== "ExportAllDeclaration" && node.type !== "ExportNamedDeclaration") {
+      return;
+    }
+    const source = isAstNode(node.source) ? node.source.value : void 0;
+    if (typeof source === "string" && isNodeBuiltinId(source)) found = source;
+  });
+  return found;
+}
+__name(findNodeBuiltinImport, "findNodeBuiltinImport");
+function collectReferences(node, names) {
+  if (Array.isArray(node)) {
+    for (const item of node) collectReferences(item, names);
+    return;
+  }
+  if (!isAstNode(node)) return;
+  if (node.type === "Identifier") {
+    names.add(String(node.name));
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    if (key === "key" && node.computed !== true && (node.type === "Property" || node.type === "MethodDefinition" || node.type === "PropertyDefinition")) {
+      continue;
+    }
+    if (key === "property" && node.type === "MemberExpression" && node.computed !== true) continue;
+    if (key === "label") continue;
+    collectReferences(value, names);
+  }
+}
+__name(collectReferences, "collectReferences");
+function patternNames(pattern) {
+  if (!isAstNode(pattern)) return [];
+  if (pattern.type === "Identifier") return [String(pattern.name)];
+  if (pattern.type === "ObjectPattern") {
+    return asNodes(pattern.properties).flatMap(
+      (property) => patternNames(property.type === "RestElement" ? property.argument : property.value)
+    );
+  }
+  if (pattern.type === "ArrayPattern") return asNodes(pattern.elements).flatMap(patternNames);
+  if (pattern.type === "AssignmentPattern") return patternNames(pattern.left);
+  if (pattern.type === "RestElement") return patternNames(pattern.argument);
+  return [];
+}
+__name(patternNames, "patternNames");
+function withoutNested(replacements) {
+  return replacements.filter(
+    (replacement) => !replacements.some(
+      (other) => other !== replacement && other.start <= replacement.start && other.end >= replacement.end
+    )
+  );
+}
+__name(withoutNested, "withoutNested");
+function applyReplacements(code, replacements) {
+  let output = code;
+  for (const replacement of [...replacements].sort((left, right) => right.start - left.start)) {
+    output = output.slice(0, replacement.start) + replacement.code + output.slice(replacement.end);
+  }
+  return output;
+}
+__name(applyReplacements, "applyReplacements");
+function readPropertyName(node) {
+  if (!isAstNode(node)) return void 0;
+  if (node.type === "Identifier") return String(node.name);
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  return void 0;
+}
+__name(readPropertyName, "readPropertyName");
+function isFunctionNode(node) {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+__name(isFunctionNode, "isFunctionNode");
+function walk(node, visit) {
+  visit(node);
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    if (isAstNode(value)) walk(value, visit);
+    else if (Array.isArray(value)) {
+      for (const item of value) if (isAstNode(item)) walk(item, visit);
+    }
+  }
+}
+__name(walk, "walk");
+function asNodes(value) {
+  return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+__name(asNodes, "asNodes");
+function isAstNode(value) {
+  return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.start === "number";
+}
+__name(isAstNode, "isAstNode");
+
+// src/environment-vite.ts
+var ENVIRONMENT_IMPORTS = /* @__PURE__ */ new Set([
+  "@farm.js/core",
+  "@farm.js/core/environment",
+  "@farm.js/core/server"
+]);
+var ENVIRONMENT_FUNCTIONS = /* @__PURE__ */ new Set([
+  "createServerOnlyFn",
+  "createClientOnlyFn",
+  "createIsomorphicFn"
+]);
+var MODULE_EXTENSION_RE2 = /\.[cm]?[jt]sx?$/;
+function transformEnvironmentFunctions(options) {
+  if (!isTransformableModule2(options.id) || !containsEnvironmentFunction(options.code)) {
+    return null;
+  }
+  let output = options.code;
+  let transformed = false;
+  for (let pass = 0; pass < 20; pass++) {
+    const ast = options.parse(output);
+    const bindings = findEnvironmentFunctionBindings(ast);
+    if (bindings.named.size === 0 && bindings.namespaces.size === 0) break;
+    const calls = findEnvironmentCalls(ast, bindings);
+    if (calls.length === 0) break;
+    const innermostCalls = calls.filter(
+      (call) => !calls.some(
+        (candidate) => candidate !== call && candidate.node.start > call.node.start && candidate.node.end < call.node.end
+      )
+    );
+    const replacements = innermostCalls.map(
+      (call) => createReplacement(output, options.id, options.environment, call)
+    );
+    output = applyReplacements2(output, replacements);
+    transformed = true;
+  }
+  if (!transformed) return null;
+  const remainingAst = options.parse(output);
+  const remainingBindings = findEnvironmentFunctionBindings(remainingAst);
+  if (findEnvironmentCalls(remainingAst, remainingBindings).length > 0) {
+    throw transformError(options.id, "environment functions are nested too deeply");
+  }
+  return { code: output };
+}
+__name(transformEnvironmentFunctions, "transformEnvironmentFunctions");
+function farmEnvironmentFunctionsPlugin() {
+  const clientRouteModules = /* @__PURE__ */ new Set();
+  return {
+    name: "farm:environment-functions",
+    enforce: "post",
+    transform(code, id, transformOptions) {
+      const environment = resolveBuildEnvironment(
+        this,
+        transformOptions?.ssr
+      );
+      const parse = /* @__PURE__ */ __name((source) => this.parse(source), "parse");
+      const result = transformEnvironmentFunctions({ code, id, environment, parse });
+      if (environment !== "client") {
+        return result ? { code: result.code, map: null } : null;
+      }
+      let routes;
+      try {
+        routes = transformProgrammaticRoutesForClient({ code: result?.code ?? code, id, parse });
+      } catch (error) {
+        this.error(error instanceof Error ? error.message : String(error));
+      }
+      if (routes) clientRouteModules.add(id);
+      const output = routes?.code ?? result?.code;
+      return output !== void 0 ? { code: output, map: null } : null;
+    },
+    generateBundle() {
+      const context = this;
+      if (resolveBuildEnvironment(context, false) !== "client") return;
+      for (const id of clientRouteModules) {
+        const chain = findClientNodeBuiltinChain(id, (moduleId) => {
+          const info = this.getModuleInfo(moduleId);
+          return info?.importedIds;
+        });
+        if (chain) {
+          this.error(
+            `[Farm.js] The browser bundle reaches the server-only module "${chain.at(-1)}" through the programmatic routes in ${id}: ${chain.join(" -> ")}. Import it only from guard, data, staticPaths, generateMetadata, or API handlers, which Farm keeps out of the browser.`
+          );
+        }
+      }
+    }
+  };
+}
+__name(farmEnvironmentFunctionsPlugin, "farmEnvironmentFunctionsPlugin");
+function resolveBuildEnvironment(context, ssr) {
+  if (context.environment?.name === "client") return "client";
+  if (context.environment?.name === "rsc" || context.environment?.name === "ssr") {
+    return "server";
+  }
+  return ssr ? "server" : "client";
+}
+__name(resolveBuildEnvironment, "resolveBuildEnvironment");
+function findEnvironmentFunctionBindings(ast) {
+  const named = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  const body = Array.isArray(ast.body) ? ast.body : [];
+  for (const statement of body) {
+    if (!isAstNode2(statement) || statement.type !== "ImportDeclaration") continue;
+    const source = isAstNode2(statement.source) ? statement.source.value : void 0;
+    if (typeof source !== "string" || !ENVIRONMENT_IMPORTS.has(source)) continue;
+    const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers : [];
+    for (const specifier of specifiers) {
+      if (!isAstNode2(specifier) || !isAstNode2(specifier.local)) continue;
+      const localName = specifier.local.name;
+      if (typeof localName !== "string") continue;
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        namespaces.add(localName);
+        continue;
+      }
+      if (specifier.type !== "ImportSpecifier" || !isAstNode2(specifier.imported)) continue;
+      const importedName = specifier.imported.name ?? specifier.imported.value;
+      if (isEnvironmentFunctionKind(importedName)) {
+        named.set(localName, importedName);
+      }
+    }
+  }
+  return { named, namespaces };
+}
+__name(findEnvironmentFunctionBindings, "findEnvironmentFunctionBindings");
+function findEnvironmentCalls(ast, bindings) {
+  const calls = [];
+  walkAst(ast, (node, ancestors) => {
+    if (node.type !== "CallExpression" || !isAstNode2(node.callee)) return;
+    if (node.callee.type === "Identifier" && typeof node.callee.name === "string") {
+      const kind = bindings.named.get(node.callee.name);
+      if (kind && !isNameShadowed(node.callee.name, ancestors)) calls.push({ node, kind });
+      return;
+    }
+    if (node.callee.type !== "MemberExpression" || node.callee.computed === true || !isAstNode2(node.callee.object) || !isAstNode2(node.callee.property) || node.callee.object.type !== "Identifier" || node.callee.property.type !== "Identifier" || typeof node.callee.object.name !== "string" || typeof node.callee.property.name !== "string" || !bindings.namespaces.has(node.callee.object.name) || isNameShadowed(node.callee.object.name, ancestors) || !isEnvironmentFunctionKind(node.callee.property.name)) {
+      return;
+    }
+    calls.push({ node, kind: node.callee.property.name });
+  });
+  return calls;
+}
+__name(findEnvironmentCalls, "findEnvironmentCalls");
+function createReplacement(code, id, environment, call) {
+  const args = Array.isArray(call.node.arguments) ? call.node.arguments : [];
+  if (args.length !== 1 || !isAstNode2(args[0]) || args[0].type === "SpreadElement") {
+    throw transformError(id, `${call.kind}() requires exactly one static argument`);
+  }
+  let replacement;
+  if (call.kind === "createIsomorphicFn") {
+    replacement = selectIsomorphicImplementation(code, id, environment, args[0]);
+  } else {
+    const expected = call.kind === "createServerOnlyFn" ? "server" : "client";
+    replacement = environment === expected ? readNode(code, args[0]) : `(0, ${readNode(code, call.node.callee)})(undefined, ${JSON.stringify(environment)})`;
+  }
+  return {
+    start: call.node.start,
+    end: call.node.end,
+    code: `(${replacement})`
+  };
+}
+__name(createReplacement, "createReplacement");
+function selectIsomorphicImplementation(code, id, environment, optionsNode) {
+  if (optionsNode.type !== "ObjectExpression") {
+    throw transformError(id, "createIsomorphicFn() requires an inline options object");
+  }
+  const properties = Array.isArray(optionsNode.properties) ? optionsNode.properties : [];
+  if (properties.some((property) => isAstNode2(property) && property.type === "SpreadElement")) {
+    throw transformError(id, "createIsomorphicFn() does not support spread properties");
+  }
+  let selectedProperty;
+  for (const property of properties) {
+    if (!isAstNode2(property) || property.type !== "Property" || property.computed === true) {
+      continue;
+    }
+    const key = readPropertyName2(property.key);
+    if (key === environment) selectedProperty = property;
+  }
+  if (!selectedProperty || !isAstNode2(selectedProperty.value)) {
+    throw transformError(id, `createIsomorphicFn() requires a ${environment} implementation`);
+  }
+  if (selectedProperty.kind !== void 0 && selectedProperty.kind !== "init") {
+    throw transformError(id, "createIsomorphicFn() does not support getters or setters");
+  }
+  return selectedProperty.method === true ? renderObjectMethod(code, id, selectedProperty.value) : readNode(code, selectedProperty.value);
+}
+__name(selectIsomorphicImplementation, "selectIsomorphicImplementation");
+function renderObjectMethod(code, id, functionNode) {
+  if (!isAstNode2(functionNode.body) || !Array.isArray(functionNode.params)) {
+    throw transformError(id, "createIsomorphicFn() received an unsupported method");
+  }
+  const params = functionNode.params.map((param) => {
+    if (!isAstNode2(param)) {
+      throw transformError(id, "createIsomorphicFn() received an unsupported parameter");
+    }
+    return readNode(code, param);
+  });
+  const asyncPrefix = functionNode.async === true ? "async " : "";
+  const generatorMarker = functionNode.generator === true ? "*" : "";
+  return `${asyncPrefix}function${generatorMarker}(${params.join(", ")}) ${readNode(code, functionNode.body)}`;
+}
+__name(renderObjectMethod, "renderObjectMethod");
+function applyReplacements2(code, replacements) {
+  let output = code;
+  for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+    output = output.slice(0, replacement.start) + replacement.code + output.slice(replacement.end);
+  }
+  return output;
+}
+__name(applyReplacements2, "applyReplacements");
+function walkAst(node, visit, ancestors = []) {
+  visit(node, ancestors);
+  const childAncestors = [...ancestors, node];
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    if (isAstNode2(value)) {
+      walkAst(value, visit, childAncestors);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isAstNode2(item)) walkAst(item, visit, childAncestors);
+      }
+    }
+  }
+}
+__name(walkAst, "walkAst");
+function isNameShadowed(name, ancestors) {
+  for (const [index, ancestor] of ancestors.entries()) {
+    if (isFunctionNode2(ancestor)) {
+      const params = Array.isArray(ancestor.params) ? ancestor.params : [];
+      if (params.some((param) => patternContainsName(param, name))) return true;
+      if (patternContainsName(ancestor.id, name)) return true;
+      if (isAstNode2(ancestor.body) && ancestors.slice(index + 1).includes(ancestor.body) && functionBodyDeclaresVarName(ancestor.body, name)) {
+        return true;
+      }
+    }
+    if (ancestor.type === "CatchClause" && patternContainsName(ancestor.param, name)) {
+      return true;
+    }
+    if ((ancestor.type === "BlockStatement" || ancestor.type === "StaticBlock") && blockDeclaresName(ancestor, name)) {
+      return true;
+    }
+    if (loopDeclaresName(ancestor, name)) return true;
+    if (ancestor.type === "SwitchStatement" && ancestors.slice(index + 1).some((candidate) => candidate.type === "SwitchCase") && switchDeclaresName(ancestor, name)) {
+      return true;
+    }
+    if (ancestor.type === "ClassExpression" && patternContainsName(ancestor.id, name) && ancestors.slice(index + 1).some((candidate) => candidate.type === "ClassBody")) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(isNameShadowed, "isNameShadowed");
+function functionBodyDeclaresVarName(body, name) {
+  if (body.type === "VariableDeclaration" && body.kind === "var") {
+    const declarations = Array.isArray(body.declarations) ? body.declarations : [];
+    if (declarations.some(
+      (declaration) => isAstNode2(declaration) && patternContainsName(declaration.id, name)
+    )) {
+      return true;
+    }
+  }
+  for (const [key, value] of Object.entries(body)) {
+    if (key === "start" || key === "end" || key === "loc" || key === "range") continue;
+    if (isAstNode2(value)) {
+      if (isNestedVarScope(value)) continue;
+      if (functionBodyDeclaresVarName(value, name)) return true;
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (!isAstNode2(item) || isNestedVarScope(item)) continue;
+        if (functionBodyDeclaresVarName(item, name)) return true;
+      }
+    }
+  }
+  return false;
+}
+__name(functionBodyDeclaresVarName, "functionBodyDeclaresVarName");
+function isNestedVarScope(node) {
+  return isFunctionNode2(node) || node.type === "ClassDeclaration" || node.type === "ClassExpression";
+}
+__name(isNestedVarScope, "isNestedVarScope");
+function loopDeclaresName(node, name) {
+  const declaration = node.type === "ForStatement" ? node.init : node.type === "ForInStatement" || node.type === "ForOfStatement" ? node.left : void 0;
+  if (!isAstNode2(declaration) || declaration.type !== "VariableDeclaration") return false;
+  const declarations = Array.isArray(declaration.declarations) ? declaration.declarations : [];
+  return declarations.some((item) => isAstNode2(item) && patternContainsName(item.id, name));
+}
+__name(loopDeclaresName, "loopDeclaresName");
+function switchDeclaresName(node, name) {
+  const cases = Array.isArray(node.cases) ? node.cases : [];
+  return cases.some((switchCase) => {
+    if (!isAstNode2(switchCase) || !Array.isArray(switchCase.consequent)) return false;
+    return switchCase.consequent.some((statement) => {
+      if (!isAstNode2(statement)) return false;
+      if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") && patternContainsName(statement.id, name)) {
+        return true;
+      }
+      if (statement.type !== "VariableDeclaration" || statement.kind === "var") return false;
+      const declarations = Array.isArray(statement.declarations) ? statement.declarations : [];
+      return declarations.some(
+        (declaration) => isAstNode2(declaration) && patternContainsName(declaration.id, name)
+      );
+    });
+  });
+}
+__name(switchDeclaresName, "switchDeclaresName");
+function blockDeclaresName(block, name) {
+  const statements = Array.isArray(block.body) ? block.body : [];
+  for (const statement of statements) {
+    if (!isAstNode2(statement)) continue;
+    if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") && patternContainsName(statement.id, name)) {
+      return true;
+    }
+    if (statement.type !== "VariableDeclaration" || !Array.isArray(statement.declarations)) {
+      continue;
+    }
+    if (statement.declarations.some(
+      (declaration) => isAstNode2(declaration) && patternContainsName(declaration.id, name)
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(blockDeclaresName, "blockDeclaresName");
+function patternContainsName(value, name) {
+  if (!isAstNode2(value)) return false;
+  if (value.type === "Identifier") return value.name === name;
+  if (value.type === "RestElement") return patternContainsName(value.argument, name);
+  if (value.type === "AssignmentPattern") return patternContainsName(value.left, name);
+  if (value.type === "Property") return patternContainsName(value.value, name);
+  const elements = Array.isArray(value.elements) ? value.elements : Array.isArray(value.properties) ? value.properties : [];
+  return elements.some((element) => patternContainsName(element, name));
+}
+__name(patternContainsName, "patternContainsName");
+function isFunctionNode2(node) {
+  return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+__name(isFunctionNode2, "isFunctionNode");
+function readPropertyName2(value) {
+  if (!isAstNode2(value)) return void 0;
+  if (value.type === "Identifier" && typeof value.name === "string") return value.name;
+  if (value.type === "Literal" && typeof value.value === "string") return value.value;
+  return void 0;
+}
+__name(readPropertyName2, "readPropertyName");
+function readNode(code, node) {
+  return code.slice(node.start, node.end);
+}
+__name(readNode, "readNode");
+function isAstNode2(value) {
+  return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+__name(isAstNode2, "isAstNode");
+function isEnvironmentFunctionKind(value) {
+  return typeof value === "string" && ENVIRONMENT_FUNCTIONS.has(value);
+}
+__name(isEnvironmentFunctionKind, "isEnvironmentFunctionKind");
+function containsEnvironmentFunction(code) {
+  return Array.from(ENVIRONMENT_FUNCTIONS).some((name) => code.includes(name));
+}
+__name(containsEnvironmentFunction, "containsEnvironmentFunction");
+function isTransformableModule2(id) {
+  const cleanId = id.split("?", 1)[0];
+  return MODULE_EXTENSION_RE2.test(cleanId) && !/\.d\.[cm]?ts$/.test(cleanId);
+}
+__name(isTransformableModule2, "isTransformableModule");
+function transformError(id, message) {
+  return new Error(`[Farm environment functions] ${message} in ${id.split("?", 1)[0]}`);
+}
+__name(transformError, "transformError");
+
+export {
+  transformEnvironmentFunctions,
+  farmEnvironmentFunctionsPlugin
+};