@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-AELACLOB.mjs

@@ -0,0 +1,47 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/theme/config.ts
+var DEFAULT_FARM_THEME_STORAGE_KEY = "farm-theme";
+var STORAGE_KEY_PATTERN = /^[A-Za-z0-9._-]+$/;
+function resolveFarmThemeConfig(config, basePath = "/") {
+  if (config && "enabled" in config) {
+    return config;
+  }
+  if (!config) {
+    return {
+      enabled: false,
+      default: "system",
+      storageKey: DEFAULT_FARM_THEME_STORAGE_KEY,
+      cookiePath: normalizeCookiePath(basePath)
+    };
+  }
+  const storageKey = config.storageKey?.trim() || DEFAULT_FARM_THEME_STORAGE_KEY;
+  if (!STORAGE_KEY_PATTERN.test(storageKey)) {
+    throw new Error(
+      "theme.storageKey may only contain letters, numbers, dots, underscores, and hyphens."
+    );
+  }
+  const defaultTheme = config.default ?? "system";
+  if (defaultTheme !== "light" && defaultTheme !== "dark" && defaultTheme !== "system") {
+    throw new Error('theme.default must be "light", "dark", or "system".');
+  }
+  return {
+    enabled: true,
+    default: defaultTheme,
+    storageKey,
+    cookiePath: normalizeCookiePath(basePath)
+  };
+}
+__name(resolveFarmThemeConfig, "resolveFarmThemeConfig");
+function normalizeCookiePath(basePath) {
+  const normalized = `/${basePath}`.replace(/\/{2,}/g, "/");
+  if (normalized === "/") return normalized;
+  return normalized.replace(/\/$/, "");
+}
+__name(normalizeCookiePath, "normalizeCookiePath");
+
+export {
+  resolveFarmThemeConfig
+};

package/dist/chunk-AHGECQEW.mjs

@@ -0,0 +1,49 @@
+import {
+  compiledFarmI18nMessages,
+  getFarmI18nClientState
+} from "./chunk-F2SE2VDO.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/i18n/client-runtime.ts
+import IntlMessageFormat from "intl-messageformat";
+var readOwnMessage = /* @__PURE__ */ __name((messages, key) => Object.prototype.hasOwnProperty.call(messages, key) ? messages[key] : void 0, "readOwnMessage");
+var translate = /* @__PURE__ */ __name((key, values, rich = false) => {
+  const snapshot = requireSnapshot();
+  const message = readOwnMessage(snapshot.messages, key);
+  if (message === void 0) return key;
+  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
+  let formatter = compiledFarmI18nMessages.get(cacheKey);
+  if (!formatter) {
+    formatter = new IntlMessageFormat(message, snapshot.locale);
+    compiledFarmI18nMessages.set(cacheKey, formatter);
+  }
+  const result = formatter.format(values);
+  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+  }
+  return Array.isArray(result) ? result.join("") : String(result);
+}, "translate");
+var t = /* @__PURE__ */ __name(((key, values) => translate(key, values)), "t");
+t.rich = (key, values) => translate(key, values, true);
+t.raw = (key) => readOwnMessage(requireSnapshot().messages, key) ?? key;
+t.has = (key) => Object.prototype.hasOwnProperty.call(requireSnapshot().messages, key);
+function createFarmClientTranslator() {
+  return ((key, ...args) => t(key, ...args));
+}
+__name(createFarmClientTranslator, "createFarmClientTranslator");
+function requireSnapshot() {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot) {
+    throw new Error("Farm i18n is not configured or has not been hydrated.");
+  }
+  return snapshot;
+}
+__name(requireSnapshot, "requireSnapshot");
+
+export {
+  t,
+  createFarmClientTranslator
+};

package/dist/chunk-AI7QMY7O.cjs

