@ereo/client 0.1.6

package/dist/index.js

@@ -0,0 +1,2081 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hydration.ts
+function parseHydrationDirective(props) {
+  if (props["client:load"]) {
+    return { strategy: "load" };
+  }
+  if (props["client:idle"]) {
+    return { strategy: "idle" };
+  }
+  if (props["client:visible"]) {
+    return { strategy: "visible" };
+  }
+  if (props["client:media"]) {
+    return { strategy: "media", media: props["client:media"] };
+  }
+  if (props["client:only"]) {
+    return { strategy: "load" };
+  }
+  return { strategy: "none" };
+}
+function shouldHydrate(strategy, media) {
+  switch (strategy) {
+    case "load":
+      return true;
+    case "idle":
+      return false;
+    case "visible":
+      return false;
+    case "media":
+      if (!media)
+        return false;
+      return () => window.matchMedia(media).matches;
+    case "none":
+    default:
+      return false;
+  }
+}
+function createHydrationTrigger(strategy, element, onHydrate, media) {
+  let cleanup = null;
+  switch (strategy) {
+    case "load":
+      onHydrate();
+      break;
+    case "idle":
+      if ("requestIdleCallback" in window) {
+        const id = requestIdleCallback(onHydrate);
+        cleanup = () => cancelIdleCallback(id);
+      } else {
+        const id = setTimeout(onHydrate, 200);
+        cleanup = () => clearTimeout(id);
+      }
+      break;
+    case "visible":
+      const observer = new IntersectionObserver((entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            observer.disconnect();
+            onHydrate();
+            break;
+          }
+        }
+      }, { rootMargin: "200px" });
+      observer.observe(element);
+      cleanup = () => observer.disconnect();
+      break;
+    case "media":
+      if (!media)
+        break;
+      const mql = window.matchMedia(media);
+      const handler = (e) => {
+        if (e.matches) {
+          mql.removeEventListener("change", handler);
+          onHydrate();
+        }
+      };
+      if (mql.matches) {
+        onHydrate();
+      } else {
+        mql.addEventListener("change", handler);
+        cleanup = () => mql.removeEventListener("change", handler);
+      }
+      break;
+    case "none":
+    default:
+      break;
+  }
+  return () => {
+    if (cleanup)
+      cleanup();
+  };
+}
+function stripHydrationProps(props) {
+  const {
+    "client:load": _load,
+    "client:idle": _idle,
+    "client:visible": _visible,
+    "client:media": _media,
+    "client:only": _only,
+    ...rest
+  } = props;
+  return rest;
+}
+var islandCounter = 0;
+function generateIslandId() {
+  return `island-${++islandCounter}`;
+}
+function resetIslandCounter() {
+  islandCounter = 0;
+}
+function getIslandCount() {
+  return islandCounter;
+}
+
+// src/islands.ts
+class IslandRegistry {
+  islands = new Map;
+  cleanups = new Map;
+  register(id, component, props, strategy, element, media) {
+    this.islands.set(id, {
+      id,
+      component,
+      props,
+      strategy,
+      media,
+      element,
+      hydrated: false
+    });
+  }
+  get(id) {
+    return this.islands.get(id);
+  }
+  markHydrated(id) {
+    const island = this.islands.get(id);
+    if (island) {
+      island.hydrated = true;
+    }
+  }
+  isHydrated(id) {
+    return this.islands.get(id)?.hydrated ?? false;
+  }
+  setCleanup(id, cleanup) {
+    this.cleanups.set(id, cleanup);
+  }
+  cleanup(id) {
+    const cleanupFn = this.cleanups.get(id);
+    if (cleanupFn) {
+      cleanupFn();
+      this.cleanups.delete(id);
+    }
+    this.islands.delete(id);
+  }
+  cleanupAll() {
+    for (const id of this.islands.keys()) {
+      this.cleanup(id);
+    }
+  }
+  getAll() {
+    return Array.from(this.islands.values());
+  }
+  getByStrategy(strategy) {
+    return this.getAll().filter((i) => i.strategy === strategy);
+  }
+  getPending() {
+    return this.getAll().filter((i) => !i.hydrated);
+  }
+}
+var islandRegistry = new IslandRegistry;
+async function hydrateIslands() {
+  const { hydrateRoot } = await import("react-dom/client");
+  const { createElement } = await import("react");
+  const islandElements = document.querySelectorAll("[data-island]");
+  for (const element of islandElements) {
+    const islandId = element.getAttribute("data-island");
+    const componentName = element.getAttribute("data-component");
+    const propsJson = element.getAttribute("data-props");
+    const strategy = element.getAttribute("data-strategy") || "load";
+    const media = element.getAttribute("data-media") || undefined;
+    if (!islandId || !componentName)
+      continue;
+    const component = getIslandComponent(componentName);
+    if (!component) {
+      console.warn(`Island component not found: ${componentName}`);
+      continue;
+    }
+    const props = propsJson ? JSON.parse(propsJson) : {};
+    islandRegistry.register(islandId, component, props, strategy, element, media);
+    const cleanup = createHydrationTrigger(strategy, element, () => {
+      if (islandRegistry.isHydrated(islandId))
+        return;
+      const root = hydrateRoot(element, createElement(component, props));
+      islandRegistry.markHydrated(islandId);
+      islandRegistry.setCleanup(islandId, () => root.unmount());
+    }, media);
+    islandRegistry.setCleanup(islandId, cleanup);
+  }
+}
+var componentRegistry = new Map;
+function registerIslandComponent(name, component) {
+  componentRegistry.set(name, component);
+}
+function getIslandComponent(name) {
+  return componentRegistry.get(name);
+}
+function registerIslandComponents(components) {
+  for (const [name, component] of Object.entries(components)) {
+    registerIslandComponent(name, component);
+  }
+}
+function createIsland(component, name) {
+  registerIslandComponent(name, component);
+  return function IslandWrapper(props) {
+    const { strategy, media } = parseHydrationDirective(props);
+    const cleanProps = stripHydrationProps(props);
+    const islandId = generateIslandId();
+    return {
+      type: "div",
+      props: {
+        "data-island": islandId,
+        "data-component": name,
+        "data-props": JSON.stringify(cleanProps),
+        "data-strategy": strategy,
+        "data-media": media || undefined,
+        children: {
+          type: component,
+          props: cleanProps
+        }
+      }
+    };
+  };
+}
+function initializeIslands() {
+  if (typeof document === "undefined")
+    return;
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", () => hydrateIslands());
+  } else {
+    hydrateIslands();
+  }
+}
+function cleanupIslands() {
+  islandRegistry.cleanupAll();
+}
+
+// src/navigation.ts
+class ClientRouter {
+  listeners = new Set;
+  currentState;
+  constructor() {
+    this.currentState = this.getStateFromLocation();
+    this.setupPopState();
+  }
+  getStateFromLocation() {
+    if (typeof window === "undefined") {
+      return { pathname: "/", search: "", hash: "" };
+    }
+    return {
+      pathname: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash,
+      state: window.history.state
+    };
+  }
+  setupPopState() {
+    if (typeof window === "undefined")
+      return;
+    window.addEventListener("popstate", (event) => {
+      const from = this.currentState;
+      this.currentState = this.getStateFromLocation();
+      this.notify({
+        type: "pop",
+        from,
+        to: this.currentState
+      });
+    });
+  }
+  async navigate(to, options = {}) {
+    if (typeof window === "undefined")
+      return;
+    const url = new URL(to, window.location.origin);
+    const from = this.currentState;
+    const newState = {
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      state: options.state
+    };
+    if (options.replace) {
+      window.history.replaceState(options.state, "", to);
+    } else {
+      window.history.pushState(options.state, "", to);
+    }
+    this.currentState = newState;
+    this.notify({
+      type: options.replace ? "replace" : "push",
+      from,
+      to: newState
+    });
+  }
+  back() {
+    if (typeof window !== "undefined") {
+      window.history.back();
+    }
+  }
+  forward() {
+    if (typeof window !== "undefined") {
+      window.history.forward();
+    }
+  }
+  go(delta) {
+    if (typeof window !== "undefined") {
+      window.history.go(delta);
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  getState() {
+    return this.currentState;
+  }
+  isActive(path, exact = false) {
+    if (exact) {
+      return this.currentState.pathname === path;
+    }
+    return this.currentState.pathname.startsWith(path);
+  }
+}
+var router = new ClientRouter;
+function navigate(to, options) {
+  return router.navigate(to, options);
+}
+function goBack() {
+  router.back();
+}
+function goForward() {
+  router.forward();
+}
+function onNavigate(listener) {
+  return router.subscribe(listener);
+}
+function getNavigationState() {
+  return router.getState();
+}
+async function fetchLoaderData(pathname, params) {
+  const url = new URL(pathname, window.location.origin);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== undefined) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  const response = await fetch(url.toString(), {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch loader data: ${response.status}`);
+  }
+  const result = await response.json();
+  return result.data;
+}
+async function submitAction(pathname, formData, options = {}) {
+  const response = await fetch(pathname, {
+    method: options.method || "POST",
+    body: formData,
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Action failed: ${response.status}`);
+  }
+  return response.json();
+}
+function setupScrollRestoration() {
+  if (typeof window === "undefined")
+    return;
+  if ("scrollRestoration" in history) {
+    history.scrollRestoration = "manual";
+  }
+  const scrollPositions = new Map;
+  router.subscribe((event) => {
+    scrollPositions.set(event.from.pathname, window.scrollY);
+    if (event.type === "pop") {
+      const savedPosition = scrollPositions.get(event.to.pathname);
+      if (savedPosition !== undefined) {
+        requestAnimationFrame(() => {
+          window.scrollTo(0, savedPosition);
+        });
+      }
+    } else {
+      window.scrollTo(0, 0);
+    }
+  });
+}
+
+// src/prefetch.ts
+var prefetchCache = new Map;
+var defaultOptions = {
+  strategy: "hover",
+  cacheDuration: 30000,
+  threshold: 0
+};
+function isCacheValid(entry, cacheDuration) {
+  return Date.now() - entry.timestamp < cacheDuration;
+}
+async function prefetch(url) {
+  const cached = prefetchCache.get(url);
+  if (cached && isCacheValid(cached, defaultOptions.cacheDuration)) {
+    return;
+  }
+  const entry = {
+    url,
+    timestamp: Date.now(),
+    loading: true
+  };
+  prefetchCache.set(url, entry);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "X-Prefetch": "true"
+      },
+      priority: "low"
+    });
+    if (response.ok) {
+      entry.data = await response.json();
+    } else {
+      entry.error = new Error(`Prefetch failed: ${response.status}`);
+    }
+  } catch (error) {
+    entry.error = error instanceof Error ? error : new Error("Prefetch failed");
+  } finally {
+    entry.loading = false;
+  }
+}
+function getPrefetchedData(url) {
+  const entry = prefetchCache.get(url);
+  if (entry && isCacheValid(entry, defaultOptions.cacheDuration) && entry.data) {
+    return entry.data;
+  }
+  return;
+}
+function clearPrefetchCache() {
+  prefetchCache.clear();
+}
+function setupLinkPrefetch(element, options = {}) {
+  const { strategy, threshold } = { ...defaultOptions, ...options };
+  const href = element.href;
+  if (!href || !href.startsWith(window.location.origin)) {
+    return () => {};
+  }
+  const url = new URL(href).pathname;
+  let cleanup = null;
+  switch (strategy) {
+    case "hover": {
+      const onMouseEnter = () => prefetch(url);
+      element.addEventListener("mouseenter", onMouseEnter);
+      cleanup = () => element.removeEventListener("mouseenter", onMouseEnter);
+      break;
+    }
+    case "viewport": {
+      const observer = new IntersectionObserver((entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            prefetch(url);
+            observer.disconnect();
+            break;
+          }
+        }
+      }, { threshold });
+      observer.observe(element);
+      cleanup = () => observer.disconnect();
+      break;
+    }
+    case "eager": {
+      prefetch(url);
+      break;
+    }
+    case "none":
+    default:
+      break;
+  }
+  return () => {
+    if (cleanup)
+      cleanup();
+  };
+}
+function setupAutoPrefetch(options = {}) {
+  if (typeof document === "undefined")
+    return () => {};
+  const cleanups = [];
+  const links = document.querySelectorAll('a[href^="/"]');
+  links.forEach((link) => {
+    cleanups.push(setupLinkPrefetch(link, options));
+  });
+  const observer = new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      for (const node of mutation.addedNodes) {
+        if (node instanceof HTMLAnchorElement && node.href.startsWith("/")) {
+          cleanups.push(setupLinkPrefetch(node, options));
+        }
+        if (node instanceof Element) {
+          const newLinks = node.querySelectorAll('a[href^="/"]');
+          newLinks.forEach((link) => {
+            cleanups.push(setupLinkPrefetch(link, options));
+          });
+        }
+      }
+    }
+  });
+  observer.observe(document.body, { childList: true, subtree: true });
+  return () => {
+    observer.disconnect();
+    cleanups.forEach((cleanup) => cleanup());
+  };
+}
+async function prefetchAll(urls) {
+  await Promise.all(urls.map(prefetch));
+}
+function isPrefetching(url) {
+  const entry = prefetchCache.get(url);
+  return entry?.loading ?? false;
+}
+function isPrefetched(url) {
+  const entry = prefetchCache.get(url);
+  return entry?.data !== undefined;
+}
+// src/hooks.ts
+import {
+  createContext,
+  useContext,
+  useState,
+  useCallback,
+  useMemo,
+  createElement
+} from "react";
+var LoaderDataContext = createContext(null);
+var ActionDataContext = createContext(null);
+var NavigationContext = createContext(null);
+var ErrorContext = createContext(null);
+function useLoaderData() {
+  const context = useContext(LoaderDataContext);
+  if (context === null) {
+    throw new Error("useLoaderData must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  return context.data;
+}
+function useActionData() {
+  const context = useContext(ActionDataContext);
+  if (context === null) {
+    throw new Error("useActionData must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  return context.data;
+}
+function useNavigation() {
+  const context = useContext(NavigationContext);
+  if (context === null) {
+    throw new Error("useNavigation must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  return context.state;
+}
+function useError() {
+  const context = useContext(ErrorContext);
+  if (context === null) {
+    throw new Error("useError must be used within an EreoProvider. " + "Make sure your component is wrapped with <EreoProvider>.");
+  }
+  return context.error;
+}
+function LoaderDataProvider({
+  children,
+  initialData
+}) {
+  const [data, setData] = useState(initialData);
+  const value = useMemo(() => ({ data, setData }), [data]);
+  return createElement(LoaderDataContext.Provider, { value }, children);
+}
+function ActionDataProvider({
+  children,
+  initialData
+}) {
+  const [data, setData] = useState(initialData);
+  const clearData = useCallback(() => {
+    setData(undefined);
+  }, []);
+  const value = useMemo(() => ({ data, setData, clearData }), [data, clearData]);
+  return createElement(ActionDataContext.Provider, { value }, children);
+}
+var defaultNavigationState = {
+  status: "idle"
+};
+function NavigationProvider({
+  children,
+  initialState = defaultNavigationState
+}) {
+  const [state, setState] = useState(initialState);
+  const startLoading = useCallback((location) => {
+    setState({
+      status: "loading",
+      location
+    });
+  }, []);
+  const startSubmitting = useCallback((options) => {
+    setState({
+      status: "submitting",
+      location: options.location,
+      formData: options.formData,
+      formMethod: options.formMethod,
+      formAction: options.formAction
+    });
+  }, []);
+  const complete = useCallback(() => {
+    setState({ status: "idle" });
+  }, []);
+  const value = useMemo(() => ({
+    state,
+    setState,
+    startLoading,
+    startSubmitting,
+    complete
+  }), [state, startLoading, startSubmitting, complete]);
+  return createElement(NavigationContext.Provider, { value }, children);
+}
+function ErrorProvider({
+  children,
+  initialError
+}) {
+  const [error, setError] = useState(initialError);
+  const clearError = useCallback(() => {
+    setError(undefined);
+  }, []);
+  const value = useMemo(() => ({ error, setError, clearError }), [error, clearError]);
+  return createElement(ErrorContext.Provider, { value }, children);
+}
+function EreoProvider({
+  children,
+  loaderData,
+  actionData,
+  navigationState,
+  error
+}) {
+  return createElement(ErrorProvider, { initialError: error, children: createElement(NavigationProvider, { initialState: navigationState, children: createElement(ActionDataProvider, { initialData: actionData, children: createElement(LoaderDataProvider, { initialData: loaderData, children }) }) }) });
+}
+function useLoaderDataContext() {
+  const context = useContext(LoaderDataContext);
+  if (context === null) {
+    throw new Error("useLoaderDataContext must be used within an EreoProvider");
+  }
+  return context;
+}
+function useActionDataContext() {
+  const context = useContext(ActionDataContext);
+  if (context === null) {
+    throw new Error("useActionDataContext must be used within an EreoProvider");
+  }
+  return context;
+}
+function useNavigationContext() {
+  const context = useContext(NavigationContext);
+  if (context === null) {
+    throw new Error("useNavigationContext must be used within an EreoProvider");
+  }
+  return context;
+}
+function useErrorContext() {
+  const context = useContext(ErrorContext);
+  if (context === null) {
+    throw new Error("useErrorContext must be used within an EreoProvider");
+  }
+  return context;
+}
+// src/link.tsx
+import * as React from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+function isExternalUrl(url) {
+  if (typeof window === "undefined")
+    return false;
+  if (url.startsWith("/") && !url.startsWith("//") || url.startsWith(".")) {
+    return false;
+  }
+  try {
+    const parsed = new URL(url, window.location.origin);
+    return parsed.origin !== window.location.origin;
+  } catch {
+    return false;
+  }
+}
+function shouldNavigate(event) {
+  if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
+    return false;
+  }
+  if (event.button !== 0) {
+    return false;
+  }
+  if (event.defaultPrevented) {
+    return false;
+  }
+  return true;
+}
+var Link = React.forwardRef(function Link2({
+  to,
+  prefetch: prefetchStrategy = "intent",
+  replace = false,
+  preventScrollReset = false,
+  state,
+  reloadDocument = false,
+  onClick,
+  onMouseEnter,
+  onFocus,
+  children,
+  ...rest
+}, ref) {
+  const internalRef = React.useRef(null);
+  const resolvedRef = ref || internalRef;
+  const hasPrefetched = React.useRef(false);
+  const isExternal = isExternalUrl(to);
+  const triggerPrefetch = React.useCallback(() => {
+    if (hasPrefetched.current || isExternal || prefetchStrategy === "none") {
+      return;
+    }
+    hasPrefetched.current = true;
+    prefetch(to);
+  }, [to, isExternal, prefetchStrategy]);
+  const handleClick = React.useCallback((event) => {
+    onClick?.(event);
+    if (isExternal || reloadDocument) {
+      return;
+    }
+    if (!shouldNavigate(event)) {
+      return;
+    }
+    const target = event.currentTarget.getAttribute("target");
+    if (target && target !== "_self") {
+      return;
+    }
+    event.preventDefault();
+    navigate(to, { replace, state });
+    if (!preventScrollReset && typeof window !== "undefined") {
+      window.scrollTo(0, 0);
+    }
+  }, [onClick, to, replace, state, isExternal, reloadDocument, preventScrollReset]);
+  const handleMouseEnter = React.useCallback((event) => {
+    onMouseEnter?.(event);
+    if (prefetchStrategy === "intent") {
+      triggerPrefetch();
+    }
+  }, [onMouseEnter, prefetchStrategy, triggerPrefetch]);
+  const handleFocus = React.useCallback((event) => {
+    onFocus?.(event);
+    if (prefetchStrategy === "intent") {
+      triggerPrefetch();
+    }
+  }, [onFocus, prefetchStrategy, triggerPrefetch]);
+  React.useEffect(() => {
+    if (prefetchStrategy === "render") {
+      triggerPrefetch();
+    }
+  }, [prefetchStrategy, triggerPrefetch]);
+  React.useEffect(() => {
+    if (prefetchStrategy !== "viewport" || typeof IntersectionObserver === "undefined") {
+      return;
+    }
+    const element = resolvedRef.current;
+    if (!element)
+      return;
+    const observer = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.isIntersecting) {
+          triggerPrefetch();
+          observer.disconnect();
+          break;
+        }
+      }
+    }, { threshold: 0 });
+    observer.observe(element);
+    return () => {
+      observer.disconnect();
+    };
+  }, [prefetchStrategy, triggerPrefetch, resolvedRef]);
+  return /* @__PURE__ */ jsxDEV("a", {
+    ...rest,
+    ref: resolvedRef,
+    href: to,
+    onClick: handleClick,
+    onMouseEnter: handleMouseEnter,
+    onFocus: handleFocus,
+    children
+  }, undefined, false, undefined, this);
+});
+var NavLink = React.forwardRef(function NavLink2({ className, style, end = false, to, ...rest }, ref) {
+  const [navigationState, setNavigationState] = React.useState(() => {
+    if (typeof window !== "undefined") {
+      return router.getState();
+    }
+    return { pathname: "/", search: "", hash: "" };
+  });
+  React.useEffect(() => {
+    const unsubscribe = onNavigate((event) => {
+      setNavigationState(event.to);
+    });
+    return unsubscribe;
+  }, []);
+  const isActive = React.useMemo(() => {
+    const toPath = to.split("?")[0].split("#")[0];
+    if (end) {
+      return navigationState.pathname === toPath;
+    }
+    return navigationState.pathname.startsWith(toPath) && (toPath === "/" ? navigationState.pathname === "/" : true);
+  }, [to, end, navigationState.pathname]);
+  const isPending = false;
+  const activeProps = { isActive, isPending };
+  const resolvedClassName = typeof className === "function" ? className(activeProps) : className;
+  const resolvedStyle = typeof style === "function" ? style(activeProps) : style;
+  return /* @__PURE__ */ jsxDEV(Link, {
+    ...rest,
+    ref,
+    to,
+    className: resolvedClassName,
+    style: resolvedStyle,
+    "aria-current": isActive ? "page" : undefined
+  }, undefined, false, undefined, this);
+});
+function useIsActive(path, end = false) {
+  const [pathname, setPathname] = React.useState(() => {
+    if (typeof window !== "undefined") {
+      return window.location.pathname;
+    }
+    return "/";
+  });
+  React.useEffect(() => {
+    const unsubscribe = onNavigate((event) => {
+      setPathname(event.to.pathname);
+    });
+    return unsubscribe;
+  }, []);
+  const toPath = path.split("?")[0].split("#")[0];
+  if (end) {
+    return pathname === toPath;
+  }
+  return pathname.startsWith(toPath) && (toPath === "/" ? pathname === "/" : true);
+}
+// src/typed-link.tsx
+import * as React2 from "react";
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+function buildPathWithParams(pattern, params) {
+  if (!params)
+    return pattern;
+  let result = pattern;
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined)
+      continue;
+    if (result.includes(`[...${key}]`)) {
+      const arrayValue = Array.isArray(value) ? value : [value];
+      result = result.replace(`[...${key}]`, arrayValue.join("/"));
+      continue;
+    }
+    if (result.includes(`[[${key}]]`)) {
+      result = result.replace(`[[${key}]]`, Array.isArray(value) ? value[0] : value);
+      continue;
+    }
+    if (result.includes(`[${key}]`)) {
+      result = result.replace(`[${key}]`, Array.isArray(value) ? value[0] : value);
+    }
+  }
+  result = result.replace(/\/?\[\[[^\]]+\]\]/g, "");
+  return result;
+}
+function buildSearchString(search) {
+  if (!search)
+    return "";
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(search)) {
+    if (value === undefined || value === null)
+      continue;
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        params.append(key, String(v));
+      }
+    } else {
+      params.set(key, String(value));
+    }
+  }
+  const queryString = params.toString();
+  return queryString ? `?${queryString}` : "";
+}
+function buildHashString(hash) {
+  if (!hash)
+    return "";
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(hash)) {
+    if (value === undefined || value === null)
+      continue;
+    params.set(key, String(value));
+  }
+  const hashString = params.toString();
+  return hashString ? `#${hashString}` : "";
+}
+function buildUrl(pattern, options = {}) {
+  const { params, search, hash } = options;
+  const path = buildPathWithParams(pattern, params);
+  const searchString = buildSearchString(search);
+  const hashString = buildHashString(hash);
+  return `${path}${searchString}${hashString}`;
+}
+function isExternalUrl2(url) {
+  if (typeof window === "undefined")
+    return false;
+  if (url.startsWith("/") && !url.startsWith("//") || url.startsWith(".")) {
+    return false;
+  }
+  try {
+    const parsed = new URL(url, window.location.origin);
+    return parsed.origin !== window.location.origin;
+  } catch {
+    return false;
+  }
+}
+function shouldNavigate2(event) {
+  if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
+    return false;
+  }
+  if (event.button !== 0) {
+    return false;
+  }
+  if (event.defaultPrevented) {
+    return false;
+  }
+  return true;
+}
+var TypedLink = React2.forwardRef(function TypedLink2(props, ref) {
+  const {
+    to,
+    params,
+    search,
+    hash,
+    prefetch: prefetchStrategy = "intent",
+    replace = false,
+    preventScrollReset = false,
+    state,
+    reloadDocument = false,
+    onClick,
+    onMouseEnter,
+    onFocus,
+    children,
+    ...rest
+  } = props;
+  const internalRef = React2.useRef(null);
+  const resolvedRef = ref || internalRef;
+  const hasPrefetched = React2.useRef(false);
+  const href = React2.useMemo(() => {
+    return buildUrl(to, {
+      params,
+      search,
+      hash
+    });
+  }, [to, params, search, hash]);
+  const isExternal = isExternalUrl2(href);
+  const triggerPrefetch = React2.useCallback(() => {
+    if (hasPrefetched.current || isExternal || prefetchStrategy === "none") {
+      return;
+    }
+    hasPrefetched.current = true;
+    prefetch(href);
+  }, [href, isExternal, prefetchStrategy]);
+  const handleClick = React2.useCallback((event) => {
+    onClick?.(event);
+    if (isExternal || reloadDocument) {
+      return;
+    }
+    if (!shouldNavigate2(event)) {
+      return;
+    }
+    const target = event.currentTarget.getAttribute("target");
+    if (target && target !== "_self") {
+      return;
+    }
+    event.preventDefault();
+    navigate(href, { replace, state });
+    if (!preventScrollReset && typeof window !== "undefined") {
+      window.scrollTo(0, 0);
+    }
+  }, [onClick, href, replace, state, isExternal, reloadDocument, preventScrollReset]);
+  const handleMouseEnter = React2.useCallback((event) => {
+    onMouseEnter?.(event);
+    if (prefetchStrategy === "intent") {
+      triggerPrefetch();
+    }
+  }, [onMouseEnter, prefetchStrategy, triggerPrefetch]);
+  const handleFocus = React2.useCallback((event) => {
+    onFocus?.(event);
+    if (prefetchStrategy === "intent") {
+      triggerPrefetch();
+    }
+  }, [onFocus, prefetchStrategy, triggerPrefetch]);
+  React2.useEffect(() => {
+    if (prefetchStrategy === "render") {
+      triggerPrefetch();
+    }
+  }, [prefetchStrategy, triggerPrefetch]);
+  React2.useEffect(() => {
+    if (prefetchStrategy !== "viewport" || typeof IntersectionObserver === "undefined") {
+      return;
+    }
+    const element = resolvedRef.current;
+    if (!element)
+      return;
+    const observer = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.isIntersecting) {
+          triggerPrefetch();
+          observer.disconnect();
+          break;
+        }
+      }
+    }, { threshold: 0 });
+    observer.observe(element);
+    return () => {
+      observer.disconnect();
+    };
+  }, [prefetchStrategy, triggerPrefetch, resolvedRef]);
+  return /* @__PURE__ */ jsxDEV2("a", {
+    ...rest,
+    ref: resolvedRef,
+    href,
+    onClick: handleClick,
+    onMouseEnter: handleMouseEnter,
+    onFocus: handleFocus,
+    children
+  }, undefined, false, undefined, this);
+});
+var TypedNavLink = React2.forwardRef(function TypedNavLink2(props, ref) {
+  const {
+    className,
+    style,
+    end = false,
+    to,
+    params,
+    search,
+    hash,
+    ...rest
+  } = props;
+  const [navigationState, setNavigationState] = React2.useState(() => {
+    if (typeof window !== "undefined") {
+      return router.getState();
+    }
+    return { pathname: "/", search: "", hash: "" };
+  });
+  React2.useEffect(() => {
+    const unsubscribe = onNavigate((event) => {
+      setNavigationState(event.to);
+    });
+    return unsubscribe;
+  }, []);
+  const targetPath = React2.useMemo(() => {
+    return buildPathWithParams(to, params).split("?")[0].split("#")[0];
+  }, [to, params]);
+  const isActive = React2.useMemo(() => {
+    if (end) {
+      return navigationState.pathname === targetPath;
+    }
+    return navigationState.pathname.startsWith(targetPath) && (targetPath === "/" ? navigationState.pathname === "/" : true);
+  }, [targetPath, end, navigationState.pathname]);
+  const isPending = false;
+  const activeProps = { isActive, isPending };
+  const resolvedClassName = typeof className === "function" ? className(activeProps) : className;
+  const resolvedStyle = typeof style === "function" ? style(activeProps) : style;
+  const href = React2.useMemo(() => {
+    return buildUrl(to, {
+      params,
+      search,
+      hash
+    });
+  }, [to, params, search, hash]);
+  return /* @__PURE__ */ jsxDEV2("a", {
+    ...rest,
+    ref,
+    href,
+    className: resolvedClassName,
+    style: resolvedStyle,
+    "aria-current": isActive ? "page" : undefined
+  }, undefined, false, undefined, this);
+});
+function useIsRouteActive(path, options = {}) {
+  const { params, end = false } = options;
+  const [pathname, setPathname] = React2.useState(() => {
+    if (typeof window !== "undefined") {
+      return window.location.pathname;
+    }
+    return "/";
+  });
+  React2.useEffect(() => {
+    const unsubscribe = onNavigate((event) => {
+      setPathname(event.to.pathname);
+    });
+    return unsubscribe;
+  }, []);
+  const targetPath = buildPathWithParams(path, params).split("?")[0].split("#")[0];
+  if (end) {
+    return pathname === targetPath;
+  }
+  return pathname.startsWith(targetPath) && (targetPath === "/" ? pathname === "/" : true);
+}
+// src/typed-navigate.ts
+function buildPathWithParams2(pattern, params) {
+  if (!params)
+    return pattern;
+  let result = pattern;
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined)
+      continue;
+    if (result.includes(`[...${key}]`)) {
+      const arrayValue = Array.isArray(value) ? value : [value];
+      result = result.replace(`[...${key}]`, arrayValue.join("/"));
+      continue;
+    }
+    if (result.includes(`[[${key}]]`)) {
+      result = result.replace(`[[${key}]]`, Array.isArray(value) ? value[0] : value);
+      continue;
+    }
+    if (result.includes(`[${key}]`)) {
+      result = result.replace(`[${key}]`, Array.isArray(value) ? value[0] : value);
+    }
+  }
+  result = result.replace(/\/?\[\[[^\]]+\]\]/g, "");
+  return result;
+}
+function buildSearchString2(search) {
+  if (!search)
+    return "";
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(search)) {
+    if (value === undefined || value === null)
+      continue;
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        params.append(key, String(v));
+      }
+    } else {
+      params.set(key, String(value));
+    }
+  }
+  const queryString = params.toString();
+  return queryString ? `?${queryString}` : "";
+}
+function buildHashString2(hash) {
+  if (!hash)
+    return "";
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(hash)) {
+    if (value === undefined || value === null)
+      continue;
+    params.set(key, String(value));
+  }
+  const hashString = params.toString();
+  return hashString ? `#${hashString}` : "";
+}
+function buildTypedUrl(pattern, options = {}) {
+  const { params, search, hash } = options;
+  const path = buildPathWithParams2(pattern, params);
+  const searchString = buildSearchString2(search);
+  const hashString = buildHashString2(hash);
+  return `${path}${searchString}${hashString}`;
+}
+async function typedNavigate(path, options) {
+  const url = buildTypedUrl(path, {
+    params: options?.params,
+    search: options?.search,
+    hash: options?.hash
+  });
+  await navigate(url, {
+    replace: options?.replace,
+    state: options?.state
+  });
+  if (options?.scroll !== false && typeof window !== "undefined") {
+    window.scrollTo(0, 0);
+  }
+}
+function useTypedNavigate() {
+  const navigateFunction = (pathOrDelta, options) => {
+    if (typeof pathOrDelta === "number") {
+      router.go(pathOrDelta);
+      return;
+    }
+    return typedNavigate(pathOrDelta, options);
+  };
+  return navigateFunction;
+}
+function typedRedirect(path, options) {
+  const url = buildTypedUrl(path, {
+    params: options?.params,
+    search: options?.search,
+    hash: options?.hash
+  });
+  const status = options?.status ?? 302;
+  return new Response(null, {
+    status,
+    headers: {
+      Location: url,
+      ...options?.headers instanceof Headers ? Object.fromEntries(options.headers.entries()) : options?.headers
+    }
+  });
+}
+var redirect = typedRedirect;
+function parseTypedSearchParams(url) {
+  const urlObj = typeof url === "string" ? new URL(url) : url;
+  const result = {};
+  urlObj.searchParams.forEach((value, key) => {
+    if (result[key]) {
+      const existing = result[key];
+      result[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+    } else {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+function parseTypedHashParams(url) {
+  const urlObj = typeof url === "string" ? new URL(url) : url;
+  if (!urlObj.hash) {
+    return {};
+  }
+  const hashParams = new URLSearchParams(urlObj.hash.slice(1));
+  const result = {};
+  hashParams.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function goBack2() {
+  router.back();
+}
+function goForward2() {
+  router.forward();
+}
+function go(delta) {
+  router.go(delta);
+}
+function isCurrentPath(path, options) {
+  if (typeof window === "undefined")
+    return false;
+  const targetPath = buildPathWithParams2(path, options?.params).split("?")[0].split("#")[0];
+  const currentPath = window.location.pathname;
+  if (options?.exact) {
+    return currentPath === targetPath;
+  }
+  return currentPath.startsWith(targetPath) && (targetPath === "/" ? currentPath === "/" : true);
+}
+async function preloadRoute(path, options) {
+  const url = buildTypedUrl(path, {
+    params: options?.params,
+    search: options?.search
+  });
+  try {
+    await fetch(url, {
+      headers: {
+        Accept: "application/json",
+        "X-Ereo-Preload": "true"
+      }
+    });
+  } catch {}
+}
+// src/form.ts
+import { createElement as createElement2, useCallback as useCallback4, useRef as useRef3, useState as useState4, useEffect as useEffect3, useContext as useContext2, createContext as createContext2 } from "react";
+var FormContext = createContext2(null);
+function FormProvider({
+  children,
+  initialActionData
+}) {
+  const [actionData, setActionData] = useState4(initialActionData);
+  const [state, setState] = useState4("idle");
+  return createElement2(FormContext.Provider, { value: { actionData, state, setActionData, setState } }, children);
+}
+function useFormContext() {
+  return useContext2(FormContext);
+}
+function Form({
+  method = "post",
+  action,
+  onSubmitStart,
+  onSubmitEnd,
+  replace = false,
+  preventScrollReset = false,
+  encType = "application/x-www-form-urlencoded",
+  fetcherKey,
+  children,
+  onSubmit,
+  ...props
+}) {
+  const formRef = useRef3(null);
+  const formContext = useFormContext();
+  const resolvedAction = action || (typeof window !== "undefined" ? window.location.pathname : "/");
+  const handleSubmit = useCallback4(async (event) => {
+    if (onSubmit) {
+      onSubmit(event);
+      if (event.defaultPrevented) {
+        return;
+      }
+    }
+    if (typeof window === "undefined") {
+      return;
+    }
+    event.preventDefault();
+    const form = event.currentTarget;
+    const formData = new FormData(form);
+    if (formContext) {
+      formContext.setState("submitting");
+    }
+    if (onSubmitStart) {
+      onSubmitStart();
+    }
+    try {
+      let body;
+      if (encType === "application/x-www-form-urlencoded") {
+        body = new URLSearchParams;
+        formData.forEach((value, key) => {
+          if (typeof value === "string") {
+            body.append(key, value);
+          }
+        });
+      } else {
+        body = formData;
+      }
+      if (method.toLowerCase() === "get") {
+        const url = new URL(resolvedAction, window.location.origin);
+        const params = new URLSearchParams;
+        formData.forEach((value, key) => {
+          if (typeof value === "string") {
+            params.append(key, value);
+          }
+        });
+        url.search = params.toString();
+        await router.navigate(url.pathname + url.search, { replace });
+        const result2 = {
+          status: 200,
+          ok: true
+        };
+        if (formContext) {
+          formContext.setState("idle");
+        }
+        if (onSubmitEnd) {
+          onSubmitEnd(result2);
+        }
+        return;
+      }
+      const response = await fetch(resolvedAction, {
+        method: method.toUpperCase(),
+        body,
+        headers: {
+          Accept: "application/json",
+          ...encType === "application/x-www-form-urlencoded" && {
+            "Content-Type": "application/x-www-form-urlencoded"
+          }
+        }
+      });
+      const result = {
+        status: response.status,
+        ok: response.ok
+      };
+      try {
+        const data = await response.json();
+        result.data = data;
+        if (formContext) {
+          formContext.setActionData(data);
+        }
+      } catch {}
+      if (response.ok && !fetcherKey) {
+        const redirectUrl = response.headers.get("X-Redirect-Url");
+        if (redirectUrl) {
+          await router.navigate(redirectUrl, { replace });
+        } else if (!preventScrollReset && typeof window !== "undefined") {
+          window.scrollTo(0, 0);
+        }
+      }
+      if (formContext) {
+        formContext.setState("idle");
+      }
+      if (onSubmitEnd) {
+        onSubmitEnd(result);
+      }
+    } catch (error) {
+      const result = {
+        error: error instanceof Error ? error : new Error(String(error)),
+        status: 0,
+        ok: false
+      };
+      if (formContext) {
+        formContext.setState("error");
+      }
+      if (onSubmitEnd) {
+        onSubmitEnd(result);
+      }
+    }
+  }, [method, resolvedAction, onSubmitStart, onSubmitEnd, replace, preventScrollReset, encType, fetcherKey, formContext, onSubmit]);
+  const formMethod = method.toLowerCase() === "get" ? "get" : "post";
+  return createElement2("form", {
+    ref: formRef,
+    method: formMethod,
+    action: resolvedAction,
+    encType,
+    onSubmit: handleSubmit,
+    ...props
+  }, method !== "get" && method !== "post" ? createElement2("input", {
+    type: "hidden",
+    name: "_method",
+    value: method.toUpperCase()
+  }) : null, children);
+}
+function useSubmit() {
+  const formContext = useFormContext();
+  const submit = useCallback4(async (target, options = {}) => {
+    const {
+      method = "post",
+      action,
+      replace = false,
+      preventScrollReset = false,
+      encType = "application/x-www-form-urlencoded",
+      fetcherKey
+    } = options;
+    if (typeof window === "undefined") {
+      return { status: 0, ok: false, error: new Error("Not in browser environment") };
+    }
+    const resolvedAction = action || window.location.pathname;
+    let formData;
+    if (target instanceof HTMLFormElement) {
+      formData = new FormData(target);
+    } else if (target instanceof FormData) {
+      formData = target;
+    } else if (target instanceof URLSearchParams) {
+      formData = new FormData;
+      target.forEach((value, key) => {
+        formData.append(key, value);
+      });
+    } else {
+      formData = new FormData;
+      for (const [key, value] of Object.entries(target)) {
+        formData.append(key, value);
+      }
+    }
+    if (formContext) {
+      formContext.setState("submitting");
+    }
+    try {
+      if (method.toLowerCase() === "get") {
+        const url = new URL(resolvedAction, window.location.origin);
+        const params = new URLSearchParams;
+        formData.forEach((value, key) => {
+          if (typeof value === "string") {
+            params.append(key, value);
+          }
+        });
+        url.search = params.toString();
+        await router.navigate(url.pathname + url.search, { replace });
+        if (formContext) {
+          formContext.setState("idle");
+        }
+        return { status: 200, ok: true };
+      }
+      let body;
+      if (encType === "application/x-www-form-urlencoded") {
+        body = new URLSearchParams;
+        formData.forEach((value, key) => {
+          if (typeof value === "string") {
+            body.append(key, value);
+          }
+        });
+      } else {
+        body = formData;
+      }
+      const response = await fetch(resolvedAction, {
+        method: method.toUpperCase(),
+        body,
+        headers: {
+          Accept: "application/json",
+          ...encType === "application/x-www-form-urlencoded" && {
+            "Content-Type": "application/x-www-form-urlencoded"
+          }
+        }
+      });
+      const result = {
+        status: response.status,
+        ok: response.ok
+      };
+      try {
+        const data = await response.json();
+        result.data = data;
+        if (formContext) {
+          formContext.setActionData(data);
+        }
+      } catch {}
+      if (response.ok && !fetcherKey) {
+        const redirectUrl = response.headers.get("X-Redirect-Url");
+        if (redirectUrl) {
+          await router.navigate(redirectUrl, { replace });
+        } else if (!preventScrollReset) {
+          window.scrollTo(0, 0);
+        }
+      }
+      if (formContext) {
+        formContext.setState("idle");
+      }
+      return result;
+    } catch (error) {
+      const result = {
+        error: error instanceof Error ? error : new Error(String(error)),
+        status: 0,
+        ok: false
+      };
+      if (formContext) {
+        formContext.setState("error");
+      }
+      return result;
+    }
+  }, [formContext]);
+  return submit;
+}
+function useFetcher(key) {
+  const [state, setStateInternal] = useState4("idle");
+  const [data, setData] = useState4(undefined);
+  const [error, setError] = useState4(undefined);
+  const [formData, setFormData] = useState4(undefined);
+  const [formMethod, setFormMethod] = useState4(undefined);
+  const [formAction, setFormAction] = useState4(undefined);
+  const mountedRef = useRef3(true);
+  useEffect3(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const safeSetState = useCallback4((newState) => {
+    if (mountedRef.current) {
+      setStateInternal(newState);
+    }
+  }, []);
+  const reset = useCallback4(() => {
+    if (mountedRef.current) {
+      setStateInternal("idle");
+      setData(undefined);
+      setError(undefined);
+      setFormData(undefined);
+      setFormMethod(undefined);
+      setFormAction(undefined);
+    }
+  }, []);
+  const submit = useCallback4(async (target, options = {}) => {
+    const {
+      method = "post",
+      action,
+      encType = "application/x-www-form-urlencoded"
+    } = options;
+    if (typeof window === "undefined") {
+      return;
+    }
+    const resolvedAction = action || window.location.pathname;
+    let newFormData;
+    if (target instanceof HTMLFormElement) {
+      newFormData = new FormData(target);
+    } else if (target instanceof FormData) {
+      newFormData = target;
+    } else if (target instanceof URLSearchParams) {
+      newFormData = new FormData;
+      target.forEach((value, key2) => {
+        newFormData.append(key2, value);
+      });
+    } else {
+      newFormData = new FormData;
+      for (const [key2, value] of Object.entries(target)) {
+        newFormData.append(key2, value);
+      }
+    }
+    setFormData(newFormData);
+    setFormMethod(method.toUpperCase());
+    setFormAction(resolvedAction);
+    safeSetState("submitting");
+    try {
+      if (method.toLowerCase() === "get") {
+        const url = new URL(resolvedAction, window.location.origin);
+        const params = new URLSearchParams;
+        newFormData.forEach((value, key2) => {
+          if (typeof value === "string") {
+            params.append(key2, value);
+          }
+        });
+        url.search = params.toString();
+        const response2 = await fetch(url.toString(), {
+          method: "GET",
+          headers: { Accept: "application/json" }
+        });
+        if (mountedRef.current) {
+          try {
+            const responseData = await response2.json();
+            setData(responseData);
+          } catch {}
+          safeSetState("idle");
+        }
+        return;
+      }
+      let body;
+      if (encType === "application/x-www-form-urlencoded") {
+        body = new URLSearchParams;
+        newFormData.forEach((value, key2) => {
+          if (typeof value === "string") {
+            body.append(key2, value);
+          }
+        });
+      } else {
+        body = newFormData;
+      }
+      const response = await fetch(resolvedAction, {
+        method: method.toUpperCase(),
+        body,
+        headers: {
+          Accept: "application/json",
+          ...encType === "application/x-www-form-urlencoded" && {
+            "Content-Type": "application/x-www-form-urlencoded"
+          }
+        }
+      });
+      if (mountedRef.current) {
+        try {
+          const responseData = await response.json();
+          setData(responseData);
+        } catch {}
+        safeSetState("idle");
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        safeSetState("error");
+      }
+    }
+  }, [safeSetState]);
+  const load = useCallback4(async (href) => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    setFormAction(href);
+    setFormMethod("GET");
+    safeSetState("loading");
+    try {
+      const response = await fetch(href, {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      if (mountedRef.current) {
+        try {
+          const responseData = await response.json();
+          setData(responseData);
+        } catch {}
+        safeSetState("idle");
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        safeSetState("error");
+      }
+    }
+  }, [safeSetState]);
+  const FetcherForm = useCallback4((formProps) => {
+    return Form({
+      ...formProps,
+      fetcherKey: key || "fetcher",
+      onSubmitStart: () => {
+        safeSetState("submitting");
+        if (formProps.onSubmitStart) {
+          formProps.onSubmitStart();
+        }
+      },
+      onSubmitEnd: (result) => {
+        if (mountedRef.current) {
+          if (result.ok) {
+            setData(result.data);
+            safeSetState("idle");
+          } else {
+            setError(result.error);
+            safeSetState("error");
+          }
+        }
+        if (formProps.onSubmitEnd) {
+          formProps.onSubmitEnd(result);
+        }
+      }
+    });
+  }, [key, safeSetState]);
+  return {
+    state,
+    data,
+    error,
+    formData,
+    formMethod,
+    formAction,
+    Form: FetcherForm,
+    submit,
+    load,
+    reset
+  };
+}
+function useActionData2() {
+  const context = useFormContext();
+  return context?.actionData;
+}
+function useNavigation2() {
+  const [navigationState, setNavigationState] = useState4(() => {
+    if (typeof window === "undefined") {
+      return { pathname: "/", search: "", hash: "" };
+    }
+    return router.getState();
+  });
+  const formContext = useFormContext();
+  useEffect3(() => {
+    return router.subscribe((event) => {
+      setNavigationState(event.to);
+    });
+  }, []);
+  return {
+    ...navigationState,
+    state: formContext?.state || "idle"
+  };
+}
+function serializeFormData(formData) {
+  const params = new URLSearchParams;
+  formData.forEach((value, key) => {
+    if (typeof value === "string") {
+      params.append(key, value);
+    }
+  });
+  return params.toString();
+}
+function parseFormData(data) {
+  const formData = new FormData;
+  const params = new URLSearchParams(data);
+  params.forEach((value, key) => {
+    formData.append(key, value);
+  });
+  return formData;
+}
+function formDataToObject(formData) {
+  const result = {};
+  formData.forEach((value, key) => {
+    if (typeof value === "string") {
+      if (key in result) {
+        const existing = result[key];
+        if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          result[key] = [existing, value];
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  });
+  return result;
+}
+function objectToFormData(obj) {
+  const formData = new FormData;
+  for (const [key, value] of Object.entries(obj)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => formData.append(key, String(v)));
+    } else {
+      formData.append(key, String(value));
+    }
+  }
+  return formData;
+}
+// src/error-boundary.tsx
+import React3, {
+  Component,
+  useContext as useContext3
+} from "react";
+class ErrorBoundary extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      error: null,
+      errorInfo: null
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.setState({ errorInfo });
+    if (this.props.onError) {
+      this.props.onError(error, errorInfo);
+    }
+  }
+  reset = () => {
+    this.setState({
+      error: null,
+      errorInfo: null
+    });
+  };
+  render() {
+    const { error } = this.state;
+    const { fallback, children } = this.props;
+    if (error) {
+      if (typeof fallback === "function") {
+        return fallback(error, this.reset);
+      }
+      if (fallback !== undefined) {
+        return fallback;
+      }
+      return React3.createElement("div", {
+        style: {
+          padding: "20px",
+          border: "1px solid #f5c6cb",
+          borderRadius: "4px",
+          backgroundColor: "#f8d7da",
+          color: "#721c24"
+        }
+      }, React3.createElement("h2", null, "Something went wrong"), React3.createElement("p", null, error.message), React3.createElement("button", {
+        onClick: this.reset,
+        style: {
+          padding: "8px 16px",
+          backgroundColor: "#721c24",
+          color: "white",
+          border: "none",
+          borderRadius: "4px",
+          cursor: "pointer"
+        }
+      }, "Try again"));
+    }
+    return children;
+  }
+}
+function useErrorBoundary() {
+  const context = useContext3(ErrorContext);
+  if (!context) {
+    throw new Error("useErrorBoundary must be used within an EreoProvider or ErrorProvider. " + "Make sure your component is wrapped with the appropriate provider.");
+  }
+  return {
+    error: context.error,
+    reset: context.clearError,
+    showBoundary: (error) => context.setError(error)
+  };
+}
+function useRouteError() {
+  const context = useContext3(ErrorContext);
+  return context?.error;
+}
+
+class RouteErrorBoundary extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      error: null,
+      errorInfo: null,
+      retryCount: 0
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.setState({ errorInfo });
+    const { errorConfig, routeId } = this.props;
+    if (errorConfig?.reportError) {
+      errorConfig.reportError(error, {
+        route: routeId,
+        phase: "render"
+      });
+    }
+    if (errorConfig?.onError === "silent") {
+      console.error(`[Route ${routeId}] Error:`, error);
+    } else if (errorConfig?.onError === "redirect") {
+      console.error(`[Route ${routeId}] Error (redirect mode):`, error);
+    } else if (errorConfig?.onError === "toast") {
+      console.error(`[Route ${routeId}] Error (toast mode):`, error);
+    }
+  }
+  reset = () => {
+    const { errorConfig } = this.props;
+    const { retryCount } = this.state;
+    if (errorConfig?.retry && retryCount < errorConfig.retry.count) {
+      setTimeout(() => {
+        this.setState((prevState) => ({
+          error: null,
+          errorInfo: null,
+          retryCount: prevState.retryCount + 1
+        }));
+      }, errorConfig.retry.delay);
+    } else {
+      this.setState({
+        error: null,
+        errorInfo: null,
+        retryCount: 0
+      });
+    }
+  };
+  render() {
+    const { error } = this.state;
+    const { children, fallbackComponent: FallbackComponent, errorConfig, params = {} } = this.props;
+    if (error) {
+      if (errorConfig?.maxCaptures !== undefined && this.state.retryCount >= errorConfig.maxCaptures) {
+        return React3.createElement("div", { style: { padding: "20px", color: "#721c24" } }, "Error limit exceeded. Please refresh the page.");
+      }
+      if (FallbackComponent) {
+        return React3.createElement(FallbackComponent, { error, params });
+      }
+      if (errorConfig?.fallback) {
+        return React3.createElement(errorConfig.fallback, {});
+      }
+      return React3.createElement("div", {
+        style: {
+          padding: "20px",
+          border: "1px solid #f5c6cb",
+          borderRadius: "4px",
+          backgroundColor: "#f8d7da",
+          color: "#721c24"
+        }
+      }, React3.createElement("h2", null, "Route Error"), React3.createElement("p", null, error.message), React3.createElement("button", {
+        onClick: this.reset,
+        style: {
+          padding: "8px 16px",
+          backgroundColor: "#721c24",
+          color: "white",
+          border: "none",
+          borderRadius: "4px",
+          cursor: "pointer"
+        }
+      }, "Retry"));
+    }
+    return children;
+  }
+}
+function isRouteErrorResponse(error) {
+  return typeof error === "object" && error !== null && "status" in error && "statusText" in error && "data" in error && typeof error.status === "number" && typeof error.statusText === "string";
+}
+function createRouteErrorResponse(status, statusText, data = null) {
+  return {
+    status,
+    statusText,
+    data,
+    internal: false
+  };
+}
+function withErrorBoundary(WrappedComponent, errorBoundaryProps) {
+  const displayName = WrappedComponent.displayName || WrappedComponent.name || "Component";
+  const ComponentWithErrorBoundary = (props) => {
+    const boundaryProps = {
+      ...errorBoundaryProps || {},
+      children: React3.createElement(WrappedComponent, props)
+    };
+    return React3.createElement(ErrorBoundary, boundaryProps);
+  };
+  ComponentWithErrorBoundary.displayName = `withErrorBoundary(${displayName})`;
+  return ComponentWithErrorBoundary;
+}
+
+class RouteError extends Error {
+  status;
+  statusText;
+  data;
+  constructor(status, statusText, data) {
+    super(`${status} ${statusText}`);
+    this.name = "RouteError";
+    this.status = status;
+    this.statusText = statusText;
+    this.data = data;
+  }
+  toResponse() {
+    return {
+      status: this.status,
+      statusText: this.statusText,
+      data: this.data
+    };
+  }
+}
+
+// src/index.ts
+function initClient() {
+  initializeIslands();
+  setupScrollRestoration();
+  setupAutoPrefetch({ strategy: "hover" });
+}
+export {
+  withErrorBoundary,
+  useTypedNavigate,
+  useSubmit,
+  useRouteError,
+  useNavigationContext,
+  useNavigation,
+  useLoaderDataContext,
+  useLoaderData,
+  useIsRouteActive,
+  useIsActive,
+  useNavigation2 as useFormNavigation,
+  useFormContext,
+  useActionData2 as useFormActionData,
+  useFetcher,
+  useErrorContext,
+  useErrorBoundary,
+  useError,
+  useActionDataContext,
+  useActionData,
+  typedRedirect,
+  typedNavigate,
+  goForward2 as typedGoForward,
+  goBack2 as typedGoBack,
+  submitAction,
+  stripHydrationProps,
+  shouldHydrate,
+  setupScrollRestoration,
+  setupLinkPrefetch,
+  setupAutoPrefetch,
+  serializeFormData,
+  router,
+  resetIslandCounter,
+  registerIslandComponents,
+  registerIslandComponent,
+  redirect,
+  preloadRoute,
+  prefetchAll,
+  prefetch,
+  parseTypedSearchParams,
+  parseTypedHashParams,
+  parseHydrationDirective,
+  parseFormData,
+  onNavigate,
+  objectToFormData,
+  navigate,
+  islandRegistry,
+  isRouteErrorResponse,
+  isPrefetching,
+  isPrefetched,
+  isCurrentPath,
+  initializeIslands,
+  initClient,
+  hydrateIslands,
+  goForward,
+  goBack,
+  go,
+  getPrefetchedData,
+  getNavigationState,
+  getIslandCount,
+  getIslandComponent,
+  generateIslandId,
+  formDataToObject,
+  fetchLoaderData,
+  createRouteErrorResponse,
+  createIsland,
+  createHydrationTrigger,
+  clearPrefetchCache,
+  cleanupIslands,
+  buildUrl,
+  buildTypedUrl,
+  TypedNavLink,
+  TypedLink,
+  RouteErrorBoundary,
+  RouteError,
+  NavigationProvider,
+  NavigationContext,
+  NavLink,
+  LoaderDataProvider,
+  LoaderDataContext,
+  Link,
+  FormProvider,
+  Form,
+  ErrorProvider,
+  ErrorContext,
+  ErrorBoundary,
+  EreoProvider,
+  ActionDataProvider,
+  ActionDataContext
+};