@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/core.cjs

@@ -0,0 +1,1710 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/core.ts
+var core_exports = {};
+__export(core_exports, {
+  $component: () => $component,
+  Await: () => Await,
+  ClientOnly: () => import_dom16.ClientOnly,
+  ColorSchemeProvider: () => ColorSchemeProvider,
+  Dynamic: () => import_dom16.Dynamic,
+  ErrorBoundary: () => import_dom16.ErrorBoundary,
+  FRAMEWORK_NAME: () => FRAMEWORK_NAME,
+  For: () => import_dom16.For,
+  Index: () => import_dom16.Index,
+  Island: () => import_dom19.Island,
+  Link: () => Link,
+  Match: () => import_dom16.Match,
+  NoSsr: () => import_dom16.NoSsr,
+  Portal: () => import_dom16.Portal,
+  Router: () => Router,
+  Show: () => import_dom16.Show,
+  Store: () => import_store.Store,
+  Suspense: () => Suspense,
+  SuspenseList: () => SuspenseList,
+  Switch: () => import_dom16.Switch,
+  ThemeProvider: () => ThemeProvider,
+  VERSION: () => VERSION2,
+  addClass: () => import_dom18.addClass,
+  appendChildren: () => import_dom18.appendChildren,
+  batch: () => import_signal18.batch,
+  classMap: () => import_dom19.classMap,
+  cleanupDelegation: () => cleanupDelegation,
+  clientOnly: () => clientOnly,
+  closest: () => import_dom18.closest,
+  composeProviders: () => composeProviders,
+  createColorScheme: () => createColorScheme,
+  createComponent: () => createComponent,
+  createComputed: () => import_signal18.createComputed,
+  createContext: () => createContext3,
+  createDebounce: () => import_signal19.createDebounce,
+  createDebouncedResource: () => import_signal19.createDebouncedResource,
+  createDebouncedSignal: () => import_signal19.createDebouncedSignal,
+  createDeferred: () => import_signal18.createDeferred,
+  createEffect: () => import_signal18.createEffect,
+  createIsomorphicState: () => createIsomorphicState,
+  createIsomorphicStore: () => createIsomorphicStore,
+  createMemo: () => import_signal18.createMemo,
+  createProvider: () => createProvider,
+  createRenderEffect: () => import_signal18.createRenderEffect,
+  createResource: () => import_signal18.createResource,
+  createRoot: () => import_signal18.createRoot,
+  createSelector: () => import_signal19.createSelector,
+  createSignal: () => import_signal18.createSignal,
+  createStore: () => import_store.createStore,
+  createTheme: () => createTheme,
+  css: () => import_dom17.css,
+  default: () => core_default,
+  deferred: () => deferred,
+  delegate: () => import_dom18.delegate,
+  domCreateElement: () => import_dom18.createElement,
+  effect: () => import_signal18.effect,
+  env: () => env,
+  getAttribute: () => import_dom18.getAttribute,
+  getOffset: () => import_dom18.getOffset,
+  getOwner: () => import_signal18.getOwner,
+  getStyle: () => import_dom18.getStyle,
+  hasClass: () => import_dom18.hasClass,
+  html: () => import_dom17.html,
+  hydrateIslands: () => import_dom19.hydrateIslands,
+  initDelegation: () => initDelegation,
+  isClient: () => isClient,
+  isJSXElement: () => isJSXElement,
+  isLitResult: () => isLitResult,
+  isNode: () => isNode,
+  isRenderable: () => isRenderable,
+  isServer: () => import_dom12.isServer,
+  isVisible: () => import_dom18.isVisible,
+  lazy: () => lazy,
+  memo: () => import_signal18.memo,
+  mergeProps: () => import_dom19.mergeProps,
+  observeIntersection: () => import_dom18.observeIntersection,
+  observeResize: () => import_dom18.observeResize,
+  onCleanup: () => import_signal18.onCleanup,
+  onMount: () => onMount,
+  onUnmount: () => onUnmount,
+  portal: () => portal,
+  query: () => import_dom18.query,
+  queryAll: () => import_dom18.queryAll,
+  read: () => import_operators.readSignal,
+  reduce: () => import_operators.reduceSignal,
+  removeAttribute: () => import_dom18.removeAttribute,
+  removeChildren: () => import_dom18.removeChildren,
+  removeClass: () => import_dom18.removeClass,
+  render: () => render,
+  requireContext: () => requireContext,
+  resource: () => import_signal18.resource,
+  runWithOwner: () => import_signal18.runWithOwner,
+  scrollIntoView: () => import_dom18.scrollIntoView,
+  setAttribute: () => import_dom18.setAttribute,
+  setOwner: () => import_signal18.setOwner,
+  setStyles: () => import_dom18.setStyles,
+  signal: () => import_signal18.signal,
+  splitProps: () => import_dom19.splitProps,
+  styleMap: () => import_dom19.styleMap,
+  svg: () => import_dom17.svg,
+  toggleClass: () => import_dom18.toggleClass,
+  untrack: () => import_signal18.untrack,
+  untrackStore: () => import_store.untrackStore,
+  unwrap: () => import_store.unwrap,
+  useCallback: () => useCallback,
+  useColorScheme: () => useColorScheme,
+  useContext: () => useContext3,
+  useEffect: () => useEffect,
+  useEventListener: () => useEventListener,
+  useLocation: () => useLocation,
+  useMemo: () => useMemo,
+  useNavigate: () => useNavigate,
+  useParams: () => useParams,
+  useReducer: () => useReducer,
+  useRef: () => useRef,
+  useRouter: () => useRouter,
+  useTheme: () => useTheme,
+  waitForElement: () => import_dom18.waitForElement
+});
+module.exports = __toCommonJS(core_exports);
+var import_signal18 = require("@fluixi/reactive/signal");
+var import_signal19 = require("@fluixi/reactive/signal");
+var import_operators = require("@fluixi/reactive/operators");
+
+// src/lib/render/index.ts
+var import_dom8 = require("@fluixi/dom");
+var import_signal6 = require("@fluixi/reactive/signal");
+
+// src/lib/render/versions.ts
+var import_dom = require("@fluixi/dom");
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.100";
+
+// src/lib/render/versions.ts
+var import_dom2 = require("@fluixi/dom");
+(0, import_dom.registerCoreVersion)(VERSION);
+
+// src/lib/render/index.ts
+var import_dom9 = require("@fluixi/dom");
+
+// src/lib/render/component.ts
+var import_dom3 = require("@fluixi/dom");
+var import_dom4 = require("@fluixi/dom");
+var import_signal = require("@fluixi/reactive/signal");
+var _LIFECYCLE = /* @__PURE__ */ Symbol.for("fluixi-lifecycle");
+function getOwnerLifecycle() {
+  const owner = (0, import_signal.getOwner)();
+  if (!owner) return null;
+  if (!owner[_LIFECYCLE]) {
+    const lc = { mounts: [], effects: [], scheduled: false };
+    owner[_LIFECYCLE] = lc;
+  }
+  return owner[_LIFECYCLE];
+}
+function scheduleLifecycleFlush(lc) {
+  if (lc.scheduled) return;
+  if ((0, import_dom3.isServer)()) {
+    lc.mounts = [];
+    lc.effects = [];
+    return;
+  }
+  lc.scheduled = true;
+  const owner = (0, import_signal.getOwner)();
+  queueMicrotask(() => {
+    if ((0, import_signal.isOwnerDisposed)(owner)) {
+      lc.mounts = [];
+      lc.effects = [];
+      return;
+    }
+    (0, import_signal.runWithOwner)(owner, () => {
+      for (const cb of lc.mounts) {
+        try {
+          const cleanup = cb();
+          if (typeof cleanup === "function") {
+            (0, import_signal.onCleanup)(cleanup);
+          }
+        } catch (e) {
+          console.error("Error in onMount callback:", e);
+        }
+      }
+      for (const cb of lc.effects) {
+        let cleanup;
+        (0, import_signal.createEffect)(() => {
+          if (cleanup) cleanup();
+          cleanup = cb();
+        });
+        (0, import_signal.onCleanup)(() => {
+          if (cleanup) cleanup();
+        });
+      }
+      lc.mounts = [];
+      lc.effects = [];
+    });
+  });
+}
+function createComponent(Comp, props) {
+  return (0, import_dom4.createComponent)(Comp, props);
+}
+function $component(value, props) {
+  const component = typeof value === "function" ? (0, import_signal.untrack)(() => value(props)) : value;
+  const nameable = component != null && (typeof component === "function" || typeof component === "object");
+  if (nameable) {
+    try {
+      component["$name"] = value.name;
+    } catch {
+    }
+  }
+  if (nameable && !(0, import_signal.isSignal)(component)) {
+    return (0, import_dom4.asComponent)(component);
+  }
+  return component;
+}
+function onMount(fn, reactive = true) {
+  if ((0, import_dom3.isServer)()) return;
+  const lc = getOwnerLifecycle();
+  if (lc) {
+    if (!reactive) {
+      if (!lc.scheduled) {
+        fn();
+      }
+      return;
+    }
+    lc.mounts.push(fn);
+    scheduleLifecycleFlush(lc);
+  } else {
+    if (!reactive) {
+      fn();
+      return;
+    }
+    (0, import_signal.createEffect)(() => {
+      const cleanup = (0, import_signal.untrack)(fn);
+      if (typeof cleanup === "function") {
+        (0, import_signal.onCleanup)(cleanup);
+      }
+    });
+  }
+}
+function onUnmount(fn) {
+  (0, import_signal.onCleanup)(fn);
+}
+function useEffect(callback) {
+  const lc = getOwnerLifecycle();
+  if (lc) {
+    lc.effects.push(callback);
+    scheduleLifecycleFlush(lc);
+  } else {
+    let cleanup;
+    (0, import_signal.createEffect)(() => {
+      if (cleanup) cleanup();
+      cleanup = callback();
+    });
+    (0, import_signal.onCleanup)(() => {
+      if (cleanup) cleanup();
+    });
+  }
+}
+function useMemo(fn) {
+  return (0, import_signal.createMemo)(fn);
+}
+function useRef(initialValue) {
+  const ref = { current: initialValue };
+  (0, import_signal.onCleanup)(() => {
+    ref.current = null;
+  });
+  return ref;
+}
+function useReducer(reducer, initialState) {
+  const [state, setState] = (0, import_signal.createSignal)(initialState);
+  const dispatch = (action2) => {
+    setState(reducer(state(), action2));
+  };
+  return [state, dispatch];
+}
+function useEventListener(target, event, handler, options) {
+  useEffect(() => {
+    const element = target && "current" in target ? target.current : target;
+    if (!element) return;
+    element.addEventListener(event, handler, options);
+    return () => {
+      element.removeEventListener(event, handler, options);
+    };
+  });
+}
+function useCallback(callback) {
+  return callback;
+}
+
+// src/lib/render/suspense.ts
+var import_signal2 = require("@fluixi/reactive/signal");
+var import_dom5 = require("@fluixi/dom");
+function isNode(value) {
+  if (typeof window === "undefined") return false;
+  if (typeof Node === "function" && value instanceof Node) return true;
+  return !!(value && typeof value === "object" && typeof value.nodeType === "number");
+}
+function isLitResult(value) {
+  if (!value || typeof value !== "object") return false;
+  return !!(typeof value["_$litType$"] !== "undefined" || typeof value["_$litDirective$"] !== "undefined" || Array.isArray(value.strings) && Array.isArray(value.values));
+}
+function isPromise(value) {
+  return !!(value && typeof value === "object" && typeof value.then === "function" || value instanceof Promise);
+}
+function isJSXElement(value) {
+  return !!(value && typeof value === "object" && "type" in value && "props" in value);
+}
+var SuspenseListContext = (0, import_signal2.createContext)(void 0, "suspense-list");
+function Suspense(props) {
+  return (0, import_dom5.createComponent)(SuspenseImpl, props);
+}
+function SuspenseImpl(props) {
+  const boundary = (0, import_signal2.createSuspenseBoundary)();
+  const listCtx = (0, import_signal2.useContext)(SuspenseListContext);
+  const listState = listCtx ? listCtx.register(boundary.inFallback) : void 0;
+  function instantiateOnce(val) {
+    if (val == null || typeof val === "boolean") return null;
+    if (typeof val === "function" && (0, import_dom5.isComponent)(val) && !(0, import_signal2.isSignal)(val)) return val();
+    return val;
+  }
+  const fallback = (0, import_dom5.runWithoutHydration)(() => instantiateOnce(props.fallback ?? null));
+  const children = (0, import_signal2.provideSuspense)(boundary, () => (0, import_signal2.readChildren)(() => props.children));
+  const track = (value, depth) => {
+    if (depth > 8) return;
+    if (Array.isArray(value)) {
+      for (const x of value) track(x, depth + 1);
+    } else if (typeof value === "function" && (0, import_signal2.isSignal)(value)) {
+      track(value(), depth + 1);
+    }
+  };
+  (0, import_signal2.provideSuspense)(boundary, () => {
+    (0, import_signal2.createRenderEffect)(() => track(children, 0));
+  });
+  const [resolved, setResolved] = (0, import_signal2.createSignal)(void 0);
+  const childIsPromise = isPromise(children);
+  if (childIsPromise) {
+    boundary.increment();
+    children.then(
+      (v) => {
+        setResolved(() => v);
+        boundary.decrement();
+      },
+      () => boundary.decrement()
+    );
+  }
+  return (0, import_signal2.createMemo)(() => {
+    const showFallback = listState ? listState.showFallback() : boundary.inFallback();
+    if (showFallback) return fallback;
+    if (childIsPromise) return resolved();
+    return children;
+  });
+}
+function SuspenseList(props) {
+  return (0, import_dom5.createComponent)(SuspenseListImpl, props);
+}
+function SuspenseListImpl(props) {
+  const { revealOrder = "together", tail } = props;
+  const registrations = [];
+  function coordinateReveal() {
+    if (revealOrder === "together") {
+      const allResolved = registrations.every((r) => !r.inFallback());
+      registrations.forEach((r) => {
+        r.setShowContent(allResolved);
+        r.setShowFallback(!allResolved);
+      });
+    } else {
+      const items = revealOrder === "backwards" ? [...registrations].reverse() : registrations;
+      let blocked = false;
+      for (const r of items) {
+        if (blocked || r.inFallback()) {
+          blocked = true;
+          r.setShowContent(false);
+          r.setShowFallback(tail !== "hidden");
+        } else {
+          r.setShowContent(true);
+          r.setShowFallback(false);
+        }
+      }
+    }
+  }
+  const coordinator = {
+    register: (inFallback) => {
+      const [showContent, setShowContent] = (0, import_signal2.createSignal)(true);
+      const [showFallback, setShowFallback] = (0, import_signal2.createSignal)(false);
+      registrations.push({ inFallback, setShowContent, setShowFallback });
+      (0, import_signal2.createEffect)(() => {
+        inFallback();
+        coordinateReveal();
+      });
+      return { showContent, showFallback };
+    }
+  };
+  return SuspenseListContext.Provider({
+    value: coordinator,
+    children: props.children
+  });
+}
+(0, import_dom5.asSuspense)(Suspense);
+Object.defineProperty(Suspense, "__suspense", { value: true, enumerable: true });
+
+// src/lib/render/lazy.ts
+var import_dom6 = require("@fluixi/dom");
+var import_signal3 = require("@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((0, import_signal3.untrack)(() => C(props)));
+    }
+    if (!component) {
+      const [resource2] = (0, import_signal3.createResource)(() => load(), { transport: false });
+      component = resource2;
+      if (resource2.error) throw resource2.error;
+    }
+    return (0, import_signal3.createMemo)(() => {
+      const C = component();
+      return C ? fromChunk((0, import_dom6.createComponent)(C, props)) : void 0;
+    });
+  });
+  LazyWrapper.preload = () => load().then(() => void 0);
+  LazyWrapper.$lazy = true;
+  LazyWrapper.loader = loader;
+  return LazyWrapper;
+}
+
+// src/lib/render/deferred.ts
+var import_dom7 = require("@fluixi/dom");
+var import_signal4 = require("@fluixi/reactive/signal");
+var import_utils = require("@fluixi/dom/utils");
+function deferred(loader, options) {
+  const exportName = options.export ?? "default";
+  const Lazy = lazy(
+    () => loader().then((mod) => {
+      const component = mod[exportName];
+      if (typeof component !== "function") {
+        throw new Error(
+          `deferred(): module has no '${exportName}' export (got ${typeof component}).`
+        );
+      }
+      return { default: component };
+    }),
+    { fallback: options.fallback }
+  );
+  function Deferred(props) {
+    if (options.strategy.kind === "never") return (0, import_dom7.isServer)() ? Lazy(props) : null;
+    if ((0, import_dom7.isServer)() || options.strategy.kind === "eager") return Lazy(props);
+    const [ready, setReady] = (0, import_signal4.createSignal)(false);
+    const start = () => {
+      void Lazy.preload().then(() => setReady(true));
+    };
+    const anchor = options.strategy.kind === "visible" ? createAnchor() : void 0;
+    schedule(options.strategy, start, anchor);
+    return (0, import_signal4.createMemo)(() => ready() ? Lazy(props) : anchor ?? options.fallback ?? null, void 0, {
+      name: "deferred"
+    });
+  }
+  Deferred.preload = Lazy.preload;
+  return Deferred;
+}
+function createAnchor() {
+  const el = document.createElement("span");
+  el.setAttribute("data-fx-load", "visible");
+  el.style.display = "block";
+  return el;
+}
+function schedule(strategy, start, anchor) {
+  let fired = false;
+  const once = () => {
+    if (fired) return;
+    fired = true;
+    start();
+  };
+  switch (strategy.kind) {
+    case "idle": {
+      const ric = globalThis.requestIdleCallback;
+      if (ric) ric(once);
+      else setTimeout(once, 1);
+      return;
+    }
+    case "visible": {
+      if (!anchor || typeof IntersectionObserver === "undefined") {
+        once();
+        return;
+      }
+      const stop = (0, import_utils.observeIntersection)(
+        anchor,
+        (isIntersecting) => {
+          if (!isIntersecting) return;
+          stop();
+          once();
+        },
+        { rootMargin: strategy.rootMargin ?? "0px" }
+      );
+      return;
+    }
+    case "interaction": {
+      const handler = () => {
+        for (const event of strategy.events) {
+          document.removeEventListener(event, handler, true);
+        }
+        once();
+      };
+      for (const event of strategy.events) {
+        document.addEventListener(event, handler, { capture: true, passive: true });
+      }
+      return;
+    }
+    case "media": {
+      if (typeof matchMedia === "undefined") {
+        once();
+        return;
+      }
+      const query2 = matchMedia(strategy.query);
+      if (query2.matches) {
+        once();
+        return;
+      }
+      const onChange = (e) => {
+        if (!e.matches) return;
+        query2.removeEventListener("change", onChange);
+        once();
+      };
+      query2.addEventListener("change", onChange);
+      return;
+    }
+    /* c8 ignore next 3 */
+    default:
+      once();
+  }
+}
+
+// src/lib/render/await.ts
+var import_signal5 = require("@fluixi/reactive/signal");
+function Await(props) {
+  const fetcher = () => {
+    const v = props.value;
+    return typeof v === "function" ? v() : v;
+  };
+  const [data] = (0, import_signal5.createResource)(fetcher);
+  return () => {
+    if (data.loading) return props.fallback;
+    const child = props.children;
+    return typeof child === "function" ? child(data()) : child;
+  };
+}
+
+// src/lib/render/index.ts
+function render(code, container, options = {}) {
+  (0, import_dom9.delegateEvents)(["click", "input", "change", "submit"]);
+  if ((0, import_dom8.isServer)()) {
+    throw new Error(
+      "render() is for client-side only. Use renderToString() on server."
+    );
+  }
+  if (!container) {
+    throw new Error("Container element is required");
+  }
+  let disposer;
+  (0, import_signal6.createRoot)((dispose) => {
+    disposer = dispose;
+    const result = typeof code === "function" ? code() : code;
+    container.textContent = "";
+    (0, import_dom2.stampVersions)(container);
+    (0, import_dom2.warnOnVersionSkew)();
+    (0, import_dom9.insert)(container, () => result);
+  });
+  return () => {
+    if (disposer) {
+      disposer();
+      disposer = void 0;
+    }
+  };
+}
+function isLitTemplateResult(value) {
+  return value && typeof value === "object" && (value["_$litType$"] !== void 0 || value["_$litDirective$"] !== void 0);
+}
+function portal(code, target, options = {}) {
+  const container = document.createElement("div");
+  container.setAttribute("data-portal", "true");
+  target.appendChild(container);
+  const dispose = render(code, container, options);
+  return () => {
+    dispose();
+    if (target.contains(container)) {
+      target.removeChild(container);
+    }
+  };
+}
+function isRenderable(value) {
+  if (value == null) return true;
+  if (typeof value === "function") return true;
+  if ((0, import_dom9.isDOMNode)(value)) return true;
+  if (isLitTemplateResult(value)) return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  return false;
+}
+function initDelegation() {
+  if ((0, import_dom8.isServer)()) return;
+  (0, import_dom9.delegateEvents)(["click", "input", "change", "submit"]);
+}
+function cleanupDelegation() {
+  if ((0, import_dom8.isServer)()) return;
+}
+
+// src/lib/context/context.ts
+var import_dom10 = require("@fluixi/dom");
+var import_signal7 = require("@fluixi/reactive/signal");
+function createContext3(defaultValue, name) {
+  const context = (0, import_signal7.createContext)(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: (0, import_dom10.asProvider)(Provider),
+    defaultValue
+  };
+}
+function useContext3(context) {
+  const value = (0, import_signal7.useContext)(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 = (0, import_signal7.getOwner)(); owner; owner = owner.parent) {
+    if (owner.contexts?.has(context.id)) return useContext3(context);
+  }
+  throw new Error(message ?? `[fluixi] No Provider for ${context.id.description ?? "this context"} above this component.`);
+}
+
+// src/lib/isomorphic.ts
+var import_signal8 = require("@fluixi/reactive/signal");
+var import_dom11 = require("@fluixi/dom");
+var import_storage = require("@fluixi/storage");
+var import_browser = require("@fluixi/storage/browser");
+var REGISTRY_KEY = "__fluixi_iso_states__";
+var SEED_PREFIX = "__iso:";
+function registry() {
+  return globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new Map();
+}
+function readSeed(key) {
+  if (typeof window === "undefined") return void 0;
+  const data = (0, import_dom11.getServerData)();
+  return data ? data[SEED_PREFIX + key] : void 0;
+}
+function createIsomorphicState(key, options) {
+  const seed = readSeed(key);
+  const initial = seed !== void 0 ? seed : typeof window !== "undefined" && options.client ? options.client() : options.fallback;
+  const [value, set] = (0, import_signal8.createSignal)(initial, { name: key });
+  registry().set(key, { server: options.server, set });
+  return { value, set, key };
+}
+function createIsomorphicStore(key, options) {
+  const seeded = readSeed(key) !== void 0;
+  const base = createIsomorphicState(key, {
+    server: options.server,
+    fallback: options.fallback
+  });
+  const value = () => base.value() ?? options.fallback;
+  const persistWrite = (v) => {
+    const target = options.persist;
+    if (!target) return;
+    if (typeof target === "string" && typeof window === "undefined") return;
+    try {
+      const { storage, key: key2 } = typeof target === "string" ? { storage: (0, import_storage.createSyncStorage)({ adapter: (0, import_browser.localStorageAdapter)() }), key: target } : target;
+      storage.set(key2, v);
+    } catch {
+    }
+  };
+  const set = (v) => {
+    base.set(v);
+    persistWrite(v);
+  };
+  const setField = (k, val) => {
+    set({ ...value(), [k]: val });
+  };
+  const fields = {};
+  for (const k of Object.keys(options.fallback)) {
+    fields[k] = (0, import_signal8.createMemo)(() => value()[k], void 0, { name: `${key}.${String(k)}` });
+  }
+  let initPromise = null;
+  const ensureInit = () => {
+    if (seeded || !options.client) return Promise.resolve();
+    if (!initPromise) {
+      initPromise = Promise.resolve(options.client()).then((v) => {
+        set(v);
+      }).catch((e) => {
+        initPromise = null;
+        throw e;
+      });
+    }
+    return initPromise;
+  };
+  return { value, fields, set, setField, ensureInit, key, seeded };
+}
+
+// src/lib/env/index.ts
+var import_dom12 = require("@fluixi/dom");
+var import_dom13 = require("@fluixi/dom");
+function isClient() {
+  return !(0, import_dom13.isServer)();
+}
+var env = {
+  get window() {
+    return typeof window !== "undefined" ? window : void 0;
+  },
+  get document() {
+    return typeof document !== "undefined" ? document : void 0;
+  }
+};
+function clientOnly(fn, fallback) {
+  return isClient() ? fn() : fallback;
+}
+
+// src/lib/theme/index.ts
+var import_head = require("@fluixi/head");
+var import_signal11 = require("@fluixi/reactive/signal");
+var import_storage3 = require("@fluixi/storage");
+
+// src/lib/storage/persisted.ts
+var import_signal9 = require("@fluixi/reactive/signal");
+var isAsync = (storage) => "encryption" in storage;
+function persisted(storage, key, options = {}) {
+  const fallback = options.fallback ?? null;
+  const name = options.name ?? `storage:${storage.keyPrefix}${key}`;
+  const state = (0, import_signal9.signal)(isAsync(storage) ? fallback : storage.get(key) ?? fallback, { name });
+  const put = (value) => state.set(() => value);
+  const resolve = (next) => typeof next === "function" ? next((0, import_signal9.untrack)(state)) : next;
+  const writeOptions = (extra) => ({
+    ...options.ttl !== void 0 ? { ttl: options.ttl } : {},
+    ...options.encrypt ? { encrypt: true } : {},
+    ...extra
+  });
+  if (!isAsync(storage)) {
+    const off2 = storage.subscribe(key, (event) => {
+      if (event.type !== "set") return put(fallback);
+      if (event.value !== void 0) put(event.value);
+    });
+    if ((0, import_signal9.getOwner)()) (0, import_signal9.onCleanup)(off2);
+    return Object.assign(() => state(), {
+      set(next, extra) {
+        const value = resolve(next);
+        storage.set(key, value, writeOptions(extra));
+        put(value);
+      },
+      remove() {
+        storage.remove(key);
+        put(fallback);
+      }
+    });
+  }
+  let written = false;
+  const reread = () => storage.get(key).then(
+    (value) => put(value ?? fallback),
+    () => void 0
+  );
+  const off = storage.subscribe(key, (event) => {
+    if (event.type !== "set") return put(fallback);
+    if (event.value !== void 0) put(event.value);
+    else void reread();
+  });
+  if ((0, import_signal9.getOwner)()) (0, import_signal9.onCleanup)(off);
+  const ready = storage.get(key).then((value) => {
+    if (!written) put(value ?? fallback);
+  });
+  return Object.assign(() => state(), {
+    ready,
+    async set(next, extra) {
+      const previous = (0, import_signal9.untrack)(state);
+      const value = resolve(next);
+      written = true;
+      put(value);
+      try {
+        await storage.set(key, value, writeOptions(extra));
+      } catch (error) {
+        put(previous);
+        throw error;
+      }
+    },
+    async remove() {
+      written = true;
+      await storage.remove(key);
+      put(fallback);
+    }
+  });
+}
+
+// src/lib/storage/index.ts
+var import_dom14 = require("@fluixi/dom");
+var import_signal10 = require("@fluixi/reactive/signal");
+var import_storage2 = require("@fluixi/storage");
+var import_browser2 = require("@fluixi/storage/browser");
+var import_server = require("@fluixi/storage/server");
+var StorageContext = (0, import_signal10.createContext)(void 0, "storage");
+var AsyncStorageContext = (0, import_signal10.createContext)(void 0, "asyncStorage");
+var isBrowser = () => typeof window !== "undefined" && typeof document !== "undefined";
+var perRequest = /* @__PURE__ */ new WeakMap();
+var perPage = /* @__PURE__ */ new Map();
+function cached(scope, id, make) {
+  let adapter = scope.get(id);
+  if (!adapter) scope.set(id, adapter = make());
+  return adapter;
+}
+function requestRequired(scope) {
+  throw new import_storage2.StorageUnavailableError(
+    `useStorage({ scope: '${scope}' }) on the server needs a request: call it during a render, a loader or a server function, or provide a storage with <StorageProvider>.`
+  );
+}
+function adapterFor(scope, cookie = {}) {
+  const ctx = (0, import_dom14.getRequestContext)();
+  const options = { httpOnly: false, ...cookie };
+  switch (scope) {
+    case "local":
+      return (0, import_browser2.localStorageAdapter)();
+    case "session":
+      return (0, import_browser2.sessionStorageAdapter)();
+    case "request":
+      if (isBrowser()) return cached(perPage, "request", import_storage2.memoryStorage);
+      if (!ctx) requestRequired(scope);
+      return cached(perRequest.get(ctx) ?? perRequest.set(ctx, /* @__PURE__ */ new Map()).get(ctx), "request", import_server.requestStorage);
+    case "cookie": {
+      const id = `cookie:${JSON.stringify(options)}`;
+      if (isBrowser()) {
+        const { httpOnly: _ignored, ...browser } = options;
+        return cached(perPage, id, () => (0, import_browser2.documentCookieAdapter)(browser));
+      }
+      if (!ctx) requestRequired(scope);
+      const raw = ctx.event.request;
+      const target = raw && typeof raw === "object" ? raw : void 0;
+      return cached(
+        perRequest.get(ctx) ?? perRequest.set(ctx, /* @__PURE__ */ new Map()).get(ctx),
+        id,
+        () => (0, import_server.cookieStorage)({
+          ...options,
+          request: raw && typeof raw === "object" && ("headers" in raw || "getHeader" in raw) ? (0, import_server.toStorageRequest)(raw) : void 0,
+          response: {
+            appendHeader(name, value) {
+              if (!(0, import_dom14.appendResponseHeader)(name, value, target)) {
+                throw new import_storage2.StorageUnavailableError("The response headers were already sent, so this cookie cannot reach the browser. Write it before the page head goes out: in middleware, a loader, a server function or the render before its first chunk.");
+              }
+            }
+          }
+        })
+      );
+    }
+  }
+}
+function useStorage(options = {}) {
+  const { scope = "auto", cookie, ...storageOptions } = options;
+  if (scope === "auto") {
+    const provided = (0, import_signal10.useContext)(StorageContext);
+    if (provided) return options.namespace ? provided.namespace(options.namespace) : provided;
+  }
+  return (0, import_storage2.createSyncStorage)({ ...storageOptions, adapter: resolveAdapter(scope, cookie) });
+}
+function resolveAdapter(scope, cookie) {
+  if (scope !== "auto") return adapterFor(scope, cookie);
+  if (isBrowser()) return adapterFor("local");
+  if (!(0, import_dom14.getRequestContext)()) requestRequired(scope);
+  return adapterFor("request");
+}
+
+// src/lib/theme/index.ts
+function systemMap(system) {
+  if (!system) return null;
+  if (system === true) return { dark: "dark", light: "light" };
+  return system;
+}
+var YEAR = 60 * 60 * 24 * 365;
+function defaultStorage() {
+  try {
+    return useStorage({ scope: "cookie", cookie: { maxAge: YEAR, sameSite: "lax" } });
+  } catch (error) {
+    if (error instanceof import_storage3.StorageUnavailableError) return null;
+    throw error;
+  }
+}
+function storedLookup(storage, key) {
+  if (!storage) return null;
+  const full = storage.keyPrefix + key;
+  if (storage.scope === "cookie") {
+    return { from: "cookie", name: encodeURIComponent(full).replace(/[()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`) };
+  }
+  if (storage.scope === "local") return { from: "local", name: full };
+  return null;
+}
+function createTheme(options) {
+  const storageKey = options.storageKey ?? "theme";
+  const attribute = options.attribute ?? "data-theme";
+  const sys = systemMap(options.system);
+  const storage = options.storage === void 0 ? defaultStorage() : options.storage;
+  const valid = (t) => typeof t === "string" && options.themes.includes(t);
+  const fallback = sys && env.window?.matchMedia?.("(prefers-color-scheme: dark)")?.matches ? sys.dark : sys ? sys.light : options.default;
+  const stored = storage ? persisted(storage, storageKey) : null;
+  const [unsaved, setUnsaved] = (0, import_signal11.createSignal)(null);
+  const value = () => {
+    const local = unsaved();
+    if (local !== null) return local;
+    const saved = stored?.();
+    return valid(saved) ? saved : fallback;
+  };
+  const [isLoading, setLoading] = (0, import_signal11.createSignal)(false);
+  const apply = (t) => {
+    env.document?.documentElement.setAttribute(attribute, t);
+  };
+  const set = (t) => {
+    if (!options.themes.includes(t)) return;
+    const prev = value();
+    try {
+      stored?.set(t);
+      setUnsaved(stored ? null : t);
+    } catch {
+      setUnsaved(() => t);
+    }
+    apply(t);
+    options.onChange?.(t, prev);
+    if (options.load) {
+      setLoading(true);
+      options.onLoading?.(t);
+      Promise.resolve(options.load(t)).finally(() => {
+        setLoading(false);
+        options.onLoaded?.(t);
+      });
+    }
+  };
+  const toggle = () => {
+    const i = options.themes.indexOf(value());
+    set(options.themes[(i + 1) % options.themes.length]);
+  };
+  const init = () => apply(value());
+  const scriptBody = () => {
+    const cfg = JSON.stringify({ s: storedLookup(storage, storageKey), a: attribute, d: options.default, sys, ts: options.themes }).replace(/</g, "\\u003c");
+    return `(function(){try{var c=${cfg},t=null,s=c.s,r=null;if(s&&s.from==='local')r=localStorage.getItem(s.name);if(s&&s.from==='cookie')document.cookie.split('; ').forEach(function(p){var i=p.indexOf('=');if(p.slice(0,i)===s.name)r=decodeURIComponent(p.slice(i+1));});if(r){var e=JSON.parse(r);t=e&&e.v===1?e.value:e;}if(c.ts.indexOf(t)<0)t=null;if(!t&&c.sys)t=matchMedia('(prefers-color-scheme: dark)').matches?c.sys.dark:c.sys.light;if(!t)t=c.d;document.documentElement.setAttribute(c.a,t);}catch(e){}})();`;
+  };
+  const headScript = () => `<script>${scriptBody()}<\/script>`;
+  if ((0, import_head.getActiveHead)()) {
+    (0, import_head.useHead)({
+      htmlAttrs: { [attribute]: () => value() },
+      ...options.script === false ? {} : { script: [{ children: scriptBody() }] }
+    });
+  }
+  return { value, isLoading, set, toggle, init, headScript };
+}
+
+// src/lib/theme/color-scheme.ts
+var import_head2 = require("@fluixi/head");
+var import_signal12 = require("@fluixi/reactive/signal");
+var CHOICES = ["system", "light", "dark"];
+var DARK = "(prefers-color-scheme: dark)";
+function createColorScheme(options = {}) {
+  const storageKey = options.storageKey ?? "color-scheme";
+  const attribute = options.attribute ?? "data-theme";
+  const systemAs = options.systemAs ?? "resolved";
+  const storage = options.storage === void 0 ? defaultStorage() : options.storage;
+  const saved = storage ? persisted(storage, storageKey) : null;
+  const [unsaved, setUnsaved] = (0, import_signal12.createSignal)(null);
+  const value = () => {
+    const local = unsaved();
+    if (local) return local;
+    const stored = saved?.();
+    return CHOICES.includes(stored) ? stored : "system";
+  };
+  const media = env.window?.matchMedia?.(DARK);
+  const [osDark, setOsDark] = (0, import_signal12.createSignal)(media?.matches ?? false);
+  if (media) {
+    const onChange = () => setOsDark(media.matches);
+    media.addEventListener?.("change", onChange);
+    if ((0, import_signal12.getOwner)()) (0, import_signal12.onCleanup)(() => media.removeEventListener?.("change", onChange));
+  }
+  const resolved = () => {
+    const choice = value();
+    return choice === "system" ? osDark() ? "dark" : "light" : choice;
+  };
+  const shown = () => systemAs === "system" && value() === "system" ? "system" : resolved();
+  const apply = () => {
+    env.document?.documentElement.setAttribute(attribute, shown());
+  };
+  const set = (choice) => {
+    if (!CHOICES.includes(choice)) return;
+    if (!saved) setUnsaved(choice);
+    else {
+      try {
+        saved.set(choice);
+        setUnsaved(null);
+      } catch {
+        setUnsaved(choice);
+      }
+    }
+    apply();
+    options.onChange?.(choice);
+  };
+  const scriptBody = () => {
+    const cfg = JSON.stringify({ s: storedLookup(storage, storageKey), a: attribute, sys: systemAs === "system", tc: options.themeColor ?? null, cs: options.colorSchemeMeta !== false }).replace(/</g, "\\u003c");
+    return `(function(){try{var c=${cfg},t=null,s=c.s,r=null;if(s&&s.from==='local')r=localStorage.getItem(s.name);if(s&&s.from==='cookie')document.cookie.split('; ').forEach(function(p){var i=p.indexOf('=');if(p.slice(0,i)===s.name)r=decodeURIComponent(p.slice(i+1));});if(r){var e=JSON.parse(r);t=e&&e.v===1?e.value:e;}var chosen=t==='light'||t==='dark'?t:null;if(!chosen)t=c.sys?'system':(matchMedia('${DARK}').matches?'dark':'light');document.documentElement.setAttribute(c.a,t);if(chosen&&c.tc)document.querySelectorAll('meta[name="theme-color"]').forEach(function(m){m.setAttribute('content',c.tc[chosen]);m.removeAttribute('media');});if(chosen&&c.cs){var m=document.querySelector('meta[name="color-scheme"]');if(m)m.setAttribute('content',chosen);}}catch(e){}})();`;
+  };
+  if ((0, import_head2.getActiveHead)()) {
+    const colors = options.themeColor;
+    (0, import_head2.useHead)({
+      htmlAttrs: { [attribute]: shown },
+      ...colors ? {
+        themeColor: () => value() === "system" ? [
+          { color: colors.light, media: "(prefers-color-scheme: light)" },
+          { color: colors.dark, media: DARK }
+        ] : colors[resolved()]
+      } : {},
+      ...options.colorSchemeMeta === false ? {} : { colorScheme: () => value() === "system" ? "light dark" : resolved() },
+      ...options.script === false ? {} : { script: [{ children: scriptBody() }] }
+    });
+  }
+  if (env.document && (0, import_signal12.getOwner)()) (0, import_signal12.createEffect)(apply);
+  return {
+    value,
+    resolved,
+    set,
+    toggle: () => set(resolved() === "dark" ? "light" : "dark"),
+    init: apply,
+    headScript: () => `<script>${scriptBody()}<\/script>`
+  };
+}
+
+// src/lib/theme/provider.ts
+var ThemesContext = createContext3(void 0, "themes");
+function ThemeProvider(props) {
+  const outer = useContext3(ThemesContext);
+  return ThemesContext.Provider({
+    // A nested provider adds to the axes above it rather than hiding them.
+    value: outer ? { ...outer, ...props.themes } : props.themes,
+    get children() {
+      return props.children;
+    }
+  });
+}
+function useTheme(name) {
+  const themes = useContext3(ThemesContext);
+  if (!themes || !(name in themes)) {
+    throw new Error(`[fluixi] No theme named "${name}" above this component: provide it with <ThemeProvider> or <ColorSchemeProvider>.`);
+  }
+  return themes[name];
+}
+function ColorSchemeProvider(props) {
+  const scheme = createColorScheme(props);
+  return ThemeProvider({
+    themes: { scheme },
+    get children() {
+      return props.children;
+    }
+  });
+}
+function useColorScheme() {
+  return useTheme("scheme");
+}
+
+// src/lib/router/index.ts
+var import_signal15 = require("@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
+var import_dom15 = require("@fluixi/dom");
+var import_signal16 = require("@fluixi/reactive/signal");
+var import_object = require("@fluixi/utils/object");
+var import_compare = require("@fluixi/utils/compare");
+
+// src/lib/router/scroll.ts
+var STORE = "fx:scroll";
+var KEEP = 100;
+function keepScroll(initial) {
+  const read3 = () => {
+    try {
+      return JSON.parse(sessionStorage.getItem(STORE) ?? "{}");
+    } catch {
+      return {};
+    }
+  };
+  const positions = read3();
+  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
+var import_router = require("@fluixi/router");
+
+// src/lib/router/data.ts
+var import_signal13 = require("@fluixi/reactive/signal");
+var import_signal14 = require("@fluixi/reactive/signal");
+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 revalidate(key, store) {
+  const names = typeof key === "string" ? [key] : Array.isArray(key) ? key : null;
+  drop(names ?? key, store ?? (0, import_signal14.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, (0, import_signal14.currentResourceCache)());
+    } catch {
+    }
+  });
+}
+globalThis[/* @__PURE__ */ Symbol.for("fluixi.revalidate")] = (names) => revalidate(names);
+var RouteDataContext = createContext3(void 0, "route-data");
+var RouteDataProvider = RouteDataContext.Provider;
+
+// src/lib/router/index.ts
+var import_router2 = require("@fluixi/router");
+var import_signal17 = require("@fluixi/reactive/signal");
+var RouterContext = (0, import_signal16.createContext)(void 0, "router");
+var OutletContext = (0, import_signal16.createContext)(void 0, "outlet");
+var LevelParamsContext = (0, import_signal16.createContext)(void 0, "route-params");
+var RouteDataContext2 = (0, import_signal16.createContext)(void 0, "route-data");
+function renderLayer(m, depth, base) {
+  let data;
+  const loader = m.route.data;
+  if (typeof loader === "function") {
+    let cancelled = false;
+    (0, import_signal15.onCleanup)(() => {
+      cancelled = true;
+    });
+    const owner = (0, import_signal15.getOwner)();
+    const router = (0, import_signal16.useContext)(RouterContext);
+    let watching = false;
+    const trackDeps = (deps) => {
+      if (watching || cancelled) return;
+      watching = true;
+      (0, import_signal15.runWithOwner)(owner, () => {
+        let first = true;
+        (0, import_signal15.createEffect)(() => {
+          deps();
+          if (first) first = false;
+          else (0, import_signal15.untrack)(() => void refetch());
+        });
+      });
+    };
+    let readsLocation;
+    const [resource2, { refetch }] = (0, import_signal15.createResource)(() => {
+      const params = (0, import_signal15.untrack)(base.params);
+      const location = (0, import_signal15.untrack)(base.location);
+      readsLocation = false;
+      const result = loader(
+        {
+          params: () => params,
+          location: () => {
+            readsLocation = true;
+            return location;
+          }
+        },
+        owner,
+        () => cancelled,
+        trackDeps
+      );
+      return router ? router.trackLoad(result) : result;
+    });
+    (0, import_signal15.onCleanup)(
+      onRevalidate(() => {
+        if ((0, import_signal15.untrack)(() => base.matched()[depth]?.route) !== m.route) return;
+        void refetch();
+      })
+    );
+    let loadedFor = (0, import_signal15.untrack)(() => JSON.stringify(base.matched()[depth]?.params ?? {}));
+    let searchedFor = (0, import_signal15.untrack)(() => base.location().search);
+    (0, import_signal15.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) (0, import_signal15.untrack)(() => void refetch());
+    });
+    data = () => {
+      const error = resource2.error;
+      if (error !== void 0 && error !== null) throw error;
+      const r = resource2;
+      if (r.state === "refreshing") return r.latest;
+      return resource2();
+    };
+    Object.defineProperty(data, "loading", { get: () => resource2.loading });
+    Object.defineProperty(data, "state", { get: () => resource2.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 (0, import_dom15.createComponent)(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] = (0, import_signal15.createSignal)((0, import_signal15.untrack)(() => !isLoading()));
+  (0, import_signal15.createEffect)(() => setReady(!isLoading()));
+  return { view: (0, import_signal15.createMemo)(() => ready() ? buildPage() : null), ready };
+}
+function renderChild(ctx) {
+  const childIdx = ctx.depth + 1;
+  const [childComp, setChildComp] = (0, import_signal15.createSignal)(
+    (0, import_signal15.untrack)(() => ctx.matched()[childIdx]?.component)
+  );
+  (0, import_signal15.createEffect)(() => {
+    const c = ctx.matched()[childIdx]?.component;
+    if ((0, import_signal15.untrack)(childComp) !== c) setChildComp(() => c);
+  });
+  const owner = (0, import_signal15.getOwner)();
+  let shown = null;
+  let pending = null;
+  const drop2 = (layer) => layer?.dispose();
+  (0, import_signal15.onCleanup)(() => {
+    drop2(shown);
+    drop2(pending);
+    shown = pending = null;
+  });
+  const incoming = (0, import_signal15.createMemo)(() => {
+    const component = childComp();
+    if (!component) return null;
+    const m = (0, import_signal15.untrack)(() => ctx.matched())[childIdx];
+    return (0, import_signal15.runWithOwner)(
+      owner,
+      () => (0, import_signal15.createRoot)((dispose) => ({
+        ...renderLayer(m, childIdx, { matched: ctx.matched, params: ctx.params, location: ctx.location }),
+        dispose
+      }))
+    );
+  });
+  return (0, import_signal15.createMemo)(() => {
+    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" ? (0, import_dom15.createComponent)(notFound, {}) : notFound;
+}
+function buildDefaultNotFound() {
+  const el = (0, import_dom15.createNativeElement)("div");
+  (0, import_dom15.setAttribute)(el, "class", "fx-not-found");
+  (0, import_dom15.setAttribute)(el, "role", "main");
+  (0, import_dom15.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 = (0, import_dom15.createNativeElement)("h1");
+  (0, import_dom15.setAttribute)(h1, "style", "margin:0;font-size:2.5rem;font-weight:700");
+  (0, import_dom15.insert)(h1, "404");
+  const p = (0, import_dom15.createNativeElement)("p");
+  (0, import_dom15.setAttribute)(p, "style", "margin:0;opacity:.7");
+  (0, import_dom15.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 ?? (0, import_router.createBrowserHistory)();
+  const router = (0, import_router.createRouter)({
+    routes: props.routes,
+    base: props.base,
+    history: history2
+  });
+  const [state, setState] = (0, import_signal15.createSignal)(router.state());
+  const [navigating, setNavigating] = (0, import_signal15.createSignal)(false);
+  const [loads, setLoads] = (0, import_signal15.createSignal)(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] = (0, import_signal15.createSignal)(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: (0, import_signal15.untrack)(state).location };
+    }
+    const prepared = prepareComponents(
+      (next.match?.matched ?? []).map((m) => m.component).filter(Boolean)
+    );
+    const commit = () => {
+      setState(next);
+      const flushed = (0, import_signal15.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);
+    });
+  });
+  (0, import_signal15.onCleanup)(() => {
+    unsub();
+    scroll?.dispose();
+    router.destroy();
+    navigationId++;
+  });
+  const matched = (0, import_signal15.createMemo)(
+    () => (state().match?.matched ?? []).filter((m) => m.component)
+  );
+  const ctx = {
+    router,
+    location: (0, import_signal15.createMemo)(() => state().location),
+    params: (0, import_signal15.createMemo)(() => 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);
+    (0, import_signal15.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);
+    }
+  });
+}
+var _ssrRouterStub = {
+  router: { navigate: () => {
+  } },
+  location: () => ({ pathname: "", search: "", hash: "", query: {} }),
+  params: () => ({}),
+  isRouting: () => false,
+  trackLoad: (result) => result
+};
+function useRouter() {
+  const ctx = (0, import_signal16.useContext)(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 (0, import_signal15.createMemo)(() => params(), {}, {
+    equals: (a, b) => JSON.stringify(a) === JSON.stringify(b)
+  });
+}
+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 useNavigate() {
+  const { router } = useRouter();
+  return (to, options) => {
+    pendingTransitionMode = options?.transition;
+    router.navigate(to, options);
+  };
+}
+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 = (0, import_signal16.useContext)(RouterContext);
+  const navigate = () => ctx.router.navigate(read(props.href) ?? "", { replace: read(props.replace) });
+  const a = (0, import_dom15.createNativeElement)("a");
+  (0, import_dom15.setAttribute)(a, "href", read(props.href) ?? "");
+  if (props.slot) (0, import_dom15.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 read3 = v;
+      const apply = () => {
+        const value = read3();
+        if (value == null || value === false) a.removeAttribute?.(k);
+        else (0, import_dom15.setAttribute)(a, k, String(value));
+      };
+      if (typeof a.addEventListener === "function") (0, import_signal15.createEffect)(apply);
+      else apply();
+      continue;
+    }
+    if (v != null) (0, import_dom15.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) (0, import_dom15.setAttribute)(a, "class", base);
+  }
+  if (typeof a.addEventListener === "function") {
+    (0, import_signal15.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) (0, import_dom15.insert)(a, linkChildren);
+  return a;
+}
+
+// src/lib/core.ts
+var import_dom17 = require("@fluixi/dom");
+var import_dom18 = require("@fluixi/dom");
+var import_dom19 = require("@fluixi/dom");
+
+// src/lib/control-flow.ts
+var import_dom16 = require("@fluixi/dom");
+
+// src/lib/core.ts
+var import_store = require("@fluixi/reactive/store");
+var VERSION2 = "0.0.1";
+var FRAMEWORK_NAME = "Fluixi";
+var core_default = {
+  // Core
+  createComponent,
+  // render,
+  onMount,
+  onUnmount,
+  createEffect: import_signal18.createEffect,
+  createMemo: import_signal18.createMemo,
+  createSignal: import_signal18.createSignal,
+  createContext: createContext3,
+  createRoot: import_signal18.createRoot,
+  createDeferred: import_signal18.createDeferred,
+  createComputed: import_signal18.createComputed,
+  createRenderEffect: import_signal18.createRenderEffect,
+  createSelector: import_signal19.createSelector,
+  onCleanup: import_signal18.onCleanup,
+  getOwner: import_signal18.getOwner,
+  runWithOwner: import_signal18.runWithOwner,
+  batch: import_signal18.batch,
+  untrack: import_signal18.untrack,
+  useContext: useContext3,
+  setOwner: import_signal18.setOwner,
+  // Control Flow
+  // Show,
+  // For,
+  // Switch,
+  // Match,
+  // Portal,
+  // Dynamic,
+  // Context
+  // Provider,
+  // Resources
+  // createResource,
+  // Router
+  // createRouter,
+  Router,
+  Link,
+  useRouter,
+  useNavigate,
+  read: import_operators.readSignal,
+  reduce: import_operators.reduceSignal,
+  // Meta
+  VERSION: VERSION2,
+  FRAMEWORK_NAME
+};