@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-52Y3C3HG.mjs

@@ -1,421 +0,0 @@
-import {
-  bundleNodeModule,
-  isDeclarationFile,
-  resolvePackageWithoutTsconfig
-} from "./chunk-VFXE6NWR.mjs";
-
-// src/layers.ts
-import { existsSync, readFileSync, realpathSync, statSync } from "fs";
-import { mkdir, unlink } from "fs/promises";
-import { createRequire, isBuiltin } from "module";
-import path from "path";
-import { pathToFileURL } from "url";
-var FARM_CORE_PACKAGE = "@farm.js/core";
-var FARM_CONFIG_ENTRY = "@farm.js/core/config";
-var FARM_CORE_REFERENCE_RE = /(["'])@farm.js\/core\1/g;
-var FARM_CONFIG_HELPER_IMPORT_RE = /(?:^|\n)[\t ]*import[\t ]*\{([^{}]*)\}[\t ]*from[\t ]*(["'])@farm.js\/core\2[\t ]*;?[\t ]*(?:\n|$)/g;
-var FARM_CONFIG_HELPER_SPECIFIER_RE = /^(?:defineConfig|defineFarmConfig)(?:\s+as\s+[$A-Z_a-z][$\w]*)?$/;
-var CONFIG_FILENAMES = [
-  "farm.config.ts",
-  "farm.config.tsx",
-  "farm.config.mts",
-  "farm.config.cts",
-  "farm.config.js",
-  "farm.config.jsx",
-  "farm.config.mjs",
-  "farm.config.cjs",
-  "config.ts",
-  "config.tsx",
-  "config.mts",
-  "config.cts",
-  "config.js",
-  "config.jsx",
-  "config.mjs",
-  "config.cjs"
-];
-var LAYER_LOCAL_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "root",
-  "srcDir",
-  "outDir",
-  "distDir",
-  "deploy",
-  "output",
-  "preset",
-  "publicDir",
-  "generateBuildId"
-]);
-async function resolveFarmLayers(projectConfig, options) {
-  const projectRoot = path.resolve(options.root);
-  const entries = normalizeLayerEntries(projectConfig.extends, "project config");
-  if (entries.length === 0) {
-    return {
-      config: {
-        ...projectConfig,
-        layers: []
-      },
-      layers: []
-    };
-  }
-  const loadedLayers = [];
-  const visited = /* @__PURE__ */ new Set();
-  const aliases = /* @__PURE__ */ new Map();
-  const visit = async (source, ownerRoot, stack) => {
-    const resolvedSource = resolveLayerSource(source, ownerRoot);
-    const cycleIndex = stack.findIndex((entry) => entry.root === resolvedSource.root);
-    if (cycleIndex !== -1) {
-      const cycle = [...stack.slice(cycleIndex).map((entry) => entry.source), source];
-      throw new Error(`Farm layer cycle detected: ${cycle.join(" -> ")}`);
-    }
-    if (visited.has(resolvedSource.root)) return;
-    const configFile = findFarmConfigFile(resolvedSource.root, resolvedSource.configFile);
-    const config = configFile ? await loadFarmConfigFile(configFile, {
-      cacheRoot: projectRoot,
-      root: resolvedSource.root
-    }) : {};
-    const nestedEntries = normalizeLayerEntries(config.extends, `layer ${JSON.stringify(source)}`);
-    const nextStack = [...stack, { root: resolvedSource.root, source }];
-    for (const nestedSource of nestedEntries) {
-      await visit(nestedSource, resolvedSource.root, nextStack);
-    }
-    if (visited.has(resolvedSource.root)) return;
-    const name = getLayerName(source, resolvedSource.root);
-    const conflictingRoot = aliases.get(name);
-    if (conflictingRoot && conflictingRoot !== resolvedSource.root) {
-      throw new Error(
-        `Farm layer alias "#layers/${name}" is ambiguous between ${conflictingRoot} and ${resolvedSource.root}`
-      );
-    }
-    aliases.set(name, resolvedSource.root);
-    visited.add(resolvedSource.root);
-    loadedLayers.push({
-      source,
-      name,
-      root: resolvedSource.root,
-      srcDir: normalizeLayerSrcDir(config.srcDir),
-      configFile,
-      config
-    });
-  };
-  for (const source of entries) {
-    await visit(source, projectRoot, []);
-  }
-  let mergedConfig = {};
-  for (const layer of loadedLayers) {
-    mergedConfig = mergeFarmLayerConfig(mergedConfig, getLayerDefaults(layer.config));
-  }
-  mergedConfig = mergeFarmLayerConfig(mergedConfig, projectConfig);
-  const layers = loadedLayers.map(({ config: _config, ...layer }) => layer);
-  return {
-    config: {
-      ...mergedConfig,
-      root: projectConfig.root,
-      srcDir: projectConfig.srcDir,
-      extends: projectConfig.extends,
-      layers
-    },
-    layers
-  };
-}
-function getFarmSourceRoots(config) {
-  const roots = (config.layers ?? []).map((layer) => ({
-    name: layer.name,
-    root: layer.root,
-    srcDir: layer.srcDir,
-    layer: true
-  }));
-  roots.push({
-    name: "project",
-    root: path.resolve(config.root || process.cwd()),
-    srcDir: config.srcDir || "src",
-    layer: false
-  });
-  return roots;
-}
-function getFarmAppDirectories(config) {
-  return getFarmSourceRoots(config).map((source) => path.join(source.root, source.srcDir, "app"));
-}
-function getFarmLayerAliases(layers) {
-  return Object.fromEntries(
-    (layers ?? []).map((layer) => [`#layers/${layer.name}`, path.join(layer.root, layer.srcDir)])
-  );
-}
-var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[A-Za-z]:[\\/]|\\\\)/;
-function toExternalSpecifier(resolvedPath) {
-  return path.isAbsolute(resolvedPath) ? pathToFileURL(resolvedPath).href : resolvedPath;
-}
-var BARE_SPECIFIER_RE = /^[^./]/;
-function createFarmConfigResolutionPlugin(options) {
-  const configEntryChecks = /* @__PURE__ */ new Map();
-  return {
-    name: "farm-config-package-resolution",
-    async resolveId(source, importer, extraOptions) {
-      if (!importer || extraOptions.isEntry || !BARE_SPECIFIER_RE.test(source) || source.startsWith("\0") || isBuiltin(source) || path.isAbsolute(source) || WINDOWS_ABSOLUTE_PATH_RE.test(source)) {
-        return null;
-      }
-      const resolveRuntimePath = async (specifier) => {
-        const resolved = await this.resolve(specifier, importer, {
-          kind: extraOptions.kind,
-          skipSelf: true
-        });
-        if (!resolved?.id || !isDeclarationFile(resolved.id)) return resolved?.id;
-        return await resolvePackageWithoutTsconfig(specifier, importer, extraOptions.kind) ?? void 0;
-      };
-      if (source === FARM_CORE_PACKAGE && extraOptions.kind === "import-statement") {
-        let configEntryCheck = configEntryChecks.get(importer);
-        if (!configEntryCheck) {
-          configEntryCheck = onlyImportsFarmConfigHelpers(importer, options.transform);
-          configEntryChecks.set(importer, configEntryCheck);
-        }
-        if (await configEntryCheck) {
-          const configEntry = await resolveRuntimePath(FARM_CONFIG_ENTRY);
-          if (configEntry) {
-            return { id: toExternalSpecifier(configEntry), external: true };
-          }
-        }
-      }
-      const resolvedId = await resolveRuntimePath(source);
-      if (!resolvedId) {
-        return { id: source, external: true };
-      }
-      return { id: toExternalSpecifier(resolvedId), external: true };
-    }
-  };
-}
-var FARM_CONFIG_ROOT = /* @__PURE__ */ Symbol.for("farm.configRoot");
-async function loadFarmConfigFile(configPath, options) {
-  const { transform } = await import("rolldown/utils");
-  const cacheRoot = path.resolve(options.cacheRoot || options.root);
-  const configCacheDir = path.join(cacheRoot, ".farm", ".config-loader");
-  await mkdir(configCacheDir, { recursive: true });
-  const modulePath = path.join(
-    configCacheDir,
-    `farm-config-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`
-  );
-  await bundleNodeModule({
-    root: path.resolve(options.root),
-    entry: path.resolve(configPath),
-    outfile: modulePath,
-    target: `node${process.versions.node.split(".")[0]}`,
-    plugins: [createFarmConfigResolutionPlugin({ transform })]
-  });
-  const moduleUrl = `${pathToFileURL(modulePath).href}?t=${Date.now()}`;
-  const configRootState = globalThis;
-  const previousConfigRoot = configRootState[FARM_CONFIG_ROOT];
-  configRootState[FARM_CONFIG_ROOT] = cacheRoot;
-  try {
-    const loaded = await import(
-      /* @vite-ignore */
-      moduleUrl
-    );
-    const config = loaded.default || loaded;
-    if (!config || typeof config !== "object" || Array.isArray(config)) {
-      throw new TypeError(`Farm config ${configPath} must export an object`);
-    }
-    return config;
-  } finally {
-    configRootState[FARM_CONFIG_ROOT] = previousConfigRoot;
-    await unlink(modulePath).catch(() => void 0);
-  }
-}
-async function onlyImportsFarmConfigHelpers(importer, transform) {
-  try {
-    const source = readFileSync(importer, "utf8");
-    if (!source.includes(FARM_CORE_PACKAGE)) return false;
-    const transformed = await transform(importer, source, {
-      lang: getSourceLang(importer),
-      sourceType: "module",
-      jsx: { runtime: "automatic" }
-    });
-    if (transformed.errors.length > 0) return false;
-    const references = [...transformed.code.matchAll(FARM_CORE_REFERENCE_RE)];
-    if (references.length === 0) return false;
-    const safeImportRanges = [];
-    for (const match of transformed.code.matchAll(FARM_CONFIG_HELPER_IMPORT_RE)) {
-      const specifiers = match[1].split(",").map((specifier) => specifier.trim()).filter(Boolean);
-      if (specifiers.length === 0 || !specifiers.every((specifier) => FARM_CONFIG_HELPER_SPECIFIER_RE.test(specifier))) {
-        continue;
-      }
-      const start = match.index ?? 0;
-      safeImportRanges.push({ start, end: start + match[0].length });
-    }
-    return references.every((reference) => {
-      const index = reference.index ?? -1;
-      return safeImportRanges.some((range) => index >= range.start && index < range.end);
-    });
-  } catch {
-    return false;
-  }
-}
-function getSourceLang(file) {
-  switch (path.extname(file)) {
-    case ".ts":
-    case ".mts":
-    case ".cts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    default:
-      return "js";
-  }
-}
-function normalizeLayerEntries(value, owner) {
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) {
-    throw new TypeError(`${owner} "extends" must be an array of layer paths or package names`);
-  }
-  return value.map((entry, index) => {
-    if (typeof entry !== "string" || entry.trim() === "") {
-      throw new TypeError(`${owner} "extends" entry ${index} must be a non-empty string`);
-    }
-    return entry.trim();
-  });
-}
-function resolveLayerSource(source, ownerRoot) {
-  if (isPathLayerSource(source)) {
-    const target = source.startsWith("file:") ? path.resolve(ownerRoot, source.slice("file:".length)) : path.resolve(ownerRoot, source);
-    if (!existsSync(target)) {
-      throw new Error(`Cannot resolve Farm layer ${JSON.stringify(source)} from ${ownerRoot}`);
-    }
-    const stats = statSync(target);
-    const root = stats.isDirectory() ? target : path.dirname(target);
-    return {
-      root: normalizeRealPath(root),
-      configFile: stats.isFile() ? normalizeRealPath(target) : void 0
-    };
-  }
-  const requireFromOwner = createRequire(path.join(ownerRoot, "package.json"));
-  let packageJsonPath;
-  try {
-    packageJsonPath = requireFromOwner.resolve(`${source}/package.json`);
-  } catch {
-  }
-  if (packageJsonPath) {
-    return { root: normalizeRealPath(path.dirname(packageJsonPath)) };
-  }
-  try {
-    const entryPath = requireFromOwner.resolve(source);
-    const packageRoot = findNearestPackageRoot(entryPath);
-    if (packageRoot) return { root: normalizeRealPath(packageRoot) };
-  } catch {
-  }
-  throw new Error(`Cannot resolve Farm layer package ${JSON.stringify(source)} from ${ownerRoot}`);
-}
-function findNearestPackageRoot(entryPath) {
-  let current = statSync(entryPath).isDirectory() ? entryPath : path.dirname(entryPath);
-  while (true) {
-    if (existsSync(path.join(current, "package.json"))) return current;
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function findFarmConfigFile(root, explicitPath) {
-  if (explicitPath) return explicitPath;
-  for (const fileName of CONFIG_FILENAMES) {
-    const candidate = path.join(root, fileName);
-    if (existsSync(candidate)) return candidate;
-  }
-  return void 0;
-}
-function getLayerName(source, root) {
-  if (!isPathLayerSource(source)) {
-    const packageName = source.split("/").filter(Boolean).pop();
-    if (packageName) return sanitizeLayerName(packageName);
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
-    if (typeof packageJson.name === "string") {
-      return sanitizeLayerName(packageJson.name.split("/").pop() || packageJson.name);
-    }
-  } catch {
-  }
-  return sanitizeLayerName(path.basename(root));
-}
-function sanitizeLayerName(value) {
-  const name = value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
-  if (!name) throw new Error(`Cannot derive a name for Farm layer ${JSON.stringify(value)}`);
-  return name;
-}
-function normalizeLayerSrcDir(value) {
-  if (value === void 0) return "src";
-  if (typeof value !== "string" || value.trim() === "" || path.isAbsolute(value)) {
-    throw new TypeError("A Farm layer srcDir must be a non-empty relative path");
-  }
-  const normalized = path.normalize(value.trim());
-  if (normalized === ".." || normalized.startsWith(`..${path.sep}`)) {
-    throw new TypeError("A Farm layer srcDir cannot leave the layer root");
-  }
-  return normalized;
-}
-function getLayerDefaults(config) {
-  return Object.fromEntries(
-    Object.entries(config).filter(
-      ([key, value]) => key !== "extends" && value !== void 0 && !LAYER_LOCAL_CONFIG_KEYS.has(key)
-    )
-  );
-}
-function mergeFarmLayerConfig(base, override) {
-  const output = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === void 0 || key === "layers") continue;
-    if (key === "plugins") {
-      output[key] = [...toArray(output[key]), ...toArray(value)];
-      continue;
-    }
-    if (key === "middleware" && output[key] !== void 0) {
-      output[key] = [...toArray(output[key]), ...toArray(value)];
-      continue;
-    }
-    if ((key === "redirects" || key === "rewrites" || key === "headers") && output[key]) {
-      output[key] = mergeConfigListResolvers(output[key], value);
-      continue;
-    }
-    if (isPlainObject(output[key]) && isPlainObject(value)) {
-      output[key] = mergePlainObjects(output[key], value);
-      continue;
-    }
-    output[key] = value;
-  }
-  return output;
-}
-function mergePlainObjects(base, override) {
-  const output = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === void 0) continue;
-    output[key] = isPlainObject(output[key]) && isPlainObject(value) ? mergePlainObjects(output[key], value) : value;
-  }
-  return output;
-}
-function mergeConfigListResolvers(base, override) {
-  return async () => [...await resolveConfigList(base), ...await resolveConfigList(override)];
-}
-async function resolveConfigList(value) {
-  const resolved = typeof value === "function" ? await value() : value;
-  return toArray(resolved);
-}
-function toArray(value) {
-  if (value === void 0 || value === null) return [];
-  return Array.isArray(value) ? value : [value];
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isPathLayerSource(source) {
-  return source.startsWith(".") || source.startsWith("/") || source.startsWith("file:") || /^[a-zA-Z]:[\\/]/.test(source);
-}
-function normalizeRealPath(value) {
-  return path.resolve(realpathSync(value));
-}
-
-export {
-  resolveFarmLayers,
-  getFarmSourceRoots,
-  getFarmAppDirectories,
-  getFarmLayerAliases,
-  createFarmConfigResolutionPlugin,
-  loadFarmConfigFile
-};

package/dist/chunk-53EHWHT2.cjs

@@ -1,166 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-var _chunkD4XGKF67cjs = require('./chunk-D4XGKF67.cjs');
-
-
-
-
-var _chunkYTVSWXEZcjs = require('./chunk-YTVSWXEZ.cjs');
-
-// src/router.ts
-function createFarmRouter(routes) {
-  const normalizedRoutes = routes.map(normalizeRouteInput);
-  const patternsByShape = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    const shape = _chunkYTVSWXEZcjs.getRoutePatternShape.call(void 0, entry.route.path, "router");
-    const existingPattern = patternsByShape.get(shape);
-    if (existingPattern) {
-      throw new (0, _chunkYTVSWXEZcjs.AmbiguousRouteError)(
-        `Ambiguous route patterns "${existingPattern}" and "${entry.route.path}" match the same URLs. Keep only one route for this URL shape.`
-      );
-    }
-    patternsByShape.set(shape, entry.route.path);
-  }
-  normalizedRoutes.sort(compareRoutes);
-  const exactRoutes = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    if (entry.segments.every((segment) => segment.type === "static")) {
-      const pathname = entry.segments.length ? `/${entry.segments.map((segment) => encodePathSegment(segment.value)).join("/")}` : "/";
-      exactRoutes.set(pathname, entry);
-    }
-  }
-  return {
-    routes: normalizedRoutes.map((entry) => entry.route),
-    match(pathname) {
-      const normalizedPathname = _chunkD4XGKF67cjs.normalizePathname.call(void 0, pathname);
-      const exactRoute = exactRoutes.get(normalizedPathname);
-      if (exactRoute) {
-        return {
-          route: exactRoute.route,
-          pathname: normalizedPathname,
-          params: {}
-        };
-      }
-      const parts = _chunkD4XGKF67cjs.splitNormalizedPathname.call(void 0, normalizedPathname);
-      for (const entry of normalizedRoutes) {
-        const params = _chunkD4XGKF67cjs.matchSegmentParts.call(void 0, entry.segments, parts);
-        if (params) {
-          return {
-            route: entry.route,
-            pathname: normalizedPathname,
-            params
-          };
-        }
-      }
-      return null;
-    },
-    build: buildFarmRoutePath,
-    isActive: isFarmRouteActive
-  };
-}
-function matchFarmRoute(pattern, pathname) {
-  return matchSegments(_chunkD4XGKF67cjs.parseRoutePattern.call(void 0, pattern), _chunkD4XGKF67cjs.normalizePathname.call(void 0, pathname));
-}
-function buildFarmRoutePath(pattern, params = {}, options = {}) {
-  const parts = [];
-  for (const segment of _chunkD4XGKF67cjs.parseRoutePattern.call(void 0, pattern)) {
-    if (segment.type === "static") {
-      parts.push(encodePathSegment(segment.value));
-      continue;
-    }
-    const value = params[segment.name];
-    const values = Array.isArray(value) ? value : value == null ? [] : [value];
-    if (values.length === 0) {
-      if (segment.optional) continue;
-      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
-    }
-    if (!segment.catchAll && values.length > 1) {
-      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
-    }
-    const encodedValues = values.map((item) => {
-      const value2 = String(item);
-      if (!value2) {
-        throw new Error(
-          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
-        );
-      }
-      return encodePathSegment(value2);
-    });
-    parts.push(...encodedValues);
-  }
-  let pathname = parts.length ? `/${parts.join("/")}` : "/";
-  if (options.trailingSlash && pathname !== "/") {
-    pathname = `${pathname}/`;
-  }
-  return appendQueryAndHash(pathname, options);
-}
-function isFarmRouteActive(pattern, pathname, options = {}) {
-  const normalizedPathname = _chunkD4XGKF67cjs.normalizePathname.call(void 0, pathname);
-  const segments = _chunkD4XGKF67cjs.parseRoutePattern.call(void 0, pattern);
-  const parts = _chunkD4XGKF67cjs.splitNormalizedPathname.call(void 0, normalizedPathname);
-  if (_chunkD4XGKF67cjs.matchSegmentParts.call(void 0, segments, parts)) return true;
-  if (options.exact !== false) return false;
-  if (segments.length === 0) return normalizedPathname === "/";
-  return _chunkD4XGKF67cjs.matchSegmentParts.call(void 0, segments, parts, true) !== null;
-}
-function normalizeRouteInput(input, index) {
-  const route = typeof input === "string" ? { path: input } : input;
-  const segments = _chunkD4XGKF67cjs.parseRoutePattern.call(void 0, route.path);
-  const path = _chunkD4XGKF67cjs.normalizeRoutePattern.call(void 0, route.path);
-  return {
-    route: {
-      ...route,
-      path
-    },
-    segments,
-    specificity: segments.map(getRouterSegmentSpecificity),
-    index
-  };
-}
-function matchSegments(segments, pathname, allowTrailingSegments = false) {
-  return _chunkD4XGKF67cjs.matchSegmentParts.call(void 0, segments, _chunkD4XGKF67cjs.splitPathname.call(void 0, pathname), allowTrailingSegments);
-}
-function compareRoutes(left, right) {
-  const specificity = _chunkYTVSWXEZcjs.compareRouteSpecificity.call(void 0, left.specificity, right.specificity);
-  if (specificity !== 0) return specificity;
-  return left.index - right.index;
-}
-function getRouterSegmentSpecificity(segment) {
-  if (segment.type === "static") return "static";
-  if (!segment.catchAll) return "dynamic";
-  return segment.optional ? "optional-catch-all" : "catch-all";
-}
-function encodePathSegment(value) {
-  return encodeURIComponent(value);
-}
-function appendQueryAndHash(pathname, options) {
-  const search = createSearchParams(options.query);
-  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
-  const query = search.toString();
-  return `${pathname}${query ? `?${query}` : ""}${hash}`;
-}
-function createSearchParams(query) {
-  if (query instanceof URLSearchParams) return query;
-  const search = new URLSearchParams();
-  if (!query) return search;
-  for (const [key, value] of Object.entries(query)) {
-    const values = Array.isArray(value) ? value : [value];
-    for (const item of values) {
-      if (item == null) continue;
-      search.append(key, String(item));
-    }
-  }
-  return search;
-}
-
-
-
-
-
-
-exports.createFarmRouter = createFarmRouter; exports.matchFarmRoute = matchFarmRoute; exports.buildFarmRoutePath = buildFarmRoutePath; exports.isFarmRouteActive = isFarmRouteActive;

package/dist/chunk-55U5QIXQ.mjs

@@ -1,35 +0,0 @@
-import {
-  createFarmMarkdownRouteModule
-} from "./chunk-E72UD6ME.mjs";
-
-// src/app-markdown.ts
-import { readFile } from "fs/promises";
-import path from "path";
-import { pathToFileURL } from "url";
-async function createFarmMarkdownRouteModuleFromFile(filePath, options = {}) {
-  const source = await readFile(filePath, "utf8");
-  return createFarmMarkdownRouteModule({
-    source,
-    filePath,
-    components: options.components,
-    config: options.config
-  });
-}
-async function loadFarmMdxComponents(config, options) {
-  const configured = config?.components;
-  if (!configured) {
-    return {};
-  }
-  if (typeof configured !== "string") {
-    return configured;
-  }
-  const modulePath = path.isAbsolute(configured) ? configured : path.join(options.root, configured);
-  const mod = options.loadModule ? await options.loadModule(modulePath) : await import(pathToFileURL(modulePath).href);
-  const maybeModule = mod;
-  return maybeModule.components || maybeModule.default || {};
-}
-
-export {
-  createFarmMarkdownRouteModuleFromFile,
-  loadFarmMdxComponents
-};