@@ -0,0 +1,41 @@
+"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/request-cookies.ts
+function parseRequestCookieHeader(header) {
+  if (!_optionalChain([header, 'optionalAccess', _ => _.trim, 'call', _2 => _2()])) return [];
+  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) {
+      return {
+        name: decodeCookieName(part),
+        value: ""
+      };
+    }
+    return {
+      name: decodeCookieName(part.slice(0, separatorIndex).trim()),
+      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
+    };
+  }).filter((cookie) => cookie.name.length > 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRequestCookieHeader, "parseRequestCookieHeader");
+var RESERVED_PREFIX = /^__(host|secure)-/i;
+function decodeCookieName(raw) {
+  const decoded = decodeCookiePart(raw);
+  return RESERVED_PREFIX.test(decoded) && !RESERVED_PREFIX.test(raw) ? raw : decoded;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodeCookieName, "decodeCookieName");
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch (e) {
+    return value;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodeCookiePart, "decodeCookiePart");
+
+
+
+
+exports.parseRequestCookieHeader = parseRequestCookieHeader; exports.decodeCookieName = decodeCookieName;

package/dist/chunk-AJQTP4OO.mjs

@@ -0,0 +1,212 @@
+import {
+  VERCEL_OG_INSTALL_HINT,
+  isMissingPackageError,
+  withOptionalPeerCause
+} from "./chunk-YOZYCI6Z.mjs";
+import {
+  omitFarmResponseBody
+} from "./chunk-5WI2S4CO.mjs";
+import {
+  matchesFarmIfNoneMatch
+} from "./chunk-ZMMBIVQM.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/metadata-image.ts
+var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
+var REACT_TRANSITIONAL_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
+var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+function isResponse(value) {
+  return typeof Response !== "undefined" && (value instanceof Response || Boolean(
+    value && typeof value === "object" && typeof value.arrayBuffer === "function" && value.headers
+  ));
+}
+__name(isResponse, "isResponse");
+function isThenable(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+__name(isThenable, "isThenable");
+function isReactElement(value) {
+  if (!value || typeof value !== "object") return false;
+  const marker = value.$$typeof;
+  return marker === REACT_ELEMENT_TYPE || marker === REACT_TRANSITIONAL_ELEMENT_TYPE;
+}
+__name(isReactElement, "isReactElement");
+async function prepareMetadataImageNode(node) {
+  if (isThenable(node)) {
+    return prepareMetadataImageNode(await node);
+  }
+  if (Array.isArray(node)) {
+    return Promise.all(node.map((child) => prepareMetadataImageNode(child)));
+  }
+  if (!isReactElement(node)) {
+    return node;
+  }
+  const element = node;
+  const type = element.type;
+  const props = element.props || {};
+  if (typeof type === "function") {
+    if (type.prototype?.isReactComponent) {
+      throw new Error(
+        "Metadata image components must be stateless function components; React class components are not supported."
+      );
+    }
+    return prepareMetadataImageNode(await type(props));
+  }
+  if (type && typeof type === "object") {
+    if (type.$$typeof === REACT_MEMO_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      return prepareMetadataImageNode(createElement2(type.type, props));
+    }
+    if (type.$$typeof === REACT_FORWARD_REF_TYPE) {
+      return prepareMetadataImageNode(await type.render(props, null));
+    }
+    if (type.$$typeof === REACT_LAZY_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      let resolvedType;
+      try {
+        resolvedType = type._init(type._payload);
+      } catch (suspension) {
+        if (suspension && typeof suspension.then === "function") {
+          await suspension;
+          resolvedType = type._init(type._payload);
+        } else {
+          throw suspension;
+        }
+      }
+      return prepareMetadataImageNode(createElement2(resolvedType, props));
+    }
+  }
+  const preparedChildren = await prepareMetadataImageNode(props.children);
+  const preparedProps = { ...props };
+  if (typeof preparedProps.className === "string") {
+    preparedProps.tw = [preparedProps.tw, preparedProps.className].filter(Boolean).join(" ");
+    delete preparedProps.className;
+  }
+  delete preparedProps.children;
+  const { createElement } = await import("react");
+  return createElement(type, {
+    ...preparedProps,
+    key: element.key,
+    children: preparedChildren
+  });
+}
+__name(prepareMetadataImageNode, "prepareMetadataImageNode");
+async function normalizeFonts(fonts) {
+  if (!fonts?.length) return void 0;
+  return Promise.all(
+    fonts.map(async (font) => {
+      const data = await font.data;
+      const arrayBuffer = ArrayBuffer.isView(data) ? toArrayBuffer(data) : data;
+      return { ...font, data: arrayBuffer };
+    })
+  );
+}
+__name(normalizeFonts, "normalizeFonts");
+function resolveCacheControl(revalidate) {
+  if (revalidate === false) {
+    return "public, max-age=31536000, immutable";
+  }
+  if (typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0) {
+    return `public, s-maxage=${Math.floor(revalidate)}, stale-while-revalidate=300`;
+  }
+  return "public, max-age=0, must-revalidate";
+}
+__name(resolveCacheControl, "resolveCacheControl");
+function toArrayBuffer(value) {
+  if (value instanceof ArrayBuffer) return value;
+  const bytes = new Uint8Array(value.byteLength);
+  bytes.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  return bytes.buffer;
+}
+__name(toArrayBuffer, "toArrayBuffer");
+async function createEntityTag(body) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", body);
+  const hash = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 32);
+  return `"${hash}"`;
+}
+__name(createEntityTag, "createEntityTag");
+async function finalizeMetadataImageResponse(body, headers, options) {
+  const responseHeaders = new Headers(headers);
+  const etag = await createEntityTag(body);
+  responseHeaders.set("ETag", etag);
+  responseHeaders.set("Content-Length", String(body.byteLength));
+  responseHeaders.set("X-Content-Type-Options", "nosniff");
+  if (matchesFarmIfNoneMatch(options.ifNoneMatch, etag)) {
+    return new Response(null, { status: 304, headers: responseHeaders });
+  }
+  return new Response(options.method?.toUpperCase() === "HEAD" ? null : body, {
+    status: 200,
+    headers: responseHeaders
+  });
+}
+__name(finalizeMetadataImageResponse, "finalizeMetadataImageResponse");
+async function loadVercelOg() {
+  try {
+    return await import("@vercel/og");
+  } catch (error) {
+    if (!isMissingPackageError(error, "@vercel/og")) throw error;
+    throw withOptionalPeerCause(
+      new Error(
+        `Rendering a metadata image from JSX needs @vercel/og, which is not installed. ${VERCEL_OG_INSTALL_HINT}`
+      ),
+      error
+    );
+  }
+}
+__name(loadVercelOg, "loadVercelOg");
+async function createFarmMetadataImageResponse(value, imageModule, options = {}) {
+  const method = (options.method || "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } });
+  }
+  if (isResponse(value)) {
+    return method === "HEAD" ? omitFarmResponseBody(value) : value;
+  }
+  const cacheControl = resolveCacheControl(imageModule.revalidate);
+  const explicitContentType = imageModule.contentType?.split(";", 1)[0]?.trim().toLowerCase();
+  if (isReactElement(value) && explicitContentType !== "image/svg+xml") {
+    const { ImageResponse } = await loadVercelOg();
+    const element = await prepareMetadataImageNode(value);
+    const response = new ImageResponse(element, {
+      width: imageModule.size?.width || 1200,
+      height: imageModule.size?.height || 630,
+      fonts: await normalizeFonts(imageModule.fonts),
+      emoji: imageModule.emoji,
+      debug: imageModule.debug,
+      headers: { "cache-control": cacheControl }
+    });
+    const headers = new Headers(response.headers);
+    headers.set("Cache-Control", cacheControl);
+    return finalizeMetadataImageResponse(await response.arrayBuffer(), headers, options);
+  }
+  let body;
+  if (typeof value === "string") {
+    body = toArrayBuffer(new TextEncoder().encode(value));
+  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    body = toArrayBuffer(value);
+  } else if (isReactElement(value)) {
+    const { renderToStaticMarkup } = await import("react-dom/server");
+    body = toArrayBuffer(new TextEncoder().encode(renderToStaticMarkup(value)));
+  } else {
+    throw new Error("Metadata image must return a Response, string, bytes, or React element");
+  }
+  return finalizeMetadataImageResponse(
+    body,
+    {
+      "Content-Type": imageModule.contentType || "image/svg+xml; charset=utf-8",
+      "Cache-Control": cacheControl
+    },
+    options
+  );
+}
+__name(createFarmMetadataImageResponse, "createFarmMetadataImageResponse");
+
+export {
+  createFarmMetadataImageResponse
+};

