@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-D4MRNBVF.cjs

@@ -0,0 +1,1462 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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 _chunkPZXYAWYGcjs = require('./chunk-PZXYAWYG.cjs');
+
+
+
+
+
+
+var _chunk3OJNNCDLcjs = require('./chunk-3OJNNCDL.cjs');
+
+
+var _chunkEOXPRC2Ccjs = require('./chunk-EOXPRC2C.cjs');
+
+
+var _chunk53EHWHT2cjs = require('./chunk-53EHWHT2.cjs');
+
+
+
+var _chunkRI3EVPKDcjs = require('./chunk-RI3EVPKD.cjs');
+
+
+
+
+var _chunkQQ44FYROcjs = require('./chunk-QQ44FYRO.cjs');
+
+
+var _chunkI2BYNELAcjs = require('./chunk-I2BYNELA.cjs');
+
+
+var _chunkJGAE5XPLcjs = require('./chunk-JGAE5XPL.cjs');
+
+
+
+
+
+
+var _chunkUZCMMJJTcjs = require('./chunk-UZCMMJJT.cjs');
+
+
+
+
+var _chunkD22BUQKWcjs = require('./chunk-D22BUQKW.cjs');
+
+// src/mutation-client.ts
+var _react = require('react');
+
+// src/client-network-status.ts
+function isNavigatorOnline() {
+  if (typeof navigator === "undefined" || typeof navigator.onLine !== "boolean") return true;
+  return navigator.onLine;
+}
+function subscribeOnline(listener) {
+  if (typeof window === "undefined") return () => {
+  };
+  window.addEventListener("online", listener);
+  return () => window.removeEventListener("online", listener);
+}
+
+// src/mutation-client.ts
+function useMutation(target, options = {}) {
+  return useMutationLifecycle(target, options).mutation;
+}
+function useMutationLifecycle(target, options = {}) {
+  const initialData = _nullishCoalesce(options.initialData, () => ( null));
+  const optionsRef = _react.useRef.call(void 0, options);
+  const targetRef = _react.useRef.call(void 0, target);
+  const requestIdRef = _react.useRef.call(void 0, 0);
+  const lastResetIdRef = _react.useRef.call(void 0, 0);
+  const initialState = {
+    pendingCount: 0,
+    pausedCount: 0,
+    status: "idle",
+    data: initialData,
+    error: null,
+    variables: void 0
+  };
+  const stateRef = _react.useRef.call(void 0, initialState);
+  const resetWakersRef = _react.useRef.call(void 0, /* @__PURE__ */ new Set());
+  const [state, setState] = _react.useState.call(void 0, initialState);
+  optionsRef.current = options;
+  targetRef.current = target;
+  const setMutationState = _react.useCallback.call(void 0, 
+    (value) => {
+      const next = typeof value === "function" ? value(stateRef.current) : value;
+      stateRef.current = next;
+      setState(next);
+    },
+    []
+  );
+  const waitForReconnect = _react.useCallback.call(void 0, 
+    async (requestId) => {
+      while (!isNavigatorOnline()) {
+        if (requestId < lastResetIdRef.current) return;
+        setMutationState((current) => ({ ...current, pausedCount: current.pausedCount + 1 }));
+        try {
+          await new Promise((resolve) => {
+            const wake = () => {
+              unsubscribe();
+              resetWakersRef.current.delete(wake);
+              resolve();
+            };
+            const unsubscribe = subscribeOnline(wake);
+            resetWakersRef.current.add(wake);
+          });
+        } finally {
+          setMutationState((current) => ({
+            ...current,
+            pausedCount: Math.max(0, current.pausedCount - 1)
+          }));
+        }
+      }
+    },
+    [setMutationState]
+  );
+  const mutatePreparedAsync = _react.useCallback.call(void 0, 
+    async (prepare) => {
+      const requestId = ++requestIdRef.current;
+      const currentOptions = optionsRef.current;
+      const previousData = stateRef.current.data;
+      let variables;
+      let preparationFailed = false;
+      let preparationError;
+      try {
+        variables = prepare();
+      } catch (error) {
+        preparationFailed = true;
+        preparationError = error;
+      }
+      const optimisticData = preparationFailed ? void 0 : _optionalChain([currentOptions, 'access', _ => _.optimistic, 'optionalCall', _2 => _2({ variables, current: previousData })]);
+      const hasOptimisticData = optimisticData !== void 0;
+      setMutationState((current) => {
+        if (requestId < lastResetIdRef.current) return current;
+        const pendingCount = current.pendingCount + 1;
+        if (requestId !== requestIdRef.current) return { ...current, pendingCount };
+        return {
+          pendingCount,
+          pausedCount: current.pausedCount,
+          status: "pending",
+          data: hasOptimisticData ? optimisticData : currentOptions.resetOnMutate === false ? current.data : null,
+          error: null,
+          variables
+        };
+      });
+      const mutationTarget = targetRef.current;
+      const isAPITarget = _chunk3OJNNCDLcjs.isAPIRouteRef.call(void 0, mutationTarget);
+      const sharedOptimistic = !preparationFailed && !isAPITarget ? _optionalChain([currentOptions, 'access', _3 => _3.request, 'optionalAccess', _4 => _4.optimistic]) : void 0;
+      const sharedSnapshots = _optionalChain([sharedOptimistic, 'optionalAccess', _5 => _5.update, 'optionalAccess', _6 => _6.length]) ? _chunk3OJNNCDLcjs.applyServerFnOptimisticUpdates.call(void 0, sharedOptimistic.update) : [];
+      try {
+        if (preparationFailed) throw preparationError;
+        let data;
+        while (true) {
+          if (currentOptions.networkMode === "online") {
+            await waitForReconnect(requestId);
+            if (requestId < lastResetIdRef.current) {
+              throw new Error("Mutation reset while waiting for reconnection");
+            }
+          }
+          try {
+            const rawResult = isAPITarget ? await mutationTarget(variables, currentOptions.request) : await _chunkPZXYAWYGcjs.invokeMutationWithRetry.call(void 0, 
+              () => targetRef.current(variables),
+              _optionalChain([currentOptions, 'access', _7 => _7.request, 'optionalAccess', _8 => _8.retry]),
+              // A reset disowns this submission; stop scheduling retries then.
+              () => requestId >= lastResetIdRef.current
+            );
+            data = unwrapMutationResult(rawResult, isAPITarget);
+            break;
+          } catch (cause) {
+            if (currentOptions.networkMode === "online" && !isNavigatorOnline() && requestId >= lastResetIdRef.current && isConnectivityFailure(cause)) {
+              continue;
+            }
+            throw cause;
+          }
+        }
+        _chunk3OJNNCDLcjs.settleServerFnOptimisticUpdates.call(void 0, sharedSnapshots, "commit");
+        if (!isAPITarget && _optionalChain([currentOptions, 'access', _9 => _9.request, 'optionalAccess', _10 => _10.invalidate])) {
+          for (const key of _chunk3OJNNCDLcjs.resolveServerFnInvalidateTargets.call(void 0, currentOptions.request.invalidate)) {
+            _chunkUZCMMJJTcjs.notifyFarmCacheInvalidation.call(void 0, key);
+          }
+        }
+        const isLatestRequest = requestId === requestIdRef.current;
+        setMutationState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount
+            };
+          }
+          return {
+            pendingCount,
+            pausedCount: current.pausedCount,
+            status: "success",
+            data,
+            error: null,
+            variables
+          };
+        });
+        if (isLatestRequest) {
+          _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, currentOptions.onSuccess, [data, variables], "Mutation onSuccess");
+          if (requestId === requestIdRef.current) {
+            _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, 
+              currentOptions.onSettled,
+              [data, null, variables],
+              "Mutation onSettled"
+            );
+          }
+        }
+        return data;
+      } catch (cause) {
+        _chunk3OJNNCDLcjs.settleServerFnOptimisticUpdates.call(void 0, 
+          sharedSnapshots,
+          _optionalChain([sharedOptimistic, 'optionalAccess', _11 => _11.rollbackOnError]) ? "rollback" : "invalidate"
+        );
+        const error = normalizeMutationError(cause);
+        const isLatestRequest = requestId === requestIdRef.current;
+        setMutationState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
+          const pendingCount = Math.max(0, current.pendingCount - 1);
+          if (!isLatestRequest) {
+            return {
+              ...current,
+              pendingCount
+            };
+          }
+          return {
+            pendingCount,
+            pausedCount: current.pausedCount,
+            status: "error",
+            data: hasOptimisticData && currentOptions.rollbackOnError ? previousData : currentOptions.resetOnMutate === false ? current.data : null,
+            error,
+            variables
+          };
+        });
+        if (isLatestRequest) {
+          _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, currentOptions.onError, [error, variables], "Mutation onError");
+          if (requestId === requestIdRef.current) {
+            _chunkEOXPRC2Ccjs.notifyClientObserver.call(void 0, 
+              currentOptions.onSettled,
+              [null, error, variables],
+              "Mutation onSettled"
+            );
+          }
+        }
+        throw error;
+      }
+    },
+    [setMutationState, waitForReconnect]
+  );
+  const mutateAsync = _react.useCallback.call(void 0, 
+    (variables) => mutatePreparedAsync(() => variables),
+    [mutatePreparedAsync]
+  );
+  const mutate = _react.useCallback.call(void 0, 
+    (variables) => {
+      void mutateAsync(variables).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  const reset = _react.useCallback.call(void 0, () => {
+    lastResetIdRef.current = ++requestIdRef.current;
+    setMutationState({
+      pendingCount: 0,
+      pausedCount: 0,
+      status: "idle",
+      data: _nullishCoalesce(optionsRef.current.initialData, () => ( null)),
+      error: null,
+      variables: void 0
+    });
+    const wakers = Array.from(resetWakersRef.current);
+    resetWakersRef.current.clear();
+    for (const wake of wakers) wake();
+  }, [setMutationState]);
+  const mutation = _react.useMemo.call(void 0, 
+    () => ({
+      pending: state.pendingCount > 0,
+      paused: state.pausedCount > 0,
+      status: state.status,
+      data: state.data,
+      error: state.error,
+      variables: state.variables,
+      mutate,
+      mutateAsync,
+      reset
+    }),
+    [
+      mutate,
+      mutateAsync,
+      reset,
+      state.data,
+      state.error,
+      state.pausedCount,
+      state.pendingCount,
+      state.status,
+      state.variables
+    ]
+  );
+  return { mutation, mutatePreparedAsync };
+}
+function isConnectivityFailure(error) {
+  if (error instanceof TypeError) return true;
+  const code = _optionalChain([error, 'optionalAccess', _12 => _12.code]);
+  return code === "network_error" || code === "timeout";
+}
+function unwrapMutationResult(result, apiRoute) {
+  if (!apiRoute) return result;
+  const apiResult = result;
+  if (apiResult.error) {
+    throw apiResult.error;
+  }
+  return apiResult.data;
+}
+function normalizeMutationError(error) {
+  if (error instanceof Error) return error;
+  const normalized = new Error(typeof error === "string" ? error : "Mutation failed");
+  normalized.cause = error;
+  return normalized;
+}
+
+// src/fetcher-client.tsx
+
+
+
+
+
+
+
+var FetcherInputError = class extends Error {
+  constructor(cause) {
+    super(
+      cause instanceof Error ? cause.message : typeof cause === "string" ? cause : "Could not prepare form input"
+    );
+    this.name = "FetcherInputError";
+    this.code = "input_error";
+    this.status = 0;
+    this.data = void 0;
+    this.cause = cause;
+  }
+};
+var formDataContexts = /* @__PURE__ */ new WeakMap();
+function useFetcher(target, options = {}) {
+  const targetRef = _react.useRef.call(void 0, target);
+  const optionsRef = _react.useRef.call(void 0, options);
+  const submissionIdRef = _react.useRef.call(void 0, 0);
+  const [formData, setFormData] = _react.useState.call(void 0, null);
+  const { mutation, mutatePreparedAsync } = useMutationLifecycle(target, options);
+  targetRef.current = target;
+  optionsRef.current = options;
+  const submitAsync = _react.useCallback.call(void 0, 
+    async (input) => {
+      const submissionId = ++submissionIdRef.current;
+      const submittedFormData = isFormData(input) ? input : null;
+      setFormData(submittedFormData);
+      try {
+        return await mutatePreparedAsync(() => {
+          try {
+            return submittedFormData ? mapFetcherFormData(targetRef.current, submittedFormData, optionsRef.current) : input;
+          } catch (error) {
+            throw new FetcherInputError(error);
+          }
+        });
+      } finally {
+        if (submissionId === submissionIdRef.current) {
+          setFormData(null);
+        }
+      }
+    },
+    [mutatePreparedAsync]
+  );
+  const submit = _react.useCallback.call(void 0, 
+    (input) => {
+      void submitAsync(input).catch(() => {
+      });
+    },
+    [submitAsync]
+  );
+  const Form = _react.useMemo.call(void 0, () => {
+    const FetcherForm = ({ action, method, encType, onSubmit, ...props }) => {
+      const targetValue = targetRef.current;
+      const metadata = _chunk3OJNNCDLcjs.getAPIRouteRefMetadata.call(void 0, targetValue);
+      const nativeAction = _nullishCoalesce(action, () => ( resolveFetcherFormAction(targetValue, metadata)));
+      const nativeMethod = _nullishCoalesce(method, () => ( (metadata && (metadata.method === "GET" || metadata.method === "POST") ? metadata.method.toLowerCase() : metadata ? "post" : void 0)));
+      const functionAction = typeof nativeAction === "function";
+      const handleSubmit = (event) => {
+        _optionalChain([onSubmit, 'optionalCall', _13 => _13(event)]);
+        if (event.defaultPrevented) return;
+        event.preventDefault();
+        const submitter = getSubmitter(event);
+        const nextFormData = createSubmitterFormData(event.currentTarget, submitter);
+        formDataContexts.set(nextFormData, {
+          form: event.currentTarget,
+          submitter
+        });
+        void submitAsync(nextFormData).catch(() => {
+        });
+      };
+      return _react.createElement.call(void 0, "form", {
+        ...props,
+        action: nativeAction,
+        method: functionAction ? void 0 : nativeMethod,
+        encType: functionAction ? void 0 : encType,
+        onSubmit: handleSubmit
+      });
+    };
+    FetcherForm.displayName = "FetcherForm";
+    return FetcherForm;
+  }, [submitAsync]);
+  const reset = _react.useCallback.call(void 0, () => {
+    submissionIdRef.current += 1;
+    setFormData(null);
+    mutation.reset();
+  }, [mutation.reset]);
+  return _react.useMemo.call(void 0, 
+    () => ({
+      state: mutation.pending ? "submitting" : "idle",
+      status: mutation.status,
+      pending: mutation.pending,
+      paused: mutation.paused,
+      data: mutation.data,
+      error: mutation.error,
+      variables: mutation.variables,
+      formData,
+      submit,
+      submitAsync,
+      Form,
+      reset
+    }),
+    [
+      Form,
+      formData,
+      mutation.data,
+      mutation.error,
+      mutation.paused,
+      mutation.pending,
+      mutation.status,
+      mutation.variables,
+      reset,
+      submit,
+      submitAsync
+    ]
+  );
+}
+function mapFetcherFormData(target, formData, options) {
+  const context = _nullishCoalesce(formDataContexts.get(formData), () => ( { form: null, submitter: null }));
+  if (options.mapFormData) {
+    return options.mapFormData(formData, context);
+  }
+  if (!_chunk3OJNNCDLcjs.isAPIRouteRef.call(void 0, target)) {
+    return formData;
+  }
+  const method = _optionalChain([_chunk3OJNNCDLcjs.getAPIRouteRefMetadata.call(void 0, target), 'optionalAccess', _14 => _14.method]);
+  const query = method === "GET" || method === "HEAD";
+  const encoding = _nullishCoalesce(_optionalChain([context, 'access', _15 => _15.submitter, 'optionalAccess', _16 => _16.getAttribute, 'call', _17 => _17("formenctype")]), () => ( _optionalChain([context, 'access', _18 => _18.form, 'optionalAccess', _19 => _19.enctype])));
+  if (!query && (_optionalChain([encoding, 'optionalAccess', _20 => _20.toLowerCase, 'call', _21 => _21()]) === "multipart/form-data" || Array.from(formData.values()).some((value) => typeof value !== "string"))) {
+    const body = new FormData();
+    for (const [key, value] of formData) {
+      if (!isUnsafeFormKey(key)) body.append(key, value);
+    }
+    return { body };
+  }
+  const values = formDataToObject(formData);
+  return query ? { query: values } : { body: values };
+}
+function resolveFetcherFormAction(target, metadata) {
+  if (!metadata) return isProgressiveFormAction(target) ? target : void 0;
+  if (metadata.sameOrigin) return metadata.path;
+  return new URL(metadata.path, metadata.baseURL).href;
+}
+function formDataToObject(formData) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of formData.entries()) {
+    if (isUnsafeFormKey(key)) continue;
+    const current = output[key];
+    if (current === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      output[key] = [current, value];
+    }
+  }
+  return output;
+}
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function createSubmitterFormData(form, submitter) {
+  try {
+    return new FormData(form, submitter);
+  } catch (e2) {
+    const formData = new FormData(form);
+    const candidate = submitter;
+    if (candidate && !candidate.disabled && candidate.name) {
+      formData.append(candidate.name, _nullishCoalesce(candidate.value, () => ( "")));
+    }
+    return formData;
+  }
+}
+function getSubmitter(event) {
+  const nativeEvent = event.nativeEvent;
+  return nativeEvent.submitter instanceof HTMLElement ? nativeEvent.submitter : null;
+}
+function isProgressiveFormAction(target) {
+  const candidate = target;
+  return candidate.__farmServerFn === true || typeof candidate.$$FORM_ACTION === "function" || candidate.$$typeof === /* @__PURE__ */ Symbol.for("react.server.reference");
+}
+function isFormData(value) {
+  if (!value || typeof value !== "object") return false;
+  return typeof FormData !== "undefined" && value instanceof FormData || Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+
+// src/cache-invalidation-broadcast.ts
+var FARM_CACHE_INVALIDATION_CHANNEL = "farm:cache-invalidation";
+var FARM_CACHE_INVALIDATION_BRIDGE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationBridge");
+var bridgeGlobal = globalThis;
+function enableCrossTabCacheInvalidation(options = {}) {
+  if (typeof BroadcastChannel !== "function") return () => {
+  };
+  const channelName = _nullishCoalesce(options.channelName, () => ( FARM_CACHE_INVALIDATION_CHANNEL));
+  const existing = bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE];
+  let bridge;
+  if (existing) {
+    if (existing.channelName !== channelName) {
+      throw new Error(
+        `Cross-tab cache invalidation is already enabled on channel "${existing.channelName}".`
+      );
+    }
+    existing.refCount += 1;
+    bridge = existing;
+  } else {
+    bridge = createBridge(channelName);
+    bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] = bridge;
+  }
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    bridge.refCount -= 1;
+    if (bridge.refCount === 0) {
+      bridge.teardown();
+      if (bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] === bridge) {
+        bridgeGlobal[FARM_CACHE_INVALIDATION_BRIDGE] = void 0;
+      }
+    }
+  };
+}
+function createBridge(channelName) {
+  const channel = new BroadcastChannel(channelName);
+  let applyingRemote = false;
+  let pending = [];
+  let flushScheduled = false;
+  let closed = false;
+  const flush = () => {
+    flushScheduled = false;
+    if (closed || pending.length === 0) return;
+    const encoded = _chunkUZCMMJJTcjs.encodeFarmCacheInvalidations.call(void 0, pending);
+    pending = [];
+    if (encoded !== null) channel.postMessage(encoded);
+  };
+  const unsubscribe = _chunkUZCMMJJTcjs.subscribeFarmCacheInvalidation.call(void 0, (key, source) => {
+    if (applyingRemote || source !== "local" || closed) return;
+    pending.push(key);
+    if (!flushScheduled) {
+      flushScheduled = true;
+      queueMicrotask(flush);
+    }
+  });
+  channel.onmessage = (event) => {
+    const keys = _chunkUZCMMJJTcjs.decodeFarmCacheInvalidations.call(void 0, 
+      typeof event.data === "string" ? event.data : void 0
+    );
+    if (keys.length === 0) return;
+    applyingRemote = true;
+    try {
+      for (const key of keys) _chunkUZCMMJJTcjs.notifyFarmCacheInvalidation.call(void 0, key, "broadcast");
+    } finally {
+      applyingRemote = false;
+    }
+  };
+  return {
+    channelName,
+    refCount: 1,
+    teardown() {
+      closed = true;
+      pending = [];
+      unsubscribe();
+      channel.onmessage = null;
+      channel.close();
+    }
+  };
+}
+
+// src/cache-invalidation-event-source.ts
+var FARM_LIVE_CACHE_INVALIDATION_CONNECTIONS = /* @__PURE__ */ Symbol.for(
+  "farm.liveCacheInvalidationConnections"
+);
+var connectionGlobal = globalThis;
+function getConnections() {
+  return _nullishCoalesce(connectionGlobal[FARM_LIVE_CACHE_INVALIDATION_CONNECTIONS], () => ( (connectionGlobal[FARM_LIVE_CACHE_INVALIDATION_CONNECTIONS] = /* @__PURE__ */ new Map())));
+}
+function enableLiveCacheInvalidation(options) {
+  if (typeof EventSource !== "function") return () => {
+  };
+  const baseUrl = typeof location === "object" ? location.href : void 0;
+  const url = baseUrl ? new URL(String(options.url), baseUrl).href : String(options.url);
+  const key = `${url}\0${options.withCredentials === true ? "include" : "same-origin"}`;
+  const connections = getConnections();
+  let connection = connections.get(key);
+  if (connection) {
+    connection.refCount += 1;
+  } else {
+    const source = new EventSource(url, {
+      withCredentials: options.withCredentials === true
+    });
+    connection = { refCount: 1, source };
+    source.onmessage = (event) => {
+      const keys = _chunkUZCMMJJTcjs.decodeFarmCacheInvalidations.call(void 0, event.data);
+      _chunkUZCMMJJTcjs.applyFarmCacheInvalidations.call(void 0, keys, "live");
+    };
+    connections.set(key, connection);
+  }
+  const claimedConnection = connection;
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    claimedConnection.refCount -= 1;
+    if (claimedConnection.refCount > 0) return;
+    claimedConnection.source.onmessage = null;
+    claimedConnection.source.close();
+    if (connections.get(key) === claimedConnection) connections.delete(key);
+  };
+}
+
+// src/client-cache-persistence.ts
+var FARM_CLIENT_CACHE_PERSIST_VERSION = "1";
+function defineClientCacheAdapter(adapter) {
+  for (const method of ["keys", "get", "set", "delete", "clear"]) {
+    if (typeof _optionalChain([adapter, 'optionalAccess', _22 => _22[method]]) !== "function") {
+      throw new TypeError(
+        `defineClientCacheAdapter expects a "${method}" method. Implement keys/get/set/delete/clear over your storage.`
+      );
+    }
+  }
+  return adapter;
+}
+function storageClientCacheAdapter(storage, options = {}) {
+  if (!storage || typeof storage.getItem !== "function" || typeof storage.setItem !== "function" || typeof storage.removeItem !== "function") {
+    throw new TypeError("storageClientCacheAdapter expects a compatible key-value client.");
+  }
+  const base = _nullishCoalesce(options.base, () => ( "farm-client-cache"));
+  const entryKey = (key) => `${base}:${key}`;
+  const enumerate = _nullishCoalesce(_optionalChain([storage, 'access', _23 => _23.getKeys, 'optionalAccess', _24 => _24.bind, 'call', _25 => _25(storage)]), () => ( _optionalChain([storage, 'access', _26 => _26.keys, 'optionalAccess', _27 => _27.bind, 'call', _28 => _28(storage)])));
+  return {
+    async keys() {
+      if (!enumerate) return [];
+      const keys = await enumerate(base);
+      const prefix = `${base}:`;
+      return keys.filter((key) => key.startsWith(prefix)).map((key) => key.slice(prefix.length));
+    },
+    async get(key) {
+      return await _asyncNullishCoalesce(await storage.getItem(entryKey(key)), async () => ( null));
+    },
+    async set(key, entry) {
+      await storage.setItem(entryKey(key), entry);
+    },
+    async delete(key) {
+      await storage.removeItem(entryKey(key));
+    },
+    async clear() {
+      if (storage.clear) {
+        await storage.clear(base);
+        return;
+      }
+      if (!enumerate) return;
+      const prefix = `${base}:`;
+      for (const key of await enumerate(base)) {
+        if (key.startsWith(prefix)) await storage.removeItem(key);
+      }
+    }
+  };
+}
+var activeEngine;
+function reportPersistenceFailure(error) {
+  const report = typeof reportError === "function" ? reportError : console.error;
+  if (error instanceof Error) {
+    report(error);
+    return;
+  }
+  const normalized = new Error("Client cache persistence failed");
+  normalized.cause = error;
+  report(normalized);
+}
+function disableEngine(engine, error) {
+  if (engine.disabled) return;
+  engine.disabled = true;
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+  if (engine.flushTimer !== void 0) {
+    clearTimeout(engine.flushTimer);
+    engine.flushTimer = void 0;
+  }
+  reportPersistenceFailure(error);
+}
+function scheduleFlush(engine) {
+  if (engine.disabled || engine.flushTimer !== void 0) return;
+  const timer = setTimeout(() => {
+    engine.flushTimer = void 0;
+    void flushEngine(engine);
+  }, engine.flushDelayMs);
+  _optionalChain([timer, 'access', _29 => _29.unref, 'optionalCall', _30 => _30()]);
+  engine.flushTimer = timer;
+}
+async function flushEngine(engine) {
+  if (engine.flushing) return engine.flushing;
+  if (engine.disabled || engine.clearing) return;
+  if (engine.pendingSets.size === 0 && engine.pendingDeletes.size === 0) return;
+  const run = (async () => {
+    while (!engine.disabled && !engine.clearing && (engine.pendingSets.size > 0 || engine.pendingDeletes.size > 0)) {
+      const sets = Array.from(engine.pendingSets.entries());
+      const deletes = Array.from(engine.pendingDeletes);
+      engine.pendingSets.clear();
+      engine.pendingDeletes.clear();
+      try {
+        if (sets.length > 0) {
+          if (engine.adapter.setMany) await engine.adapter.setMany(sets);
+          else for (const [key, entry] of sets) await engine.adapter.set(key, entry);
+        }
+        for (const key of deletes) await engine.adapter.delete(key);
+      } catch (error) {
+        disableEngine(engine, error);
+        return;
+      }
+    }
+  })();
+  engine.flushing = run;
+  try {
+    await run;
+  } finally {
+    engine.flushing = void 0;
+  }
+}
+async function hydrateEngine(engine) {
+  const generation = engine.hydrationGeneration;
+  const now = Date.now();
+  const keys = await engine.adapter.keys();
+  if (engine.disabled || generation !== engine.hydrationGeneration) return;
+  if (keys.length === 0) return;
+  const persisted = engine.adapter.getMany ? await engine.adapter.getMany(keys) : await Promise.all(keys.map((key) => engine.adapter.get(key)));
+  if (engine.disabled || generation !== engine.hydrationGeneration) return;
+  engine.hydrating = true;
+  try {
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      const entry = persisted[index];
+      if (engine.disabled || generation !== engine.hydrationGeneration) return;
+      if (!entry || entry.version !== engine.version || entry.gcAt !== void 0 && now >= entry.gcAt) {
+        engine.pendingDeletes.add(key);
+        continue;
+      }
+      if (engine.cache.get(key, now)) continue;
+      engine.cache.set(key, {
+        data: entry.data,
+        updatedAt: entry.updatedAt,
+        staleAt: 0,
+        gcAt: entry.gcAt,
+        status: "success",
+        error: null,
+        persist: true
+      });
+    }
+  } finally {
+    engine.hydrating = false;
+  }
+  if (engine.pendingDeletes.size > 0) scheduleFlush(engine);
+}
+function createSink(engine) {
+  return {
+    onSet(key, entry) {
+      if (engine.disabled || engine.hydrating) return;
+      if (!entry.persist || entry.fetching || entry.error || entry.status === "pending") return;
+      if (engine.persistKey && !engine.persistKey(key)) return;
+      engine.pendingDeletes.delete(key);
+      engine.pendingSets.set(key, {
+        data: entry.data,
+        updatedAt: entry.updatedAt,
+        staleAt: entry.staleAt,
+        gcAt: entry.gcAt,
+        version: engine.version
+      });
+      scheduleFlush(engine);
+    },
+    onDelete(key) {
+      if (engine.disabled) return;
+      engine.pendingSets.delete(key);
+      engine.pendingDeletes.add(key);
+      scheduleFlush(engine);
+    },
+    onClear() {
+      if (engine.disabled || engine.clearing) return;
+      engine.hydrationGeneration += 1;
+      engine.pendingSets.clear();
+      engine.pendingDeletes.clear();
+      void engine.adapter.clear().catch((error) => disableEngine(engine, error));
+    }
+  };
+}
+function initPersistedClientCache(adapter, options = {}) {
+  defineClientCacheAdapter(adapter);
+  disposePersistedClientCache();
+  const engine = {
+    adapter,
+    cache: _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, ),
+    version: options.version ? `${FARM_CLIENT_CACHE_PERSIST_VERSION}:${options.version}` : FARM_CLIENT_CACHE_PERSIST_VERSION,
+    persistKey: options.persistKey,
+    flushDelayMs: _nullishCoalesce(options.flushDelayMs, () => ( 300)),
+    pendingSets: /* @__PURE__ */ new Map(),
+    pendingDeletes: /* @__PURE__ */ new Set(),
+    flushTimer: void 0,
+    hydrating: false,
+    hydrationGeneration: 0,
+    disabled: false,
+    clearing: false,
+    flushing: void 0
+  };
+  activeEngine = engine;
+  engine.cache.attachPersistence(createSink(engine));
+  void hydrateEngine(engine).catch((error) => disableEngine(engine, error));
+  return () => {
+    if (activeEngine !== engine) return;
+    disposePersistedClientCache();
+  };
+}
+function initConfiguredClientCachePersistence(adapterModule, options = {}) {
+  try {
+    const adapter = _optionalChain([adapterModule, 'optionalAccess', _31 => _31.default]);
+    if (!adapter) {
+      throw new Error(
+        "cache.client.adapter must default-export an adapter. Export defineClientCacheAdapter({ keys, get, set, delete, clear }) as the module default."
+      );
+    }
+    initPersistedClientCache(adapter, options);
+  } catch (error) {
+    reportPersistenceFailure(error);
+  }
+}
+function disposePersistedClientCache() {
+  const engine = activeEngine;
+  if (!engine) return;
+  activeEngine = void 0;
+  engine.disabled = true;
+  engine.cache.attachPersistence(void 0);
+  if (engine.flushTimer !== void 0) {
+    clearTimeout(engine.flushTimer);
+    engine.flushTimer = void 0;
+  }
+  engine.pendingSets.clear();
+  engine.pendingDeletes.clear();
+}
+async function clearPersistedCache() {
+  const engine = activeEngine;
+  if (!engine) {
+    _chunkI2BYNELAcjs.getFarmClientDataCache.call(void 0, ).clear();
+    return;
+  }
+  engine.clearing = true;
+  engine.hydrationGeneration += 1;
+  try {
+    engine.pendingSets.clear();
+    engine.pendingDeletes.clear();
+    engine.cache.clear();
+    engine.pendingSets.clear();
+    engine.pendingDeletes.clear();
+    await engine.flushing;
+    engine.pendingSets.clear();
+    engine.pendingDeletes.clear();
+    await engine.adapter.clear();
+  } catch (error) {
+    disableEngine(engine, error);
+  } finally {
+    engine.clearing = false;
+  }
+}
+
+// src/store.ts
+
+var RESERVED_STORE_KEYS = /* @__PURE__ */ new Set([
+  "use",
+  "get",
+  "set",
+  "replace",
+  "reset",
+  "subscribe"
+]);
+function cloneState(state) {
+  return { ...state };
+}
+function pickState(state, keys) {
+  const slice = {};
+  for (const key of keys) {
+    slice[key] = state[key];
+  }
+  return slice;
+}
+function getEnumerableKeys(state) {
+  return Reflect.ownKeys(state).filter(
+    (key) => Object.prototype.propertyIsEnumerable.call(state, key)
+  );
+}
+function getChangedKeys(state, previousState) {
+  const keys = /* @__PURE__ */ new Set([...getEnumerableKeys(state), ...getEnumerableKeys(previousState)]);
+  return [...keys].filter((key) => !Object.is(state[key], previousState[key]));
+}
+function normalizeKeys(keys) {
+  return Array.from(new Set(keys));
+}
+function resolveValue(value, previousValue) {
+  return typeof value === "function" ? value(previousValue) : value;
+}
+function isStoreKey(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
+}
+function createStore(initialState, extend) {
+  const initialSnapshot = cloneState(initialState);
+  let state = cloneState(initialState);
+  const subscriptions = /* @__PURE__ */ new Set();
+  const addSubscription = (keys, notify) => {
+    const subscription = {
+      // Object property enumeration returns numeric keys as strings.
+      keys: _nullishCoalesce(_optionalChain([keys, 'optionalAccess', _32 => _32.map, 'call', _33 => _33((key) => typeof key === "number" ? String(key) : key)]), () => ( null)),
+      notify
+    };
+    subscriptions.add(subscription);
+    return () => {
+      subscriptions.delete(subscription);
+    };
+  };
+  const emit = (nextState, previousState) => {
+    const changedKeys = getChangedKeys(nextState, previousState);
+    if (changedKeys.length === 0) {
+      return;
+    }
+    const changedKeySet = new Set(changedKeys);
+    for (const subscription of subscriptions) {
+      if (subscription.keys === null || subscription.keys.some((key) => changedKeySet.has(key))) {
+        subscription.notify(nextState, previousState);
+      }
+    }
+  };
+  const getState = (key) => {
+    return key === void 0 ? state : state[key];
+  };
+  const replaceState2 = (nextState) => {
+    const previousState = state;
+    const resolvedState = typeof nextState === "function" ? nextState(previousState) : nextState;
+    state = resolvedState;
+    emit(state, previousState);
+    return state;
+  };
+  const setState = (keyOrPatch, value) => {
+    const previousState = state;
+    let nextState;
+    if (isStoreKey(keyOrPatch)) {
+      const key = keyOrPatch;
+      const nextValue = resolveValue(value, previousState[key]);
+      if (Object.is(previousState[key], nextValue)) {
+        return nextValue;
+      }
+      nextState = {
+        ...previousState,
+        [key]: nextValue
+      };
+      state = nextState;
+      emit(nextState, previousState);
+      return nextValue;
+    }
+    const patch = typeof keyOrPatch === "function" ? keyOrPatch(previousState) : keyOrPatch;
+    nextState = {
+      ...previousState,
+      ...patch
+    };
+    state = nextState;
+    emit(nextState, previousState);
+    return nextState;
+  };
+  const subscribeState = (keyOrListener, listener) => {
+    if (typeof keyOrListener === "function") {
+      return addSubscription(null, (nextState, previousState) => {
+        keyOrListener(nextState, previousState);
+      });
+    }
+    if (Array.isArray(keyOrListener)) {
+      const keys = normalizeKeys(keyOrListener);
+      return addSubscription(keys, (nextState, previousState) => {
+        listener(
+          pickState(nextState, keys),
+          pickState(previousState, keys)
+        );
+      });
+    }
+    const key = keyOrListener;
+    return addSubscription([key], (nextState, previousState) => {
+      listener(nextState[key], previousState[key]);
+    });
+  };
+  const useStateValue = (keyOrKeys) => {
+    if (Array.isArray(keyOrKeys)) {
+      const keys = normalizeKeys(keyOrKeys);
+      let lastState = state;
+      let lastSlice = pickState(state, keys);
+      const getSnapshot = () => {
+        if (lastState !== state) {
+          lastState = state;
+          lastSlice = pickState(state, keys);
+        }
+        return lastSlice;
+      };
+      return _react.useSyncExternalStore.call(void 0, 
+        (notify) => addSubscription(keys, () => notify()),
+        getSnapshot,
+        getSnapshot
+      );
+    }
+    if (isStoreKey(keyOrKeys)) {
+      return _react.useSyncExternalStore.call(void 0, 
+        (notify) => addSubscription([keyOrKeys], () => notify()),
+        () => state[keyOrKeys],
+        () => state[keyOrKeys]
+      );
+    }
+    return _react.useSyncExternalStore.call(void 0, 
+      (notify) => addSubscription(null, () => notify()),
+      () => state,
+      () => state
+    );
+  };
+  const store = {
+    use: useStateValue,
+    get: getState,
+    set: setState,
+    replace: replaceState2,
+    reset: () => replaceState2(cloneState(initialSnapshot)),
+    subscribe: subscribeState
+  };
+  for (const key of getEnumerableKeys(initialSnapshot)) {
+    if (RESERVED_STORE_KEYS.has(key)) {
+      throw new Error(
+        `createStore does not allow the reserved key "${String(key)}" in the initial state.`
+      );
+    }
+    const field = (() => useStateValue(key));
+    field.get = () => state[key];
+    field.set = (value) => setState(key, value);
+    field.subscribe = (listener) => subscribeState(key, listener);
+    Object.defineProperty(store, key, {
+      configurable: false,
+      enumerable: true,
+      value: field,
+      writable: false
+    });
+  }
+  if (extend) {
+    const methods = extend(store);
+    for (const [name, method] of Object.entries(methods)) {
+      if (name in store) {
+        throw new Error(
+          `createStore cannot attach the method "${name}" because it already exists.`
+        );
+      }
+      Object.defineProperty(store, name, {
+        configurable: false,
+        enumerable: true,
+        value: method,
+        writable: false
+      });
+    }
+  }
+  return store;
+}
+
+// src/client/link.tsx
+
+
+// src/provider.tsx
+
+var _jsxruntime = require('react/jsx-runtime');
+var farmContext;
+function getFarmContext() {
+  return _nullishCoalesce(farmContext, () => ( (farmContext = _react.createContext.call(void 0, null))));
+}
+function FarmProvider({ children, config }) {
+  const value = {
+    config,
+    basePath: _chunkD22BUQKWcjs.normalizeFarmBasePath.call(void 0, config.basePath)
+  };
+  const FarmContext = getFarmContext();
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, FarmContext.Provider, { value, children });
+}
+function useOptionalFarm() {
+  return _react.useContext.call(void 0, getFarmContext());
+}
+
+// src/client/link.tsx
+
+function isModifierEvent(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+function isExternalUrl(href) {
+  return href.startsWith("//") || /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href);
+}
+function getRouter() {
+  if (typeof window !== "undefined" && window.__FARM_SPA_ROUTER__) {
+    return window.__FARM_SPA_ROUTER__;
+  }
+  return null;
+}
+function normalizePrefetch(prefetch2) {
+  if (prefetch2 === false || prefetch2 === "none") {
+    return { intent: false, viewport: false, render: false };
+  }
+  if (prefetch2 === true) {
+    return { intent: true, viewport: true, render: false };
+  }
+  if (prefetch2 === "hover") {
+    return { intent: true, viewport: false, render: false };
+  }
+  if (prefetch2 === "intent") {
+    return { intent: true, viewport: false, render: false };
+  }
+  if (prefetch2 === "viewport") {
+    return { intent: false, viewport: true, render: false };
+  }
+  if (prefetch2 === "render") {
+    return { intent: false, viewport: false, render: true };
+  }
+  return { intent: false, viewport: false, render: false };
+}
+function LinkInner({
+  href,
+  params,
+  query,
+  hash,
+  trailingSlash,
+  prefetch: prefetch2 = true,
+  prefetchDelay = 50,
+  replace = false,
+  scroll = true,
+  viewTransition = false,
+  locale,
+  onClick,
+  target,
+  onMouseEnter,
+  onMouseLeave,
+  onFocus,
+  onBlur,
+  onTouchStart,
+  ...props
+}, ref) {
+  const elementRef = _react.useRef.call(void 0, null);
+  const intentTimeoutRef = _react.useRef.call(void 0, null);
+  const activePrefetch = _react.useRef.call(void 0, null);
+  const farm = useOptionalFarm();
+  const { intent, viewport, render } = normalizePrefetch(prefetch2);
+  const baseHref = resolveLinkHref(href, params, {
+    query,
+    hash,
+    trailingSlash: _nullishCoalesce(trailingSlash, () => ( _chunkJGAE5XPLcjs.getFarmTrailingSlashPreference.call(void 0, )))
+  });
+  const localizedHref = _chunkRI3EVPKDcjs.localizeActiveFarmHref.call(void 0, baseHref, locale);
+  const resolvedHref = isExternalUrl(localizedHref) ? localizedHref : _chunkD22BUQKWcjs.applyFarmBasePath.call(void 0, localizedHref, _nullishCoalesce(_optionalChain([farm, 'optionalAccess', _34 => _34.basePath]), () => ( _chunkD22BUQKWcjs.getFarmBasePath.call(void 0, ))));
+  const isExternal = isExternalUrl(resolvedHref);
+  const isScriptHref = _chunkQQ44FYROcjs.isFarmScriptURL.call(void 0, resolvedHref);
+  const doPrefetch = _react.useCallback.call(void 0, () => {
+    if (isExternal || activePrefetch.current) return;
+    const router = getRouter();
+    if (!router) return;
+    const token = Symbol(resolvedHref);
+    activePrefetch.current = token;
+    const reset = () => {
+      if (activePrefetch.current === token) activePrefetch.current = null;
+    };
+    try {
+      void router.prefetch(resolvedHref).then(reset, reset);
+    } catch (e3) {
+      reset();
+    }
+  }, [resolvedHref, isExternal]);
+  _react.useEffect.call(void 0, () => {
+    activePrefetch.current = null;
+  }, [resolvedHref]);
+  _react.useEffect.call(void 0, () => {
+    const element = elementRef.current;
+    if (!element || isExternal) return;
+    const router = getRouter();
+    if (!router) return;
+    if (viewport) {
+      router.observeForPrefetch(element);
+      return () => router.unobserveForPrefetch(element);
+    }
+  }, [resolvedHref, viewport, isExternal]);
+  _react.useEffect.call(void 0, () => {
+    if (!render || isExternal) return;
+    let cancelled = false;
+    let timeoutId = null;
+    const tryRenderPrefetch = () => {
+      if (cancelled || activePrefetch.current) return;
+      const router = getRouter();
+      if (!router) {
+        timeoutId = setTimeout(tryRenderPrefetch, 30);
+        return;
+      }
+      doPrefetch();
+    };
+    tryRenderPrefetch();
+    return () => {
+      cancelled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [render, isExternal, resolvedHref, doPrefetch]);
+  _react.useEffect.call(void 0, () => {
+    return () => {
+      if (intentTimeoutRef.current) {
+        clearTimeout(intentTimeoutRef.current);
+        intentTimeoutRef.current = null;
+      }
+    };
+  }, []);
+  const cancelIntent = _react.useCallback.call(void 0, () => {
+    if (intentTimeoutRef.current) {
+      clearTimeout(intentTimeoutRef.current);
+      intentTimeoutRef.current = null;
+    }
+  }, []);
+  const scheduleIntentPrefetch = _react.useCallback.call(void 0, () => {
+    if (isExternal || !intent || activePrefetch.current) return;
+    cancelIntent();
+    intentTimeoutRef.current = setTimeout(() => {
+      intentTimeoutRef.current = null;
+      doPrefetch();
+    }, prefetchDelay);
+  }, [intent, isExternal, prefetchDelay, doPrefetch, cancelIntent]);
+  const handleMouseEnter = _react.useCallback.call(void 0, 
+    (event) => {
+      _optionalChain([onMouseEnter, 'optionalCall', _35 => _35(event)]);
+      scheduleIntentPrefetch();
+    },
+    [onMouseEnter, scheduleIntentPrefetch]
+  );
+  const handleMouseLeave = _react.useCallback.call(void 0, 
+    (event) => {
+      _optionalChain([onMouseLeave, 'optionalCall', _36 => _36(event)]);
+      cancelIntent();
+    },
+    [onMouseLeave, cancelIntent]
+  );
+  const handleTouchStart = _react.useCallback.call(void 0, 
+    (event) => {
+      _optionalChain([onTouchStart, 'optionalCall', _37 => _37(event)]);
+      scheduleIntentPrefetch();
+    },
+    [onTouchStart, scheduleIntentPrefetch]
+  );
+  const handleFocus = _react.useCallback.call(void 0, 
+    (event) => {
+      _optionalChain([onFocus, 'optionalCall', _38 => _38(event)]);
+      scheduleIntentPrefetch();
+    },
+    [onFocus, scheduleIntentPrefetch]
+  );
+  const handleBlur = _react.useCallback.call(void 0, 
+    (event) => {
+      _optionalChain([onBlur, 'optionalCall', _39 => _39(event)]);
+      cancelIntent();
+    },
+    [onBlur, cancelIntent]
+  );
+  const handleClick = _react.useCallback.call(void 0, 
+    (event) => {
+      _optionalChain([onClick, 'optionalCall', _40 => _40(event)]);
+      if (isScriptHref) {
+        event.preventDefault();
+        _chunkQQ44FYROcjs.isFarmBlockedNavigationURL.call(void 0, _chunkQQ44FYROcjs.resolveFarmNavigationURL.call(void 0, resolvedHref, window.location.href));
+        return;
+      }
+      if (event.defaultPrevented) return;
+      if (isExternal) return;
+      if (event.currentTarget.hasAttribute("download")) return;
+      if (target && target !== "_self") return;
+      if (isModifierEvent(event)) return;
+      if (event.button !== 0) return;
+      if (typeof window !== "undefined") {
+        event.preventDefault();
+        if (_chunkRI3EVPKDcjs.isFarmLocaleChangeHref.call(void 0, localizedHref)) {
+          window.location.assign(resolvedHref);
+          return;
+        }
+        const router = getRouter();
+        if (router) {
+          router.navigate(resolvedHref, { replace, scroll, viewTransition });
+        } else {
+          if (replace) window.location.replace(resolvedHref);
+          else window.location.href = resolvedHref;
+        }
+      }
+    },
+    [
+      localizedHref,
+      resolvedHref,
+      replace,
+      scroll,
+      viewTransition,
+      target,
+      isExternal,
+      isScriptHref,
+      onClick
+    ]
+  );
+  const setRefs = _react.useCallback.call(void 0, 
+    (node) => {
+      elementRef.current = node;
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    },
+    [ref]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "a",
+    {
+      ref: setRefs,
+      href: isScriptHref ? void 0 : resolvedHref,
+      target,
+      onClick: handleClick,
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      onTouchStart: handleTouchStart,
+      ...props,
+      "data-farm-link": "",
+      "data-replace": replace ? "" : void 0,
+      "data-no-scroll": !scroll ? "" : void 0,
+      "data-view-transition": viewTransition === "auto" ? "auto" : viewTransition ? "true" : void 0
+    }
+  );
+}
+var LinkWithRef = _react.forwardRef.call(void 0, LinkInner);
+LinkWithRef.displayName = "Link";
+var Link = LinkWithRef;
+function resolveLinkHref(href, params, options) {
+  if (isExternalUrl(href)) return href;
+  if (href.startsWith("#") && !params && !options.query && options.hash === void 0) return href;
+  const { pathname, query, hash } = splitInternalHref(href);
+  const resolvedHref = _chunk53EHWHT2cjs.buildFarmRoutePath.call(void 0, pathname, params, {
+    query: mergeQueryParams(query, options.query),
+    hash: _nullishCoalesce(options.hash, () => ( hash)),
+    trailingSlash: options.trailingSlash
+  });
+  return applyPreservedSearchParams(resolvedHref);
+}
+function splitInternalHref(href) {
+  try {
+    const url = new URL(href, "http://farm.local");
+    return {
+      pathname: url.pathname || "/",
+      query: url.searchParams,
+      hash: url.hash ? url.hash.slice(1) : void 0
+    };
+  } catch (e4) {
+    const [withoutHash, rawHash] = href.split("#", 2);
+    const [pathname, rawQuery] = withoutHash.split("?", 2);
+    return {
+      pathname: pathname || "/",
+      query: new URLSearchParams(rawQuery || ""),
+      hash: rawHash
+    };
+  }
+}
+function mergeQueryParams(current, next) {
+  const merged = new URLSearchParams(current);
+  if (next instanceof URLSearchParams) {
+    for (const [key, value] of next.entries()) {
+      merged.append(key, value);
+    }
+  } else if (next) {
+    for (const [key, value] of Object.entries(next)) {
+      const values = Array.isArray(value) ? value : [value];
+      for (const item of values) {
+        if (item == null) continue;
+        merged.append(key, String(item));
+      }
+    }
+  }
+  return merged.toString() ? merged : void 0;
+}
+function applyPreservedSearchParams(href) {
+  if (typeof window === "undefined") return href;
+  const manifest = window.__FARM_MANIFEST__;
+  const routes = _optionalChain([manifest, 'optionalAccess', _41 => _41.routes]) && typeof manifest.routes === "object" ? Object.values(manifest.routes) : [];
+  if (routes.length === 0) return href;
+  const url = _chunkQQ44FYROcjs.resolveFarmNavigationURL.call(void 0, href, window.location.href);
+  const route = routes.find((candidate) => matchManifestRoute(url.pathname, candidate));
+  const preserve = Array.isArray(_optionalChain([route, 'optionalAccess', _42 => _42.search, 'optionalAccess', _43 => _43.preserve])) ? route.search.preserve : [];
+  if (preserve.length === 0) return href;
+  const current = new URLSearchParams(window.location.search);
+  let changed = false;
+  for (const key of preserve) {
+    if (url.searchParams.has(key) || !current.has(key)) continue;
+    for (const value of current.getAll(key)) {
+      url.searchParams.append(key, value);
+      changed = true;
+    }
+  }
+  if (!changed) return href;
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+function matchManifestRoute(pathname, route) {
+  if (!route || !Array.isArray(route.segments)) return false;
+  const routeSegments = route.segments;
+  const normalized = pathname === "/" ? "" : pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+  const pathSegments = normalized ? normalized.split("/") : [];
+  const hasCatchAll = routeSegments.some((segment) => segment.isCatchAll);
+  if (!hasCatchAll && pathSegments.length !== routeSegments.length) {
+    return false;
+  }
+  for (let index = 0; index < routeSegments.length; index++) {
+    const routeSegment = routeSegments[index];
+    const pathSegment = pathSegments[index];
+    if (routeSegment.isCatchAll) {
+      return true;
+    }
+    if (pathSegment === void 0) {
+      if (routeSegment.isOptional) continue;
+      return false;
+    }
+    if (!routeSegment.isDynamic && routeSegment.segment !== pathSegment) {
+      return false;
+    }
+  }
+  return pathSegments.length === routeSegments.length || hasCatchAll;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FarmProvider = FarmProvider; exports.useMutation = useMutation; exports.FetcherInputError = FetcherInputError; exports.useFetcher = useFetcher; exports.FARM_CACHE_INVALIDATION_CHANNEL = FARM_CACHE_INVALIDATION_CHANNEL; exports.enableCrossTabCacheInvalidation = enableCrossTabCacheInvalidation; exports.enableLiveCacheInvalidation = enableLiveCacheInvalidation; exports.FARM_CLIENT_CACHE_PERSIST_VERSION = FARM_CLIENT_CACHE_PERSIST_VERSION; exports.defineClientCacheAdapter = defineClientCacheAdapter; exports.storageClientCacheAdapter = storageClientCacheAdapter; exports.initPersistedClientCache = initPersistedClientCache; exports.initConfiguredClientCachePersistence = initConfiguredClientCachePersistence; exports.clearPersistedCache = clearPersistedCache; exports.createStore = createStore; exports.Link = Link;