@farm.js/core 0.1.17 → 0.1.19

package/dist/environment/vite.cjs

@@ -1,373 +1,9 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/environment-vite.ts
-var environment_vite_exports = {};
-__export(environment_vite_exports, {
-  farmEnvironmentFunctionsPlugin: () => farmEnvironmentFunctionsPlugin,
-  transformEnvironmentFunctions: () => transformEnvironmentFunctions
-});
-module.exports = __toCommonJS(environment_vite_exports);
-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_RE = /\.[cm]?[jt]sx?$/;
-function transformEnvironmentFunctions(options) {
-  if (!isTransformableModule(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 = applyReplacements(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() {
-  return {
-    name: "farm:environment-functions",
-    enforce: "post",
-    transform(code, id, transformOptions) {
-      const result = transformEnvironmentFunctions({
-        code,
-        id,
-        environment: resolveBuildEnvironment(
-          this,
-          transformOptions?.ssr
-        ),
-        parse: /* @__PURE__ */ __name((source) => this.parse(source), "parse")
-      });
-      return result ? { code: result.code, map: null } : null;
-    }
-  };
-}
-__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 (!isAstNode(statement) || statement.type !== "ImportDeclaration") continue;
-    const source = isAstNode(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 (!isAstNode(specifier) || !isAstNode(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" || !isAstNode(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" || !isAstNode(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 || !isAstNode(node.callee.object) || !isAstNode(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 || !isAstNode(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) => isAstNode(property) && property.type === "SpreadElement")) {
-    throw transformError(id, "createIsomorphicFn() does not support spread properties");
-  }
-  let selectedProperty;
-  for (const property of properties) {
-    if (!isAstNode(property) || property.type !== "Property" || property.computed === true) {
-      continue;
-    }
-    const key = readPropertyName(property.key);
-    if (key === environment) selectedProperty = property;
-  }
-  if (!selectedProperty || !isAstNode(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 (!isAstNode(functionNode.body) || !Array.isArray(functionNode.params)) {
-    throw transformError(id, "createIsomorphicFn() received an unsupported method");
-  }
-  const params = functionNode.params.map((param) => {
-    if (!isAstNode(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 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 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 (isAstNode(value)) {
-      walkAst(value, visit, childAncestors);
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        if (isAstNode(item)) walkAst(item, visit, childAncestors);
-      }
-    }
-  }
-}
-__name(walkAst, "walkAst");
-function isNameShadowed(name, ancestors) {
-  for (const [index, ancestor] of ancestors.entries()) {
-    if (isFunctionNode(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 (isAstNode(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) => isAstNode(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 (isAstNode(value)) {
-      if (isNestedVarScope(value)) continue;
-      if (functionBodyDeclaresVarName(value, name)) return true;
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        if (!isAstNode(item) || isNestedVarScope(item)) continue;
-        if (functionBodyDeclaresVarName(item, name)) return true;
-      }
-    }
-  }
-  return false;
-}
-__name(functionBodyDeclaresVarName, "functionBodyDeclaresVarName");
-function isNestedVarScope(node) {
-  return isFunctionNode(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 (!isAstNode(declaration) || declaration.type !== "VariableDeclaration") return false;
-  const declarations = Array.isArray(declaration.declarations) ? declaration.declarations : [];
-  return declarations.some((item) => isAstNode(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 (!isAstNode(switchCase) || !Array.isArray(switchCase.consequent)) return false;
-    return switchCase.consequent.some((statement) => {
-      if (!isAstNode(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) => isAstNode(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 (!isAstNode(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) => isAstNode(declaration) && patternContainsName(declaration.id, name)
-    )) {
-      return true;
-    }
-  }
-  return false;
-}
-__name(blockDeclaresName, "blockDeclaresName");
-function patternContainsName(value, name) {
-  if (!isAstNode(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 isFunctionNode(node) {
-  return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
-}
-__name(isFunctionNode, "isFunctionNode");
-function readPropertyName(value) {
-  if (!isAstNode(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(readPropertyName, "readPropertyName");
-function readNode(code, node) {
-  return code.slice(node.start, node.end);
-}
-__name(readNode, "readNode");
-function isAstNode(value) {
-  return !!value && typeof value === "object" && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
-}
-__name(isAstNode, "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 isTransformableModule(id) {
-  const cleanId = id.split("?", 1)[0];
-  return MODULE_EXTENSION_RE.test(cleanId) && !/\.d\.[cm]?ts$/.test(cleanId);
-}
-__name(isTransformableModule, "isTransformableModule");
-function transformError(id, message) {
-  return new Error(`[Farm environment functions] ${message} in ${id.split("?", 1)[0]}`);
-}
-__name(transformError, "transformError");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  farmEnvironmentFunctionsPlugin,
-  transformEnvironmentFunctions
-});
+
+var _chunk22GUSVNJcjs = require('../chunk-22GUSVNJ.cjs');
+require('../chunk-S3JO3N4H.cjs');
+
+
+
+exports.farmEnvironmentFunctionsPlugin = _chunk22GUSVNJcjs.farmEnvironmentFunctionsPlugin; exports.transformEnvironmentFunctions = _chunk22GUSVNJcjs.transformEnvironmentFunctions;

package/dist/environment.cjs

@@ -1,95 +1,13 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/environment.ts
-var environment_exports = {};
-__export(environment_exports, {
-  FarmEnvironmentError: () => FarmEnvironmentError,
-  createClientOnlyFn: () => createClientOnlyFn,
-  createIsomorphicFn: () => createIsomorphicFn,
-  createServerOnlyFn: () => createServerOnlyFn
-});
-module.exports = __toCommonJS(environment_exports);
-var _FarmEnvironmentError = class _FarmEnvironmentError extends Error {
-  constructor(api, expected, actual) {
-    super(`${api}() can only be called on the ${expected}. It was called on the ${actual}.`);
-    this.api = api;
-    this.expected = expected;
-    this.actual = actual;
-    this.code = "FARM_ENVIRONMENT_MISMATCH";
-    this.name = "FarmEnvironmentError";
-  }
-};
-__name(_FarmEnvironmentError, "FarmEnvironmentError");
-var FarmEnvironmentError = _FarmEnvironmentError;
-function createServerOnlyFn(implementation, compiledActualEnvironment) {
-  if (compiledActualEnvironment) {
-    return createMismatchFunction("createServerOnlyFn", "server", compiledActualEnvironment);
-  }
-  if (getRuntimeEnvironment() !== "server") {
-    return createMismatchFunction("createServerOnlyFn", "server");
-  }
-  assertFunction(implementation, "createServerOnlyFn");
-  return implementation;
-}
-__name(createServerOnlyFn, "createServerOnlyFn");
-function createClientOnlyFn(implementation, compiledActualEnvironment) {
-  if (compiledActualEnvironment) {
-    return createMismatchFunction("createClientOnlyFn", "client", compiledActualEnvironment);
-  }
-  if (getRuntimeEnvironment() !== "client") {
-    return createMismatchFunction("createClientOnlyFn", "client");
-  }
-  assertFunction(implementation, "createClientOnlyFn");
-  return implementation;
-}
-__name(createClientOnlyFn, "createClientOnlyFn");
-function createIsomorphicFn(options) {
-  if (!options || typeof options !== "object") {
-    throw new TypeError("createIsomorphicFn requires server and client functions");
-  }
-  assertFunction(options.server, "createIsomorphicFn server");
-  assertFunction(options.client, "createIsomorphicFn client");
-  return getRuntimeEnvironment() === "server" ? options.server : options.client;
-}
-__name(createIsomorphicFn, "createIsomorphicFn");
-function getRuntimeEnvironment() {
-  return typeof window === "undefined" ? "server" : "client";
-}
-__name(getRuntimeEnvironment, "getRuntimeEnvironment");
-function createMismatchFunction(api, expected, actual = expected === "server" ? "client" : "server") {
-  return /* @__PURE__ */ __name(function farmEnvironmentBoundary() {
-    throw new FarmEnvironmentError(api, expected, actual);
-  }, "farmEnvironmentBoundary");
-}
-__name(createMismatchFunction, "createMismatchFunction");
-function assertFunction(value, label) {
-  if (typeof value !== "function") {
-    throw new TypeError(`${label} must be a function`);
-  }
-}
-__name(assertFunction, "assertFunction");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FarmEnvironmentError,
-  createClientOnlyFn,
-  createIsomorphicFn,
-  createServerOnlyFn
-});
+
+
+
+var _chunkW4E7WMXEcjs = require('./chunk-W4E7WMXE.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+exports.FarmEnvironmentError = _chunkW4E7WMXEcjs.FarmEnvironmentError; exports.createClientOnlyFn = _chunkW4E7WMXEcjs.createClientOnlyFn; exports.createIsomorphicFn = _chunkW4E7WMXEcjs.createIsomorphicFn; exports.createServerOnlyFn = _chunkW4E7WMXEcjs.createServerOnlyFn;

package/dist/font.cjs

@@ -1,63 +1,13 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/font.ts
-var font_exports = {};
-__export(font_exports, {
-  defineLayoutFonts: () => defineLayoutFonts,
-  localFont: () => localFont,
-  remoteFont: () => remoteFont,
-  resolveFarmLayoutFonts: () => resolveFarmLayoutFonts
-});
-module.exports = __toCommonJS(font_exports);
-function defineLayoutFonts(fonts) {
-  return fonts;
-}
-__name(defineLayoutFonts, "defineLayoutFonts");
-function resolveFarmLayoutFonts(layouts) {
-  let resolved;
-  for (const layout of layouts) {
-    if (!layout.fonts) continue;
-    resolved = { ...resolved, ...layout.fonts };
-  }
-  return resolved;
-}
-__name(resolveFarmLayoutFonts, "resolveFarmLayoutFonts");
-function fontCompilerError(loader) {
-  throw new Error(
-    `[Farm fonts] ${loader}() must be called at module scope with static options and compiled by the Farm Vite plugin.`
-  );
-}
-__name(fontCompilerError, "fontCompilerError");
-function localFont(_options) {
-  return fontCompilerError("localFont");
-}
-__name(localFont, "localFont");
-function remoteFont(_options) {
-  return fontCompilerError("remoteFont");
-}
-__name(remoteFont, "remoteFont");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  defineLayoutFonts,
-  localFont,
-  remoteFont,
-  resolveFarmLayoutFonts
-});
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkAMDMVWMIcjs = require('./chunk-AMDMVWMI.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+exports.defineLayoutFonts = _chunkAMDMVWMIcjs.defineLayoutFonts; exports.localFont = _chunkAMDMVWMIcjs.localFont; exports.remoteFont = _chunkAMDMVWMIcjs.remoteFont; exports.resolveFarmLayoutFonts = _chunkAMDMVWMIcjs.resolveFarmLayoutFonts;