@fluixi/core 1.0.0-alpha.100

package/dist/src/cdn/chunk-RKBFEFZP.mjs

@@ -0,0 +1,987 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/lib/router/index.ts
+import {
+  createSignal as createSignal2,
+  createMemo as createMemo2,
+  createResource as createResource3,
+  createEffect,
+  createRoot,
+  getOwner as getOwner2,
+  onCleanup,
+  runWithOwner,
+  untrack as untrack2,
+  flush
+} from "@fluixi/reactive/signal";
+
+// src/lib/router/transition.ts
+function supportsViewTransitions() {
+  return typeof document !== "undefined" && typeof document.startViewTransition === "function";
+}
+function prefersReducedMotion() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  try {
+    return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  } catch {
+    return false;
+  }
+}
+function shouldAnimate(mode) {
+  return mode !== "none" && supportsViewTransitions() && !prefersReducedMotion();
+}
+function prepareComponents(components) {
+  const pending = [];
+  for (const component of components) {
+    const preload = component?.preload;
+    if (typeof preload === "function") {
+      try {
+        const result = preload();
+        if (result && typeof result.then === "function") {
+          pending.push(result.catch(() => void 0));
+        }
+      } catch {
+      }
+    }
+  }
+  return pending.length ? Promise.all(pending).then(() => void 0) : null;
+}
+function runTransition(mode, commit) {
+  if (!shouldAnimate(mode)) {
+    return Promise.resolve(commit()).then(() => void 0);
+  }
+  const start = document.startViewTransition;
+  try {
+    const transition = start.call(document, () => commit());
+    transition.finished?.catch(() => void 0);
+    transition.ready?.catch(() => void 0);
+    return transition.updateCallbackDone.catch(() => void 0);
+  } catch {
+    return Promise.resolve(commit()).then(() => void 0);
+  }
+}
+
+// src/lib/router/index.ts
+import {
+  insert,
+  createComponent as createComponent2,
+  createNativeElement,
+  setAttribute
+} from "@fluixi/dom";
+import { createContext as createContext2, useContext as useContext2 } from "@fluixi/reactive/signal";
+import { get } from "@fluixi/utils/object";
+import { deepEqual } from "@fluixi/utils/compare";
+
+// src/lib/router/scroll.ts
+var STORE = "fx:scroll";
+var KEEP = 100;
+function keepScroll(initial) {
+  const read2 = () => {
+    try {
+      return JSON.parse(sessionStorage.getItem(STORE) ?? "{}");
+    } catch {
+      return {};
+    }
+  };
+  const positions = read2();
+  const write = () => {
+    const keys = Object.keys(positions);
+    for (const key of keys.slice(0, Math.max(0, keys.length - KEEP))) delete positions[key];
+    try {
+      sessionStorage.setItem(STORE, JSON.stringify(positions));
+    } catch {
+    }
+  };
+  let current = initial.key;
+  const save = () => {
+    if (current === void 0) return;
+    delete positions[current];
+    positions[current] = window.scrollY;
+    write();
+  };
+  const restoration = history.scrollRestoration;
+  history.scrollRestoration = "manual";
+  window.addEventListener("pagehide", save);
+  const to = (top) => window.scrollTo({ top, left: 0, behavior: "instant" });
+  const toHash = (hash) => {
+    if (!hash || hash === "#") return false;
+    const target = document.getElementById(decodeURIComponent(hash.slice(1)));
+    target?.scrollIntoView({ behavior: "instant" });
+    return target !== null;
+  };
+  return {
+    leave: save,
+    arrive(location, from) {
+      current = location.key;
+      if (location.action === "pop" || from === void 0) {
+        const y = location.key === void 0 ? void 0 : positions[location.key];
+        if (y !== void 0) to(y);
+        return;
+      }
+      if (location.action === "replace" && location.pathname === from.pathname) return;
+      if (!toHash(location.hash)) to(0);
+    },
+    dispose() {
+      window.removeEventListener("pagehide", save);
+      history.scrollRestoration = restoration;
+    }
+  };
+}
+
+// src/lib/router/index.ts
+import {
+  createRouter as createCoreRouter,
+  createBrowserHistory,
+  matchRoutes,
+  matchPath
+} from "@fluixi/router";
+
+// src/lib/router/data.ts
+import {
+  createResource,
+  createSignal
+} from "@fluixi/reactive/signal";
+import { currentResourceCache } from "@fluixi/reactive/signal";
+
+// src/lib/context/context.ts
+import { asProvider } from "@fluixi/dom";
+import {
+  createContext as createReactiveContext,
+  getOwner,
+  useContext as useReactiveContext
+} from "@fluixi/reactive/signal";
+function createContext(defaultValue, name) {
+  const context = createReactiveContext(defaultValue, name);
+  const Provider = (props) => (
+    // Children stay a getter: the reactive Provider reads them after stamping the value on
+    // its owner. Reading `props.children` here would render them, and any <Outlet/> in them,
+    // before the context exists.
+    context.Provider({
+      value: props.value,
+      get children() {
+        return props.children;
+      },
+      debug: props.debug
+    })
+  );
+  return {
+    id: context.id,
+    Provider: asProvider(Provider),
+    defaultValue
+  };
+}
+function useContext(context) {
+  const value = useReactiveContext(context);
+  return value !== void 0 ? value : context.defaultValue;
+}
+function createProvider(context, value, props) {
+  const resolved = typeof value === "function" ? value() : value;
+  return context.Provider({
+    value: resolved,
+    get children() {
+      return props.children;
+    }
+  });
+}
+function composeProviders(providers, props) {
+  const outermost = providers.reduceRight(
+    (inner, [context, value]) => ({
+      get children() {
+        return createProvider(context, value, inner);
+      }
+    }),
+    props
+  );
+  return outermost.children;
+}
+function requireContext(context, message) {
+  for (let owner = getOwner(); owner; owner = owner.parent) {
+    if (owner.contexts?.has(context.id)) return useContext(context);
+  }
+  throw new Error(message ?? `[fluixi] No Provider for ${context.id.description ?? "this context"} above this component.`);
+}
+
+// src/lib/router/data.ts
+var revalidationListeners = /* @__PURE__ */ new Set();
+function onRevalidate(listener) {
+  revalidationListeners.add(listener);
+  return () => void revalidationListeners.delete(listener);
+}
+var reloadMounted = () => {
+  for (const listener of [...revalidationListeners]) listener();
+};
+function cache(fn, name, options = {}) {
+  const { ttl = Infinity, staleWhileRevalidate = true } = options;
+  return (...args) => {
+    const store = options.cache ?? currentResourceCache();
+    const key = name + ":" + JSON.stringify(args);
+    const fetchFresh = () => {
+      const running = store.inflight.get(key);
+      if (running) return running;
+      const promise = Promise.resolve(fn(...args)).then(
+        (value) => {
+          store.set(key, { value, timestamp: Date.now() });
+          store.inflight.delete(key);
+          return value;
+        },
+        (error) => {
+          store.inflight.delete(key);
+          throw error;
+        }
+      );
+      store.inflight.set(key, promise);
+      return promise;
+    };
+    const hit = store.get(key);
+    if (hit && (ttl === Infinity || Date.now() - hit.timestamp <= ttl)) return Promise.resolve(hit.value);
+    if (hit && staleWhileRevalidate) {
+      fetchFresh().then(reloadMounted, () => void 0);
+      return Promise.resolve(hit.value);
+    }
+    return fetchFresh();
+  };
+}
+function revalidate(key, store) {
+  const names = typeof key === "string" ? [key] : Array.isArray(key) ? key : null;
+  drop(names ?? key, store ?? currentResourceCache());
+  if (names && !store) tellOtherTabs(names);
+}
+function drop(what, store) {
+  const matches = Array.isArray(what) ? (k) => what.some((n) => k === n || k.startsWith(n + ":")) : what;
+  for (const k of [...store.keys()]) if (matches(k)) store.delete(k);
+  reloadMounted();
+}
+var TABS_KEY = "fluixi:revalidate";
+function tellOtherTabs(names) {
+  try {
+    localStorage.setItem(TABS_KEY, JSON.stringify({ names, at: Date.now() + Math.random() }));
+  } catch {
+  }
+}
+if (typeof window !== "undefined") {
+  window.addEventListener("storage", (event) => {
+    if (event.key !== TABS_KEY || !event.newValue) return;
+    try {
+      const names = JSON.parse(event.newValue).names;
+      if (Array.isArray(names) && names.every((n) => typeof n === "string")) drop(names, currentResourceCache());
+    } catch {
+    }
+  });
+}
+globalThis[/* @__PURE__ */ Symbol.for("fluixi.revalidate")] = (names) => revalidate(names);
+function createAsync(fetcher, source) {
+  const [data] = createResource(source || (() => true), fetcher);
+  return data;
+}
+var submissionState = /* @__PURE__ */ new Map();
+function getSubmissionSignal(url) {
+  if (!submissionState.has(url)) {
+    submissionState.set(
+      url,
+      createSignal(void 0)
+    );
+  }
+  return submissionState.get(url);
+}
+var submissionsState = /* @__PURE__ */ new Map();
+function getSubmissionsSignal(url) {
+  if (!submissionsState.has(url)) submissionsState.set(url, createSignal([]));
+  return submissionsState.get(url);
+}
+function action(fn, name, options = {}) {
+  const actionUrl = name || fn.name || "action";
+  const submit = async (...args) => {
+    const input = args.length > 1 ? args : args[0];
+    const [, setSubmission] = getSubmissionSignal(actionUrl);
+    const [, setSubmissions] = getSubmissionsSignal(actionUrl);
+    let entry;
+    const drop2 = () => setSubmissions((list) => list.filter((s) => s !== entry));
+    const settle = (next) => {
+      setSubmissions((list) => list.map((s) => s === entry ? next : s));
+      entry = next;
+    };
+    const clear = () => {
+      setSubmission(void 0);
+      drop2();
+    };
+    const retry = () => {
+      drop2();
+      return submit(...args);
+    };
+    entry = {
+      input,
+      pending: true,
+      clear,
+      retry
+    };
+    setSubmission(entry);
+    setSubmissions((list) => [...list, entry]);
+    try {
+      const result = await fn(...args);
+      setSubmission({
+        input,
+        result,
+        pending: false,
+        clear,
+        retry
+      });
+      drop2();
+      const stale = typeof options.invalidates === "function" ? options.invalidates(result) : options.invalidates;
+      for (const key of stale ?? []) revalidate(key);
+      return result;
+    } catch (error) {
+      const failed = {
+        input,
+        error,
+        pending: false,
+        clear,
+        retry
+      };
+      setSubmission(failed);
+      settle(failed);
+      throw error;
+    }
+  };
+  submit.url = actionUrl;
+  submit.with = (args) => action((...a) => fn(args, ...a), name, options);
+  return submit;
+}
+function useSubmission(actionFn) {
+  const [submission] = getSubmissionSignal(actionFn.url);
+  return submission;
+}
+function useSubmissions(actionFn) {
+  const [submissions] = getSubmissionsSignal(actionFn.url);
+  return submissions;
+}
+function useAction(actionFn) {
+  return actionFn;
+}
+var RouteDataContext = createContext(void 0, "route-data");
+var RouteDataProvider = RouteDataContext.Provider;
+
+// src/lib/router/index.ts
+import {
+  createMemoryHistory,
+  createBrowserHistory as createBrowserHistory2,
+  matchRoutes as matchRoutes2,
+  matchPath as matchPath2
+} from "@fluixi/router";
+
+// src/lib/render/lazy.ts
+import { createComponent } from "@fluixi/dom";
+import {
+  untrack,
+  createMemo,
+  createResource as createResource2
+} from "@fluixi/reactive/signal";
+function fromChunk(value) {
+  if (value != null && (typeof value === "object" || typeof value === "function")) {
+    try {
+      value["$lazy"] = true;
+    } catch {
+    }
+  }
+  return value;
+}
+function lazy(loader, options) {
+  let resolved;
+  let promise;
+  let component;
+  function load() {
+    if (!promise) {
+      promise = loader().then((mod) => resolved = mod.default);
+    }
+    return promise;
+  }
+  if (options?.preload) load();
+  const LazyWrapper = ((props) => {
+    if (resolved) {
+      const C = resolved;
+      return fromChunk(untrack(() => C(props)));
+    }
+    if (!component) {
+      const [resource] = createResource2(() => load(), { transport: false });
+      component = resource;
+      if (resource.error) throw resource.error;
+    }
+    return createMemo(() => {
+      const C = component();
+      return C ? fromChunk(createComponent(C, props)) : void 0;
+    });
+  });
+  LazyWrapper.preload = () => load().then(() => void 0);
+  LazyWrapper.$lazy = true;
+  LazyWrapper.loader = loader;
+  return LazyWrapper;
+}
+
+// src/lib/router/index.ts
+import { runWithOwner as runWithOwner2 } from "@fluixi/reactive/signal";
+var RouterContext = createContext2(void 0, "router");
+var OutletContext = createContext2(void 0, "outlet");
+var LevelParamsContext = createContext2(void 0, "route-params");
+var RouteDataContext2 = createContext2(void 0, "route-data");
+function renderLayer(m, depth, base) {
+  let data;
+  const loader = m.route.data;
+  if (typeof loader === "function") {
+    let cancelled = false;
+    onCleanup(() => {
+      cancelled = true;
+    });
+    const owner = getOwner2();
+    const router = useContext2(RouterContext);
+    let watching = false;
+    const trackDeps = (deps) => {
+      if (watching || cancelled) return;
+      watching = true;
+      runWithOwner(owner, () => {
+        let first = true;
+        createEffect(() => {
+          deps();
+          if (first) first = false;
+          else untrack2(() => void refetch());
+        });
+      });
+    };
+    let readsLocation;
+    const [resource, { refetch }] = createResource3(() => {
+      const params = untrack2(base.params);
+      const location = untrack2(base.location);
+      readsLocation = false;
+      const result = loader(
+        {
+          params: () => params,
+          location: () => {
+            readsLocation = true;
+            return location;
+          }
+        },
+        owner,
+        () => cancelled,
+        trackDeps
+      );
+      return router ? router.trackLoad(result) : result;
+    });
+    onCleanup(
+      onRevalidate(() => {
+        if (untrack2(() => base.matched()[depth]?.route) !== m.route) return;
+        void refetch();
+      })
+    );
+    let loadedFor = untrack2(() => JSON.stringify(base.matched()[depth]?.params ?? {}));
+    let searchedFor = untrack2(() => base.location().search);
+    createEffect(() => {
+      const now = base.matched()[depth];
+      const search = base.location().search;
+      if (now?.route !== m.route) return;
+      const params = JSON.stringify(now.params ?? {});
+      const paramsMoved = params !== loadedFor;
+      const searchMoved = readsLocation !== false && search !== searchedFor;
+      loadedFor = params;
+      searchedFor = search;
+      if (paramsMoved || searchMoved) untrack2(() => void refetch());
+    });
+    data = () => {
+      const error = resource.error;
+      if (error !== void 0 && error !== null) throw error;
+      const r = resource;
+      if (r.state === "refreshing") return r.latest;
+      return resource();
+    };
+    Object.defineProperty(data, "loading", { get: () => resource.loading });
+    Object.defineProperty(data, "state", { get: () => resource.state });
+  }
+  const buildPage = () => RouteDataContext2.Provider({
+    value: data,
+    get children() {
+      return LevelParamsContext.Provider({
+        value: m.params,
+        get children() {
+          return OutletContext.Provider({
+            value: { depth, ...base },
+            get children() {
+              return createComponent2(m.component, {});
+            }
+          });
+        }
+      });
+    }
+  });
+  if (!data) return { view: buildPage(), ready: () => true };
+  const res = data;
+  const isLoading = () => {
+    const state = res.state;
+    return state === void 0 ? res.loading : state === "pending" || state === "unresolved";
+  };
+  const [ready, setReady] = createSignal2(untrack2(() => !isLoading()));
+  createEffect(() => setReady(!isLoading()));
+  return { view: createMemo2(() => ready() ? buildPage() : null), ready };
+}
+function renderChild(ctx) {
+  const childIdx = ctx.depth + 1;
+  const [childComp, setChildComp] = createSignal2(
+    untrack2(() => ctx.matched()[childIdx]?.component)
+  );
+  createEffect(() => {
+    const c = ctx.matched()[childIdx]?.component;
+    if (untrack2(childComp) !== c) setChildComp(() => c);
+  });
+  const owner = getOwner2();
+  let shown = null;
+  let pending = null;
+  const drop2 = (layer) => layer?.dispose();
+  onCleanup(() => {
+    drop2(shown);
+    drop2(pending);
+    shown = pending = null;
+  });
+  const incoming = createMemo2(() => {
+    const component = childComp();
+    if (!component) return null;
+    const m = untrack2(() => ctx.matched())[childIdx];
+    return runWithOwner(
+      owner,
+      () => createRoot((dispose) => ({
+        ...renderLayer(m, childIdx, { matched: ctx.matched, params: ctx.params, location: ctx.location }),
+        dispose
+      }))
+    );
+  });
+  return createMemo2(() => {
+    const next = incoming();
+    if (!next) {
+      drop2(shown);
+      drop2(pending);
+      shown = pending = null;
+      return ctx.notFound ? ctx.notFound() : null;
+    }
+    if (next === shown) return shown.view;
+    if (pending && pending !== next) drop2(pending);
+    pending = next;
+    if (shown && !next.ready()) return shown.view;
+    drop2(shown);
+    shown = next;
+    pending = null;
+    return shown.view;
+  });
+}
+function renderNotFound(notFound) {
+  if (notFound == null) return buildDefaultNotFound();
+  return typeof notFound === "function" ? createComponent2(notFound, {}) : notFound;
+}
+function buildDefaultNotFound() {
+  const el = createNativeElement("div");
+  setAttribute(el, "class", "fx-not-found");
+  setAttribute(el, "role", "main");
+  setAttribute(
+    el,
+    "style",
+    "min-height:60vh;display:grid;place-content:center;gap:.25rem;text-align:center;font-family:system-ui,-apple-system,sans-serif"
+  );
+  const h1 = createNativeElement("h1");
+  setAttribute(h1, "style", "margin:0;font-size:2.5rem;font-weight:700");
+  insert(h1, "404");
+  const p = createNativeElement("p");
+  setAttribute(p, "style", "margin:0;opacity:.7");
+  insert(p, "This page could not be found.");
+  el.appendChild(h1);
+  el.appendChild(p);
+  return el;
+}
+var pendingTransitionMode;
+function Router(props) {
+  const history2 = props.history ?? createBrowserHistory();
+  const router = createCoreRouter({
+    routes: props.routes,
+    base: props.base,
+    history: history2
+  });
+  const [state, setState] = createSignal2(router.state());
+  const [navigating, setNavigating] = createSignal2(false);
+  const [loads, setLoads] = createSignal2(0);
+  let navigationId = 0;
+  const scroll = history2.window ? keepScroll(router.state().location) : void 0;
+  let arriving = scroll ? { id: 0, location: router.state().location, from: void 0 } : null;
+  const [arrived, setArrived] = createSignal2(0);
+  const takeMode = () => {
+    const mode = pendingTransitionMode ?? (props.transition ?? "auto");
+    pendingTransitionMode = void 0;
+    return mode;
+  };
+  const unsub = router.subscribe((next) => {
+    const id = ++navigationId;
+    const mode = takeMode();
+    setNavigating(true);
+    if (scroll) {
+      scroll.leave();
+      arriving = { id, location: next.location, from: untrack2(state).location };
+    }
+    const prepared = prepareComponents(
+      (next.match?.matched ?? []).map((m) => m.component).filter(Boolean)
+    );
+    const commit = () => {
+      setState(next);
+      const flushed = flush();
+      if (id === navigationId) setNavigating(false);
+      if (scroll) setArrived(id);
+      return flushed;
+    };
+    if (!prepared) {
+      void runTransition(mode, commit);
+      return;
+    }
+    void prepared.then(() => {
+      if (id !== navigationId) return;
+      return runTransition(mode, commit);
+    });
+  });
+  onCleanup(() => {
+    unsub();
+    scroll?.dispose();
+    router.destroy();
+    navigationId++;
+  });
+  const matched = createMemo2(
+    () => (state().match?.matched ?? []).filter((m) => m.component)
+  );
+  const ctx = {
+    router,
+    location: createMemo2(() => state().location),
+    params: createMemo2(() => state().match?.params ?? {}),
+    isRouting: () => navigating() || loads() > 0,
+    // Counted by the promise, not by an owner: a load a newer navigation superseded still
+    // settles and uncounts itself, and a resource seeded from the server never calls it.
+    trackLoad(result) {
+      if (result && typeof result.finally === "function") {
+        setLoads((n) => n + 1);
+        void result.finally(() => setLoads((n) => n - 1)).catch(() => {
+        });
+      }
+      return result;
+    }
+  };
+  if (scroll) {
+    const nextFrame = typeof requestAnimationFrame === "function" ? requestAnimationFrame : (fn) => setTimeout(fn, 0);
+    createEffect(() => {
+      const id = arrived();
+      if (ctx.isRouting()) return;
+      const next = arriving;
+      if (!next || next.id !== id || id !== navigationId) return;
+      arriving = null;
+      nextFrame(() => {
+        if (id === navigationId) scroll.arrive(next.location, next.from);
+      });
+    });
+  }
+  const root = {
+    depth: -1,
+    matched,
+    params: ctx.params,
+    location: ctx.location,
+    // Only the root carries this: renderChild shows it when the URL matched nothing.
+    notFound: () => renderNotFound(props.notFound)
+  };
+  let rootView;
+  return RouterContext.Provider({
+    value: ctx,
+    get children() {
+      return rootView ??= renderChild(root);
+    }
+  });
+}
+function Outlet() {
+  const ctx = useContext2(OutletContext);
+  if (!ctx) return null;
+  return renderChild(ctx);
+}
+function useIsRouting(options = {}) {
+  const routing = useContext2(RouterContext)?.isRouting ?? (() => false);
+  const delay = options.delay ?? 0;
+  if (delay <= 0) return routing;
+  const [late, setLate] = createSignal2(false);
+  createEffect(() => {
+    if (!routing()) {
+      setLate(false);
+      return;
+    }
+    const timer = setTimeout(() => setLate(true), delay);
+    onCleanup(() => clearTimeout(timer));
+  });
+  return () => routing() && late();
+}
+function Redirect(props) {
+  const ctx = useContext2(RouterContext);
+  if (ctx && typeof window !== "undefined") {
+    let cancelled = false;
+    onCleanup(() => cancelled = true);
+    queueMicrotask(() => {
+      if (!cancelled) ctx.router.navigate(props.to, { replace: props.replace !== false });
+    });
+  }
+  return null;
+}
+var _ssrRouterStub = {
+  router: { navigate: () => {
+  } },
+  location: () => ({ pathname: "", search: "", hash: "", query: {} }),
+  params: () => ({}),
+  isRouting: () => false,
+  trackLoad: (result) => result
+};
+function useRouter() {
+  const ctx = useContext2(RouterContext);
+  if (ctx) return ctx;
+  if (typeof window === "undefined") return _ssrRouterStub;
+  throw new Error("[router] useRouter must be used within <Router>");
+}
+function useParams() {
+  const params = useRouter().params;
+  return createMemo2(() => params(), {}, {
+    equals: (a, b) => JSON.stringify(a) === JSON.stringify(b)
+  });
+}
+function useLevelParams() {
+  return useContext2(LevelParamsContext) ?? {};
+}
+function useParam(key) {
+  const params = useParams();
+  return createMemo2(() => params()[key]);
+}
+function useParamSelector(selector, equals) {
+  const params = useParams();
+  return createMemo2(
+    () => selector(params()),
+    void 0,
+    equals ? { equals } : void 0
+  );
+}
+function useMatch(path) {
+  const location = useLocation();
+  return createMemo2(
+    () => matchPath(typeof path === "function" ? path() : path, location.pathname)
+  );
+}
+function useSearchParams() {
+  const location = useLocation();
+  const navigate = useNavigate();
+  const params = createMemo2(() => location.query);
+  const setParams = (next, options) => {
+    const current = new URLSearchParams(location.search);
+    for (const [k, v] of Object.entries(next)) {
+      if (v === null) current.delete(k);
+      else current.set(k, v);
+    }
+    const search = current.toString();
+    navigate(location.pathname + (search ? `?${search}` : ""), options);
+  };
+  return [params, setParams];
+}
+function select(source, key) {
+  const equals = (a, b) => deepEqual(a, b);
+  if (key !== void 0) {
+    return createMemo2(
+      () => get(source(), key),
+      void 0,
+      { equals }
+    );
+  }
+  return createMemo2(source, void 0, { equals });
+}
+function useLocation() {
+  const { location } = useRouter();
+  return new Proxy({}, {
+    get: (_t, key) => location()[key],
+    has: (_t, key) => key in location(),
+    ownKeys: () => Reflect.ownKeys(location()),
+    getOwnPropertyDescriptor: (_t, key) => Object.getOwnPropertyDescriptor(location(), key)
+  });
+}
+function useLinkNavigation(options = {}) {
+  const ctx = useContext2(RouterContext);
+  return (event) => {
+    if (!ctx || event.defaultPrevented || event.button !== 0) return;
+    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+    const target = event.target;
+    const anchor = target?.closest?.("a");
+    if (!anchor || !anchor.getAttribute("href")) return;
+    if (anchor.target && anchor.target !== "_self") return;
+    if (anchor.hasAttribute("download")) return;
+    if (/(^|\s)external(\s|$)/.test(anchor.getAttribute("rel") ?? "")) return;
+    const url = new URL(anchor.href);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return;
+    if (url.origin !== window.location.origin) return;
+    if (url.hash && url.pathname === window.location.pathname && url.search === window.location.search) return;
+    if (options.shouldNavigate && !options.shouldNavigate(url, anchor)) return;
+    event.preventDefault();
+    pendingTransitionMode = options.transition;
+    ctx.router.navigate(url.pathname + url.search + url.hash, { replace: options.replace });
+  };
+}
+function useNavigate() {
+  const { router } = useRouter();
+  return (to, options) => {
+    pendingTransitionMode = options?.transition;
+    router.navigate(to, options);
+  };
+}
+function useRouteData() {
+  const acc = useContext2(RouteDataContext2);
+  return acc ?? (() => void 0);
+}
+var read = (v) => typeof v === "function" ? v() : v;
+var LINK_OWN_PROPS = /* @__PURE__ */ new Set([
+  "href",
+  "slot",
+  "class",
+  "className",
+  "active",
+  "activeClass",
+  "replace",
+  "children"
+]);
+function Link(props) {
+  const ctx = useContext2(RouterContext);
+  const navigate = () => ctx.router.navigate(read(props.href) ?? "", { replace: read(props.replace) });
+  const a = createNativeElement("a");
+  setAttribute(a, "href", read(props.href) ?? "");
+  if (props.slot) setAttribute(a, "slot", read(props.slot));
+  for (const k of Object.keys(props)) {
+    if (LINK_OWN_PROPS.has(k)) continue;
+    const v = props[k];
+    if (typeof v === "function") {
+      if (/^on[A-Z]/.test(k)) continue;
+      const read2 = v;
+      const apply = () => {
+        const value = read2();
+        if (value == null || value === false) a.removeAttribute?.(k);
+        else setAttribute(a, k, String(value));
+      };
+      if (typeof a.addEventListener === "function") createEffect(apply);
+      else apply();
+      continue;
+    }
+    if (v != null) setAttribute(a, k, String(v));
+  }
+  if (typeof a.addEventListener === "function") {
+    a.addEventListener("click", (e) => {
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      if (!ctx) return;
+      e.preventDefault();
+      navigate();
+    });
+  } else {
+    const base = read(props.className ?? props.class) ?? "";
+    if (base) setAttribute(a, "class", base);
+  }
+  if (typeof a.addEventListener === "function") {
+    createEffect(() => {
+      const href = read(props.href) ?? "";
+      a.setAttribute("href", href);
+      const base = read(props.className ?? props.class) ?? "";
+      const activeClass = read(props.activeClass) ?? "";
+      const active = read(props.active) ?? ctx?.location().pathname === href;
+      a.className = [base, active ? activeClass : ""].filter(Boolean).join(" ");
+    });
+  }
+  const linkChildren = props.children;
+  if (linkChildren != null) insert(a, linkChildren);
+  return a;
+}
+var A = Link;
+function ActionForm(props) {
+  const action2 = props.action;
+  const cls = props.className ?? props.class;
+  const url = action2.url ?? "";
+  const form = createNativeElement("form");
+  setAttribute(form, "method", "post");
+  if (url) setAttribute(form, "action", url);
+  if (cls) setAttribute(form, "class", cls);
+  for (const k of Object.keys(props)) {
+    if (k === "action" || k === "children" || k === "class" || k === "className") continue;
+    const v = props[k];
+    if (v != null && typeof v !== "function") setAttribute(form, k, String(v));
+  }
+  if (typeof form.addEventListener === "function") {
+    form.addEventListener("submit", (e) => {
+      e.preventDefault();
+      const data = {};
+      new FormData(form).forEach((v, k) => {
+        data[k] = v;
+      });
+      Promise.resolve(action2(data)).catch(() => {
+      });
+    });
+  }
+  const children = props.children;
+  if (children != null) insert(form, children);
+  return form;
+}
+async function preloadRoutes(routes, pathname) {
+  const match = matchRoutes(routes, pathname);
+  if (!match) return;
+  const loads = [];
+  for (const m of match.matched) {
+    const c = m.component;
+    if (c && typeof c.preload === "function") loads.push(c.preload());
+  }
+  await Promise.all(loads);
+}
+
+export {
+  __reExport,
+  lazy,
+  createContext,
+  useContext,
+  createProvider,
+  composeProviders,
+  requireContext,
+  supportsViewTransitions,
+  prefersReducedMotion,
+  cache,
+  revalidate,
+  createAsync,
+  action,
+  useSubmission,
+  useSubmissions,
+  useAction,
+  Router,
+  Outlet,
+  useIsRouting,
+  Redirect,
+  useRouter,
+  useParams,
+  useLevelParams,
+  useParam,
+  useParamSelector,
+  useMatch,
+  useSearchParams,
+  select,
+  useLocation,
+  useLinkNavigation,
+  useNavigate,
+  useRouteData,
+  Link,
+  A,
+  ActionForm,
+  preloadRoutes,
+  createMemoryHistory,
+  createBrowserHistory2 as createBrowserHistory,
+  matchRoutes2 as matchRoutes,
+  matchPath2 as matchPath,
+  runWithOwner2 as runWithOwner
+};