@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-QBK2AA4U.cjs

@@ -1,445 +0,0 @@
-"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; }
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// src/deferred.ts
-var FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
-var FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
-var FARM_DEFERRED_BRAND = /* @__PURE__ */ Symbol.for(
-  "farm.deferred"
-);
-var FARM_DEFERRED_MARKER = "$farmDeferred";
-var _DeferredDataError = class _DeferredDataError extends Error {
-  constructor(message = "Deferred route data failed to load") {
-    super(message);
-    this.name = "DeferredDataError";
-    this.code = FARM_DEFERRED_ERROR_CODE;
-  }
-};
-_chunkS3JO3N4Hcjs.__name.call(void 0, _DeferredDataError, "DeferredDataError");
-var DeferredDataError = _DeferredDataError;
-var deferredStates = /* @__PURE__ */ new WeakMap();
-function defer(value) {
-  if (isDeferred(value)) {
-    return value;
-  }
-  const promise = Promise.resolve(value);
-  Object.defineProperty(promise, FARM_DEFERRED_BRAND, {
-    configurable: false,
-    enumerable: false,
-    value: true,
-    writable: false
-  });
-  deferredStates.set(promise, { status: "pending" });
-  promise.then(
-    (resolved) => deferredStates.set(promise, { status: "fulfilled", value: resolved }),
-    (reason) => deferredStates.set(promise, { status: "rejected", reason })
-  );
-  return promise;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, defer, "defer");
-function isDeferred(value) {
-  return Boolean(
-    value && (typeof value === "object" || typeof value === "function") && value[FARM_DEFERRED_BRAND] === true
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isDeferred, "isDeferred");
-function prepareDeferredData(value) {
-  const context = createEncodingContext();
-  return {
-    data: encodeDeferredValue(value, context, /* @__PURE__ */ new WeakSet()),
-    records: context.records
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, prepareDeferredData, "prepareDeferredData");
-function snapshotDeferredData(records) {
-  const context = createEncodingContext(records);
-  const settlements = {};
-  for (let index = 0; index < context.records.length; index++) {
-    const record = context.records[index];
-    const state = readDeferredState(record.promise);
-    if (state.status === "fulfilled") {
-      try {
-        settlements[record.id] = {
-          status: "fulfilled",
-          value: encodeDeferredValue(state.value, context, /* @__PURE__ */ new WeakSet())
-        };
-      } catch (e) {
-        settlements[record.id] = createRejectedSettlement();
-      }
-    } else {
-      settlements[record.id] = createRejectedSettlement();
-    }
-  }
-  return settlements;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, snapshotDeferredData, "snapshotDeferredData");
-function reviveDeferredData(value, settlements) {
-  return reviveDeferredValue(value, /* @__PURE__ */ new Map(), settlements);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, reviveDeferredData, "reviveDeferredData");
-function createDeferredDataResponse(value, init = {}, options = {}) {
-  const context = createEncodingContext();
-  const data = encodeDeferredValue(value, context, /* @__PURE__ */ new WeakSet());
-  const headers = new Headers(init.headers);
-  if (context.records.length === 0) {
-    headers.set("Content-Type", "application/json; charset=utf-8");
-    return new Response(JSON.stringify(data), { ...init, headers });
-  }
-  headers.set("Content-Type", `${FARM_DEFERRED_CONTENT_TYPE}; charset=utf-8`);
-  headers.set("Cache-Control", headers.get("Cache-Control") || "private, max-age=0");
-  const initialLine = encodeDeferredMessage({ type: "data", data });
-  const encoder = new TextEncoder();
-  let cancelled = false;
-  const stream = new ReadableStream({
-    start(controller) {
-      controller.enqueue(encoder.encode(initialLine));
-      let pending = context.records.length;
-      const finishRecord = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
-        pending--;
-        if (!cancelled && pending === 0) controller.close();
-      }, "finishRecord");
-      const schedule = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (record) => {
-        record.promise.then(
-          (resolved) => {
-            if (cancelled) return;
-            try {
-              const previousLength = context.records.length;
-              const encoded = encodeDeferredValue(resolved, context, /* @__PURE__ */ new WeakSet());
-              const nestedRecords = context.records.slice(previousLength);
-              pending += nestedRecords.length;
-              controller.enqueue(
-                encoder.encode(
-                  encodeDeferredMessage({ type: "resolve", id: record.id, data: encoded })
-                )
-              );
-              for (const nestedRecord of nestedRecords) schedule(nestedRecord);
-            } catch (error) {
-              reportDeferredError(options, error, record.id);
-              controller.enqueue(
-                encoder.encode(
-                  encodeDeferredMessage({
-                    type: "reject",
-                    id: record.id,
-                    error: createDeferredPublicError()
-                  })
-                )
-              );
-            }
-          },
-          (error) => {
-            if (cancelled) return;
-            reportDeferredError(options, error, record.id);
-            controller.enqueue(
-              encoder.encode(
-                encodeDeferredMessage({
-                  type: "reject",
-                  id: record.id,
-                  error: createDeferredPublicError()
-                })
-              )
-            );
-          }
-        ).finally(finishRecord);
-      }, "schedule");
-      const initialRecords = context.records.slice();
-      for (const record of initialRecords) schedule(record);
-    },
-    cancel() {
-      cancelled = true;
-    }
-  });
-  return new Response(stream, { ...init, headers });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createDeferredDataResponse, "createDeferredDataResponse");
-async function readDeferredDataResponse(response, options = {}) {
-  const contentType = response.headers.get("Content-Type") || "";
-  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {
-    const data2 = await response.json();
-    notifyDeferredComplete(options);
-    return data2;
-  }
-  if (!response.body) {
-    throw new DeferredDataError("Deferred route data response has no body");
-  }
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  const controllers = /* @__PURE__ */ new Map();
-  let buffer = "";
-  let complete = false;
-  const readLine = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
-    while (true) {
-      const newline = buffer.indexOf("\n");
-      if (newline >= 0) {
-        const line = buffer.slice(0, newline);
-        buffer = buffer.slice(newline + 1);
-        return line;
-      }
-      if (complete) {
-        if (!buffer) return void 0;
-        const line = buffer;
-        buffer = "";
-        return line;
-      }
-      const chunk = await reader.read();
-      complete = chunk.done;
-      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-      if (chunk.done) buffer += decoder.decode();
-    }
-  }, "readLine");
-  const firstLine = await readLine();
-  if (!firstLine) {
-    reader.releaseLock();
-    throw new DeferredDataError("Deferred route data response is empty");
-  }
-  const initial = parseDeferredMessage(firstLine);
-  if (initial.type !== "data") {
-    reader.releaseLock();
-    throw new DeferredDataError("Deferred route data response is invalid");
-  }
-  const data = reviveDeferredValue(initial.data, controllers);
-  void (async () => {
-    try {
-      for (let line = await readLine(); line !== void 0; line = await readLine()) {
-        if (!line) continue;
-        const message = parseDeferredMessage(line);
-        if (message.type === "resolve") {
-          const controller = getControlledDeferred(message.id, controllers);
-          controller.resolve(reviveDeferredValue(message.data, controllers));
-        } else if (message.type === "reject") {
-          getControlledDeferred(message.id, controllers).reject(
-            new DeferredDataError(_optionalChain([message, 'access', _ => _.error, 'optionalAccess', _2 => _2.message]))
-          );
-        }
-      }
-      const outstanding = rejectPendingDeferred(
-        controllers,
-        "Deferred route data stream ended before completion"
-      );
-      if (outstanding === 0) notifyDeferredComplete(options);
-    } catch (e2) {
-      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
-    } finally {
-      reader.releaseLock();
-    }
-  })();
-  return data;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, readDeferredDataResponse, "readDeferredDataResponse");
-function notifyDeferredComplete(options) {
-  try {
-    _optionalChain([options, 'access', _3 => _3.onComplete, 'optionalCall', _4 => _4()]);
-  } catch (e3) {
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, notifyDeferredComplete, "notifyDeferredComplete");
-function createEncodingContext(records = []) {
-  return {
-    records: [...records],
-    ids: new Map(records.map((record) => [record.promise, record.id])),
-    nextId: records.reduce((highest, record) => {
-      const value = Number(record.id.replace(/^d/, ""));
-      return Number.isFinite(value) ? Math.max(highest, value + 1) : highest;
-    }, records.length)
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createEncodingContext, "createEncodingContext");
-function encodeDeferredValue(value, context, ancestors) {
-  if (isDeferred(value)) {
-    let id = context.ids.get(value);
-    if (!id) {
-      id = `d${context.nextId++}`;
-      context.ids.set(value, id);
-      context.records.push({ id, promise: value });
-    }
-    return { [FARM_DEFERRED_MARKER]: id };
-  }
-  if (!value || typeof value !== "object") return value;
-  if (Array.isArray(value)) {
-    assertNotCircular(value, ancestors);
-    const output2 = value.map((item) => encodeDeferredValue(item, context, ancestors));
-    ancestors.delete(value);
-    return output2;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) return value;
-  assertNotCircular(value, ancestors);
-  const output = {};
-  for (const [key, item] of Object.entries(value)) {
-    defineDataProperty(output, key, encodeDeferredValue(item, context, ancestors));
-  }
-  ancestors.delete(value);
-  if (isDeferredMarker(output)) {
-    return { [FARM_DEFERRED_MARKER]: `!${output[FARM_DEFERRED_MARKER]}` };
-  }
-  return output;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, encodeDeferredValue, "encodeDeferredValue");
-function reviveDeferredValue(value, controllers, settlements, applyingSettlements = /* @__PURE__ */ new Set()) {
-  if (isDeferredMarker(value)) {
-    const id = value[FARM_DEFERRED_MARKER];
-    if (id.startsWith("!")) {
-      return { [FARM_DEFERRED_MARKER]: id.slice(1) };
-    }
-    const controller = getControlledDeferred(id, controllers);
-    const settlement = _optionalChain([settlements, 'optionalAccess', _5 => _5[id]]);
-    if (settlement && controller.promise.status === "pending") {
-      if (applyingSettlements.has(id)) return controller.promise;
-      applyingSettlements.add(id);
-      if (settlement.status === "fulfilled") {
-        controller.resolve(
-          reviveDeferredValue(settlement.value, controllers, settlements, applyingSettlements)
-        );
-      } else {
-        controller.reject(new DeferredDataError(settlement.error.message));
-      }
-      applyingSettlements.delete(id);
-    } else if (settlements && controller.promise.status === "pending") {
-      controller.reject(new DeferredDataError("Deferred route data was not resolved"));
-    }
-    return controller.promise;
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (item) => reviveDeferredValue(item, controllers, settlements, applyingSettlements)
-    );
-  }
-  if (!value || typeof value !== "object") return value;
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) return value;
-  const output = {};
-  for (const [key, item] of Object.entries(value)) {
-    defineDataProperty(
-      output,
-      key,
-      reviveDeferredValue(item, controllers, settlements, applyingSettlements)
-    );
-  }
-  return output;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, reviveDeferredValue, "reviveDeferredValue");
-function defineDataProperty(output, key, value) {
-  if (key === "__proto__") {
-    Object.defineProperty(output, key, {
-      value,
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
-  } else {
-    output[key] = value;
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, defineDataProperty, "defineDataProperty");
-function getControlledDeferred(id, controllers) {
-  const existing = controllers.get(id);
-  if (existing) return existing;
-  let nativeResolve;
-  let nativeReject;
-  const promise = new Promise((resolve, reject) => {
-    nativeResolve = resolve;
-    nativeReject = reject;
-  });
-  promise.status = "pending";
-  promise.catch(() => void 0);
-  const controlled = {
-    promise,
-    resolve(value) {
-      if (promise.status !== "pending") return;
-      promise.status = "fulfilled";
-      promise.value = value;
-      nativeResolve(value);
-    },
-    reject(error) {
-      if (promise.status !== "pending") return;
-      promise.status = "rejected";
-      promise.reason = error;
-      nativeReject(error);
-    }
-  };
-  controllers.set(id, controlled);
-  return controlled;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getControlledDeferred, "getControlledDeferred");
-function readDeferredState(promise) {
-  const tracked = deferredStates.get(promise);
-  if (tracked && tracked.status !== "pending") return tracked;
-  const reactState = promise;
-  if (reactState.status === "fulfilled") {
-    return { status: "fulfilled", value: reactState.value };
-  }
-  if (reactState.status === "rejected") {
-    return { status: "rejected", reason: reactState.reason };
-  }
-  return tracked || { status: "pending" };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, readDeferredState, "readDeferredState");
-function isDeferredMarker(value) {
-  return Boolean(
-    value && typeof value === "object" && Object.keys(value).length === 1 && typeof value[FARM_DEFERRED_MARKER] === "string"
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isDeferredMarker, "isDeferredMarker");
-function assertNotCircular(value, ancestors) {
-  if (ancestors.has(value)) {
-    throw new TypeError("Deferred route data must be JSON-serializable and cannot be circular");
-  }
-  ancestors.add(value);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, assertNotCircular, "assertNotCircular");
-function createDeferredPublicError() {
-  return {
-    code: FARM_DEFERRED_ERROR_CODE,
-    message: "Deferred route data failed to load"
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createDeferredPublicError, "createDeferredPublicError");
-function createRejectedSettlement() {
-  return { status: "rejected", error: createDeferredPublicError() };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createRejectedSettlement, "createRejectedSettlement");
-function reportDeferredError(options, error, id) {
-  try {
-    _optionalChain([options, 'access', _6 => _6.onError, 'optionalCall', _7 => _7(error, id)]);
-  } catch (e4) {
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, reportDeferredError, "reportDeferredError");
-function encodeDeferredMessage(message) {
-  return `${JSON.stringify(message)}
-`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, encodeDeferredMessage, "encodeDeferredMessage");
-function parseDeferredMessage(line) {
-  try {
-    return JSON.parse(line);
-  } catch (e5) {
-    throw new DeferredDataError("Deferred route data response contains invalid JSON");
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, parseDeferredMessage, "parseDeferredMessage");
-function rejectPendingDeferred(controllers, message) {
-  let rejected = 0;
-  for (const controller of controllers.values()) {
-    if (controller.promise.status === "pending") {
-      controller.reject(new DeferredDataError(message));
-      rejected += 1;
-    }
-  }
-  return rejected;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, rejectPendingDeferred, "rejectPendingDeferred");
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.FARM_DEFERRED_CONTENT_TYPE = FARM_DEFERRED_CONTENT_TYPE; exports.FARM_DEFERRED_ERROR_CODE = FARM_DEFERRED_ERROR_CODE; exports.FARM_DEFERRED_BRAND = FARM_DEFERRED_BRAND; exports.DeferredDataError = DeferredDataError; exports.defer = defer; exports.isDeferred = isDeferred; exports.prepareDeferredData = prepareDeferredData; exports.snapshotDeferredData = snapshotDeferredData; exports.reviveDeferredData = reviveDeferredData; exports.createDeferredDataResponse = createDeferredDataResponse; exports.readDeferredDataResponse = readDeferredDataResponse;

package/dist/chunk-QCFBDFRS.mjs

@@ -1,169 +0,0 @@
-import {
-  resolveFarmI18nMessagePath
-} from "./chunk-BCMSYSN2.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/i18n/catalog.ts
-import { readFile } from "fs/promises";
-import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
-async function readFarmI18nCatalogs(config) {
-  if (!config.enabled) {
-    return { catalogs: {}, signatures: {} };
-  }
-  const catalogs = {};
-  for (const locale of config.locales) {
-    const filePath = resolveFarmI18nMessagePath(config, locale);
-    let source;
-    try {
-      source = await readFile(filePath, "utf8");
-    } catch (error) {
-      throw new Error(
-        `Unable to read Farm i18n catalog for "${locale}" at ${filePath}: ${messageOf(error)}`
-      );
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(source);
-    } catch (error) {
-      throw new Error(`Invalid JSON in Farm i18n catalog ${filePath}: ${messageOf(error)}`);
-    }
-    catalogs[locale] = flattenFarmI18nCatalog(parsed, filePath);
-  }
-  const reference = catalogs[config.defaultLocale] || {};
-  const signatures = {};
-  for (const [key, message] of Object.entries(reference)) {
-    signatures[key] = analyzeFarmI18nMessage(message, `${config.defaultLocale}:${key}`);
-  }
-  validateFarmI18nCatalogs(config, catalogs, signatures);
-  return { catalogs, signatures };
-}
-__name(readFarmI18nCatalogs, "readFarmI18nCatalogs");
-function flattenFarmI18nCatalog(input, source = "i18n catalog") {
-  if (!isPlainObject(input)) {
-    throw new Error(`${source} must contain a JSON object at its root.`);
-  }
-  const output = {};
-  const visit = /* @__PURE__ */ __name((value, segments) => {
-    if (typeof value === "string") {
-      const key = segments.join(".");
-      if (!key) throw new Error(`${source} contains an empty message key.`);
-      if (Object.prototype.hasOwnProperty.call(output, key)) {
-        throw new Error(`${source} contains duplicate message key "${key}".`);
-      }
-      output[key] = value;
-      return;
-    }
-    if (!isPlainObject(value)) {
-      const key = segments.join(".") || "<root>";
-      throw new Error(`${source} message "${key}" must be a string or nested object.`);
-    }
-    for (const [key, nested] of Object.entries(value)) {
-      if (!key.trim()) throw new Error(`${source} contains an empty message key.`);
-      visit(nested, [...segments, key]);
-    }
-  }, "visit");
-  visit(input, []);
-  return output;
-}
-__name(flattenFarmI18nCatalog, "flattenFarmI18nCatalog");
-function analyzeFarmI18nMessage(message, label = "message") {
-  let ast;
-  try {
-    ast = parse(message, { captureLocation: false });
-  } catch (error) {
-    throw new Error(`Invalid ICU syntax in ${label}: ${messageOf(error)}`);
-  }
-  const signature = {};
-  collectArguments(ast, signature, label);
-  return signature;
-}
-__name(analyzeFarmI18nMessage, "analyzeFarmI18nMessage");
-function validateFarmI18nCatalogs(config, catalogs, signatures) {
-  const referenceKeys = Object.keys(catalogs[config.defaultLocale] || {}).sort();
-  for (const locale of config.locales) {
-    const catalog = catalogs[locale] || {};
-    const localeKeys = Object.keys(catalog).sort();
-    const missing = referenceKeys.filter(
-      (key) => !Object.prototype.hasOwnProperty.call(catalog, key)
-    );
-    const extra = localeKeys.filter(
-      (key) => !Object.prototype.hasOwnProperty.call(signatures, key)
-    );
-    if (config.strict && (missing.length > 0 || extra.length > 0)) {
-      const details = [
-        missing.length ? `missing: ${missing.join(", ")}` : "",
-        extra.length ? `extra: ${extra.join(", ")}` : ""
-      ].filter(Boolean).join("; ");
-      throw new Error(
-        `Farm i18n catalog "${locale}" does not match the default catalog (${details}).`
-      );
-    }
-    for (const [key, message] of Object.entries(catalog)) {
-      const actual = analyzeFarmI18nMessage(message, `${locale}:${key}`);
-      const expected = signatures[key];
-      if (!expected || sameSignature(expected, actual)) continue;
-      throw new Error(
-        `Farm i18n message "${key}" in "${locale}" uses different variables than "${config.defaultLocale}".`
-      );
-    }
-  }
-}
-__name(validateFarmI18nCatalogs, "validateFarmI18nCatalogs");
-function collectArguments(elements, signature, label) {
-  for (const element of elements) {
-    switch (element.type) {
-      case TYPE.argument:
-        addArgument(signature, element.value, "string", label);
-        break;
-      case TYPE.number:
-      case TYPE.plural:
-        addArgument(signature, element.value, "number", label);
-        break;
-      case TYPE.date:
-      case TYPE.time:
-        addArgument(signature, element.value, "date", label);
-        break;
-      case TYPE.select:
-        addArgument(signature, element.value, "select", label);
-        break;
-      case TYPE.tag:
-        addArgument(signature, element.value, "rich", label);
-        collectArguments(element.children, signature, label);
-        break;
-    }
-    if (element.type === TYPE.plural || element.type === TYPE.select) {
-      for (const option of Object.values(element.options)) {
-        collectArguments(option.value, signature, label);
-      }
-    }
-  }
-}
-__name(collectArguments, "collectArguments");
-function addArgument(signature, name, kind, label) {
-  const existing = signature[name];
-  if (existing && existing !== kind) {
-    throw new Error(`Farm i18n ${label} uses variable "${name}" as both ${existing} and ${kind}.`);
-  }
-  signature[name] = kind;
-}
-__name(addArgument, "addArgument");
-function sameSignature(expected, actual) {
-  const expectedEntries = Object.entries(expected).sort(([a], [b]) => a.localeCompare(b));
-  const actualEntries = Object.entries(actual).sort(([a], [b]) => a.localeCompare(b));
-  return JSON.stringify(expectedEntries) === JSON.stringify(actualEntries);
-}
-__name(sameSignature, "sameSignature");
-function isPlainObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-__name(isPlainObject, "isPlainObject");
-function messageOf(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(messageOf, "messageOf");
-
-export {
-  readFarmI18nCatalogs
-};