package/dist/chunk-AMDMVWMI.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/font.ts
+function defineLayoutFonts(fonts) {
+  return fonts;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineLayoutFonts, "defineLayoutFonts");
+function resolveFarmLayoutFonts(layouts) {
+  let resolved;
+  for (const layout of layouts) {
+    if (!layout.fonts) continue;
+    resolved = { ...resolved, ...layout.fonts };
+  }
+  return resolved;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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.`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, fontCompilerError, "fontCompilerError");
+function localFont(_options) {
+  return fontCompilerError("localFont");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, localFont, "localFont");
+function remoteFont(_options) {
+  return fontCompilerError("remoteFont");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, remoteFont, "remoteFont");
+
+
+
+
+
+
+exports.defineLayoutFonts = defineLayoutFonts; exports.resolveFarmLayoutFonts = resolveFarmLayoutFonts; exports.localFont = localFont; exports.remoteFont = remoteFont;

package/dist/chunk-ARJWXNQL.cjs

@@ -0,0 +1,256 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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/api/transport.ts
+function multipart(schema) {
+  if (!Object.isExtensible(schema) && !isMultipartSchema(schema)) {
+    throw new TypeError("multipart() requires an extensible schema object");
+  }
+  if (!isMultipartSchema(schema)) {
+    Object.defineProperty(schema, "__farmMultipartSchema", {
+      value: true,
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
+  }
+  return schema;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, multipart, "multipart");
+function isMultipartSchema(value) {
+  return typeof value === "object" && value !== null && value.__farmMultipartSchema === true && typeof value.parse === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isMultipartSchema, "isMultipartSchema");
+function toFormData(values) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(values)) {
+    if (isUnsafeFormKey(key)) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) appendFormValue(formData, key, entry);
+      continue;
+    }
+    appendFormValue(formData, key, value);
+  }
+  return formData;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toFormData, "toFormData");
+function jsonStream(source, init = {}) {
+  const iterator = toAsyncIterator(source);
+  const encoder = new TextEncoder();
+  let finished = false;
+  let cleanup;
+  const closeSource = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (reason) => _nullishCoalesce(cleanup, () => ( (cleanup = Promise.resolve().then(() => _optionalChain([iterator, 'access', _ => _.return, 'optionalCall', _2 => _2(reason)]))))), "closeSource");
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        if (finished) return;
+        try {
+          const next = await iterator.next();
+          if (finished) return;
+          if (next.done) {
+            finished = true;
+            controller.close();
+            return;
+          }
+          const serialized = JSON.stringify(next.value);
+          if (serialized === void 0) {
+            throw new TypeError("Farm JSON stream chunks must be JSON-serializable values");
+          }
+          controller.enqueue(encoder.encode(`${serialized}
+`));
+        } catch (error) {
+          if (finished) return;
+          finished = true;
+          try {
+            await closeSource(error);
+          } catch (e) {
+          }
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        finished = true;
+        await closeSource(reason);
+      }
+    },
+    {
+      // Do not read the next application event until the response consumer
+      // requests another chunk.
+      highWaterMark: 0
+    }
+  );
+  const headers = new Headers(init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/x-ndjson; charset=utf-8");
+  }
+  headers.set("cache-control", _nullishCoalesce(headers.get("cache-control"), () => ( "no-store")));
+  return new Response(body, {
+    ...init,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, jsonStream, "jsonStream");
+function isJSONStreamResponse(response) {
+  const contentType = _nullishCoalesce(_optionalChain([response, 'access', _3 => _3.headers, 'optionalAccess', _4 => _4.get, 'optionalCall', _5 => _5("content-type"), 'optionalAccess', _6 => _6.toLowerCase, 'call', _7 => _7()]), () => ( ""));
+  return contentType.includes("application/x-ndjson") || contentType.includes("application/ndjson");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isJSONStreamResponse, "isJSONStreamResponse");
+function readJSONStream(response) {
+  if (!response.body) {
+    throw new TypeError("Cannot read a JSON stream response without a body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let completed = false;
+  let cancelled = false;
+  let claimed = false;
+  let released = false;
+  const releaseReader = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  }, "releaseReader");
+  const parseLine = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (line) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      completed = true;
+      buffer = "";
+      void reader.cancel(error).catch(() => {
+      });
+      releaseReader();
+      throw error;
+    }
+  }, "parseLine");
+  const readNext = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
+    while (true) {
+      if (cancelled) return { done: true, value: void 0 };
+      const lineEnd = buffer.indexOf("\n");
+      if (lineEnd >= 0) {
+        const line = buffer.slice(0, lineEnd).trim();
+        buffer = buffer.slice(lineEnd + 1);
+        if (!line) continue;
+        return { done: false, value: await parseLine(line) };
+      }
+      if (completed) {
+        const line = buffer.trim();
+        buffer = "";
+        if (!line) {
+          releaseReader();
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: await parseLine(line) };
+      }
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (error) {
+        if (cancelled) return { done: true, value: void 0 };
+        completed = true;
+        buffer = "";
+        releaseReader();
+        throw error;
+      }
+      if (cancelled) return { done: true, value: void 0 };
+      completed = chunk.done;
+      buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+    }
+  }, "readNext");
+  let readQueue = Promise.resolve();
+  const iterator = {
+    next() {
+      const result = readQueue.then(readNext);
+      readQueue = result.then(
+        () => {
+        },
+        () => {
+        }
+      );
+      return result;
+    },
+    async return() {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel();
+        } finally {
+          releaseReader();
+        }
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+  return {
+    response,
+    async cancel(reason) {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel(reason);
+        } finally {
+          releaseReader();
+        }
+      }
+    },
+    [Symbol.asyncIterator]() {
+      if (claimed) {
+        throw new TypeError("Farm API streams can only be consumed once");
+      }
+      claimed = true;
+      return iterator;
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readJSONStream, "readJSONStream");
+function isFarmAPIStream(value) {
+  return typeof value === "object" && value !== null && "response" in value && typeof value.cancel === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmAPIStream, "isFarmAPIStream");
+function appendFormValue(formData, key, value) {
+  if (value === void 0) return;
+  if (value === null) {
+    formData.append(key, "");
+    return;
+  }
+  if (value instanceof Blob) {
+    formData.append(key, value);
+    return;
+  }
+  if (value instanceof Date) {
+    formData.append(key, value.toISOString());
+    return;
+  }
+  formData.append(key, String(value));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendFormValue, "appendFormValue");
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isUnsafeFormKey, "isUnsafeFormKey");
+function toAsyncIterator(source) {
+  if (Symbol.asyncIterator in Object(source)) {
+    return source[Symbol.asyncIterator]();
+  }
+  const iterator = source[Symbol.iterator]();
+  return {
+    next: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => iterator.next(), "next"),
+    return: iterator.return ? async (value) => iterator.return(value) : void 0
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toAsyncIterator, "toAsyncIterator");
+
+
+
+
+
+
+
+
+
+exports.multipart = multipart; exports.isMultipartSchema = isMultipartSchema; exports.toFormData = toFormData; exports.jsonStream = jsonStream; exports.isJSONStreamResponse = isJSONStreamResponse; exports.readJSONStream = readJSONStream; exports.isFarmAPIStream = isFarmAPIStream;