@fictjs/runtime 0.0.12 → 0.0.14

package/dist/index.dev.js

@@ -8,99 +8,126 @@ function getDevtoolsHook() {
 }
 
 // src/cycle-guard.ts
-var defaultOptions = {
-  maxFlushCyclesPerMicrotask: 1e4,
-  maxEffectRunsPerFlush: 2e4,
-  windowSize: 5,
-  highUsageRatio: 0.8,
-  maxRootReentrantDepth: 10,
-  enableWindowWarning: true,
-  devMode: false
+var isDev = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var setCycleProtectionOptions = () => {
 };
-var options = {
-  ...defaultOptions
+var resetCycleProtectionStateForTests = () => {
 };
-var effectRunsThisFlush = 0;
-var windowUsage = [];
-var rootDepth = /* @__PURE__ */ new WeakMap();
-var flushWarned = false;
-var rootWarned = false;
-var windowWarned = false;
-function setCycleProtectionOptions(opts) {
-  options = { ...options, ...opts };
-}
-function beginFlushGuard() {
-  effectRunsThisFlush = 0;
-  flushWarned = false;
-  windowWarned = false;
-}
-function beforeEffectRunGuard() {
-  const next = ++effectRunsThisFlush;
-  if (next > options.maxFlushCyclesPerMicrotask || next > options.maxEffectRunsPerFlush) {
-    const message = `[fict] cycle protection triggered: flush-budget-exceeded`;
-    if (options.devMode) {
-      throw new Error(message);
+var beginFlushGuard = () => {
+};
+var beforeEffectRunGuard = () => true;
+var endFlushGuard = () => {
+};
+var enterRootGuard = () => true;
+var exitRootGuard = () => {
+};
+if (isDev) {
+  const defaultOptions = {
+    maxFlushCyclesPerMicrotask: 1e4,
+    maxEffectRunsPerFlush: 2e4,
+    windowSize: 5,
+    highUsageRatio: 0.8,
+    maxRootReentrantDepth: 10,
+    enableWindowWarning: true,
+    devMode: false
+  };
+  let options = {
+    ...defaultOptions
+  };
+  let effectRunsThisFlush = 0;
+  let windowUsage = [];
+  let rootDepth = /* @__PURE__ */ new WeakMap();
+  let flushWarned = false;
+  let rootWarned = false;
+  let windowWarned = false;
+  setCycleProtectionOptions = (opts) => {
+    options = { ...options, ...opts };
+  };
+  resetCycleProtectionStateForTests = () => {
+    options = { ...defaultOptions };
+    effectRunsThisFlush = 0;
+    windowUsage = [];
+    rootDepth = /* @__PURE__ */ new WeakMap();
+    flushWarned = false;
+    rootWarned = false;
+    windowWarned = false;
+  };
+  beginFlushGuard = () => {
+    effectRunsThisFlush = 0;
+    flushWarned = false;
+    windowWarned = false;
+  };
+  beforeEffectRunGuard = () => {
+    const next = ++effectRunsThisFlush;
+    if (next > options.maxFlushCyclesPerMicrotask || next > options.maxEffectRunsPerFlush) {
+      const message = `[fict] cycle protection triggered: flush-budget-exceeded`;
+      if (options.devMode) {
+        throw new Error(message);
+      }
+      if (!flushWarned) {
+        flushWarned = true;
+        console.warn(message, { effectRuns: next });
+      }
+      return false;
     }
-    if (!flushWarned) {
-      flushWarned = true;
-      console.warn(message, { effectRuns: next });
+    return true;
+  };
+  endFlushGuard = () => {
+    recordWindowUsage(effectRunsThisFlush, options.maxFlushCyclesPerMicrotask);
+    effectRunsThisFlush = 0;
+  };
+  enterRootGuard = (root) => {
+    const depth = (rootDepth.get(root) ?? 0) + 1;
+    if (depth > options.maxRootReentrantDepth) {
+      const message = `[fict] cycle protection triggered: root-reentry`;
+      if (options.devMode) {
+        throw new Error(message);
+      }
+      if (!rootWarned) {
+        rootWarned = true;
+        console.warn(message, { depth });
+      }
+      return false;
     }
-    return false;
-  }
-  return true;
-}
-function endFlushGuard() {
-  recordWindowUsage(effectRunsThisFlush, options.maxFlushCyclesPerMicrotask);
-  effectRunsThisFlush = 0;
-}
-function enterRootGuard(root) {
-  const depth = (rootDepth.get(root) ?? 0) + 1;
-  if (depth > options.maxRootReentrantDepth) {
-    const message = `[fict] cycle protection triggered: root-reentry`;
-    if (options.devMode) {
-      throw new Error(message);
+    rootDepth.set(root, depth);
+    return true;
+  };
+  exitRootGuard = (root) => {
+    const depth = rootDepth.get(root);
+    if (depth === void 0) return;
+    if (depth <= 1) {
+      rootDepth.delete(root);
+    } else {
+      rootDepth.set(root, depth - 1);
     }
-    if (!rootWarned) {
-      rootWarned = true;
-      console.warn(message, { depth });
+  };
+  const recordWindowUsage = (used, budget) => {
+    if (!options.enableWindowWarning) return;
+    const entry = { used, budget };
+    windowUsage.push(entry);
+    if (windowUsage.length > options.windowSize) {
+      windowUsage.shift();
+    }
+    if (windowWarned) return;
+    if (windowUsage.length >= options.windowSize && windowUsage.every(
+      (item) => item.budget > 0 && item.used / item.budget >= options.highUsageRatio
+    )) {
+      windowWarned = true;
+      reportCycle("high-usage-window", {
+        windowSize: options.windowSize,
+        ratio: options.highUsageRatio
+      });
     }
-    return false;
-  }
-  rootDepth.set(root, depth);
-  return true;
-}
-function exitRootGuard(root) {
-  const depth = rootDepth.get(root);
-  if (depth === void 0) return;
-  if (depth <= 1) {
-    rootDepth.delete(root);
-  } else {
-    rootDepth.set(root, depth - 1);
-  }
-}
-function recordWindowUsage(used, budget) {
-  if (!options.enableWindowWarning) return;
-  const entry = { used, budget };
-  windowUsage.push(entry);
-  if (windowUsage.length > options.windowSize) {
-    windowUsage.shift();
-  }
-  if (windowWarned) return;
-  if (windowUsage.length >= options.windowSize && windowUsage.every((item) => item.budget > 0 && item.used / item.budget >= options.highUsageRatio)) {
-    windowWarned = true;
-    reportCycle("high-usage-window", {
-      windowSize: options.windowSize,
-      ratio: options.highUsageRatio
-    });
-  }
-}
-function reportCycle(reason, detail = void 0) {
-  const hook = getDevtoolsHook();
-  hook?.cycleDetected?.(detail ? { reason, detail } : { reason });
-  console.warn(`[fict] cycle protection triggered: ${reason}`, detail ?? "");
+  };
+  const reportCycle = (reason, detail = void 0) => {
+    const hook = getDevtoolsHook();
+    hook?.cycleDetected?.(detail ? { reason, detail } : { reason });
+    console.warn(`[fict] cycle protection triggered: ${reason}`, detail ?? "");
+  };
 }
 
 // src/lifecycle.ts
+var isDev2 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
 var currentRoot;
 var currentEffectCleanups;
 var globalErrorHandlers = /* @__PURE__ */ new WeakMap();
@@ -239,7 +266,8 @@ function runLifecycle(fn) {
 }
 function registerErrorHandler(fn) {
   if (!currentRoot) {
-    throw new Error("registerErrorHandler must be called within a root");
+    const message = isDev2 ? "registerErrorHandler must be called within a root" : "FICT:E_ROOT_HANDLER";
+    throw new Error(message);
   }
   if (!currentRoot.errorHandlers) {
     currentRoot.errorHandlers = [];
@@ -254,7 +282,8 @@ function registerErrorHandler(fn) {
 }
 function registerSuspenseHandler(fn) {
   if (!currentRoot) {
-    throw new Error("registerSuspenseHandler must be called within a root");
+    const message = isDev2 ? "registerSuspenseHandler must be called within a root" : "FICT:E_ROOT_SUSPENSE";
+    throw new Error(message);
   }
   if (!currentRoot.suspenseHandlers) {
     currentRoot.suspenseHandlers = [];
@@ -328,6 +357,7 @@ function handleSuspend(token, startRoot) {
 }
 
 // src/signal.ts
+var isDev3 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
 var Mutable = 1;
 var Watching = 2;
 var Running = 4;
@@ -543,16 +573,16 @@ function shallowPropagate(firstLink) {
 function update(node) {
   return "getter" in node && node.getter !== void 0 ? updateComputed(node) : updateSignal(node);
 }
-function notify(effect2) {
-  effect2.flags &= ~Watching;
+function notify(effect) {
+  effect.flags &= ~Watching;
   const effects = [];
   for (; ; ) {
-    effects.push(effect2);
-    const nextLink = effect2.subs;
+    effects.push(effect);
+    const nextLink = effect.subs;
     if (nextLink === void 0) break;
-    effect2 = nextLink.sub;
-    if (effect2 === void 0 || !(effect2.flags & Watching)) break;
-    effect2.flags &= ~Watching;
+    effect = nextLink.sub;
+    if (effect === void 0 || !(effect.flags & Watching)) break;
+    effect.flags &= ~Watching;
   }
   const targetQueue = isInTransition ? lowPriorityQueue : highPriorityQueue;
   for (let i = effects.length - 1; i >= 0; i--) {
@@ -821,31 +851,6 @@ function computedOper() {
   if (activeSub !== void 0) link(this, activeSub, cycle);
   return this.value;
 }
-function effect(fn) {
-  const e = {
-    fn,
-    subs: void 0,
-    subsTail: void 0,
-    deps: void 0,
-    depsTail: void 0,
-    flags: WatchingRunning,
-    __id: void 0
-  };
-  registerEffectDevtools(e);
-  const prevSub = activeSub;
-  if (prevSub !== void 0) link(e, prevSub, 0);
-  activeSub = e;
-  try {
-    effectRunDevtools(e);
-    fn();
-  } finally {
-    activeSub = prevSub;
-    e.flags &= ~Running;
-  }
-  const disposer = effectOper.bind(e);
-  disposer[EFFECT_MARKER] = true;
-  return disposer;
-}
 function effectWithCleanup(fn, cleanupRunner) {
   const e = {
     fn,
@@ -875,39 +880,30 @@ function effectWithCleanup(fn, cleanupRunner) {
 function effectOper() {
   disposeNode(this);
 }
-function effectScope(fn) {
-  const e = { deps: void 0, depsTail: void 0, subs: void 0, subsTail: void 0, flags: 0 };
-  const prevSub = activeSub;
-  if (prevSub !== void 0) link(e, prevSub, 0);
-  activeSub = e;
-  try {
-    fn();
-  } finally {
-    activeSub = prevSub;
-  }
-  const disposer = effectScopeOper.bind(e);
-  disposer[EFFECT_SCOPE_MARKER] = true;
-  return disposer;
-}
-function effectScopeOper() {
-  disposeNode(this);
-}
 function batch(fn) {
   ++batchDepth;
-  let _error;
-  let hasError = false;
+  let result;
+  let error;
   try {
-    return fn();
+    result = fn();
   } catch (e) {
-    _error = e;
-    hasError = true;
-    throw e;
+    error = e;
   } finally {
     --batchDepth;
-    if (!hasError && batchDepth === 0) {
-      flush();
+    if (batchDepth === 0) {
+      try {
+        flush();
+      } catch (flushErr) {
+        if (error === void 0) {
+          error = flushErr;
+        }
+      }
     }
   }
+  if (error !== void 0) {
+    throw error;
+  }
+  return result;
 }
 function setActiveSub(sub) {
   const prev = activeSub;
@@ -928,194 +924,49 @@ function setTransitionContext(value) {
   isInTransition = value;
   return prev;
 }
-var $state = signal;
-var devtoolsSignalId = 0;
-var devtoolsEffectId = 0;
-function registerSignalDevtools(value, node) {
-  const hook = getDevtoolsHook();
-  if (!hook) return void 0;
-  const id = ++devtoolsSignalId;
-  hook.registerSignal(id, value);
-  node.__id = id;
-  return id;
-}
-function updateSignalDevtools(node, value) {
-  const hook = getDevtoolsHook();
-  if (!hook) return;
-  const id = node.__id;
-  if (id) hook.updateSignal(id, value);
-}
-function registerEffectDevtools(node) {
-  const hook = getDevtoolsHook();
-  if (!hook) return void 0;
-  const id = ++devtoolsEffectId;
-  hook.registerEffect(id);
-  node.__id = id;
-  return id;
-}
-function effectRunDevtools(node) {
-  const hook = getDevtoolsHook();
-  if (!hook) return;
-  const id = node.__id;
-  if (id) hook.effectRun(id);
-}
-function createSelector(source, equalityFn = (a, b) => a === b) {
-  let current = source();
-  const observers = /* @__PURE__ */ new Map();
-  const dispose = effect(() => {
-    const next = source();
-    if (equalityFn(current, next)) return;
-    const prevSig = observers.get(current);
-    if (prevSig) prevSig(false);
-    const nextSig = observers.get(next);
-    if (nextSig) nextSig(true);
-    current = next;
-  });
-  registerRootCleanup(() => {
-    dispose();
-    observers.clear();
-  });
-  return (key) => {
-    let sig = observers.get(key);
-    if (!sig) {
-      sig = signal(equalityFn(key, current));
-      observers.set(key, sig);
-      registerRootCleanup(() => observers.delete(key));
-    }
-    return sig();
+var registerSignalDevtools = () => void 0;
+var updateSignalDevtools = () => {
+};
+var registerEffectDevtools = () => void 0;
+var effectRunDevtools = () => {
+};
+if (isDev3) {
+  let devtoolsSignalId = 0;
+  let devtoolsEffectId = 0;
+  registerSignalDevtools = (value, node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return void 0;
+    const id = ++devtoolsSignalId;
+    hook.registerSignal(id, value);
+    node.__id = id;
+    return id;
   };
-}
-
-// src/store.ts
-var PROXY = Symbol("fict:store-proxy");
-var TARGET = Symbol("fict:store-target");
-var ITERATE_KEY = Symbol("fict:iterate");
-function createStore(initialValue) {
-  const unwrapped = unwrap(initialValue);
-  const wrapped = wrap(unwrapped);
-  function setStore(fn) {
-    batch(() => {
-      const result = fn(wrapped);
-      if (result !== void 0) {
-        reconcile(wrapped, result);
-      }
-    });
-  }
-  return [wrapped, setStore];
-}
-var proxyCache = /* @__PURE__ */ new WeakMap();
-var signalCache = /* @__PURE__ */ new WeakMap();
-function wrap(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (value[PROXY]) return value;
-  if (proxyCache.has(value)) return proxyCache.get(value);
-  const handler = {
-    get(target, prop, receiver) {
-      if (prop === PROXY) return true;
-      if (prop === TARGET) return target;
-      const value2 = Reflect.get(target, prop, receiver);
-      track(target, prop);
-      return wrap(value2);
-    },
-    has(target, prop) {
-      const result = Reflect.has(target, prop);
-      track(target, prop);
-      return result;
-    },
-    ownKeys(target) {
-      track(target, ITERATE_KEY);
-      return Reflect.ownKeys(target);
-    },
-    getOwnPropertyDescriptor(target, prop) {
-      track(target, prop);
-      return Reflect.getOwnPropertyDescriptor(target, prop);
-    },
-    set(target, prop, value2, receiver) {
-      if (prop === PROXY || prop === TARGET) return false;
-      const hadKey = Object.prototype.hasOwnProperty.call(target, prop);
-      const oldValue = Reflect.get(target, prop, receiver);
-      if (oldValue === value2) return true;
-      const result = Reflect.set(target, prop, value2, receiver);
-      if (result) {
-        trigger(target, prop);
-        if (!hadKey) {
-          trigger(target, ITERATE_KEY);
-        }
-      }
-      return result;
-    },
-    deleteProperty(target, prop) {
-      const hadKey = Object.prototype.hasOwnProperty.call(target, prop);
-      const result = Reflect.deleteProperty(target, prop);
-      if (result) {
-        trigger(target, prop);
-        if (hadKey) {
-          trigger(target, ITERATE_KEY);
-        }
-      }
-      return result;
-    }
+  updateSignalDevtools = (node, value) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return;
+    const id = node.__id;
+    if (id) hook.updateSignal(id, value);
+  };
+  registerEffectDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return void 0;
+    const id = ++devtoolsEffectId;
+    hook.registerEffect(id);
+    node.__id = id;
+    return id;
+  };
+  effectRunDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return;
+    const id = node.__id;
+    if (id) hook.effectRun(id);
   };
-  const proxy = new Proxy(value, handler);
-  proxyCache.set(value, proxy);
-  return proxy;
-}
-function unwrap(value) {
-  if (value && typeof value === "object" && value[PROXY]) {
-    return value[TARGET];
-  }
-  return value;
-}
-function track(target, prop) {
-  let signals = signalCache.get(target);
-  if (!signals) {
-    signals = /* @__PURE__ */ new Map();
-    signalCache.set(target, signals);
-  }
-  let s = signals.get(prop);
-  if (!s) {
-    const initial = prop === ITERATE_KEY ? Reflect.ownKeys(target).length : getLastValue(target, prop);
-    s = signal(initial);
-    signals.set(prop, s);
-  }
-  s();
-}
-function trigger(target, prop) {
-  const signals = signalCache.get(target);
-  if (signals) {
-    const s = signals.get(prop);
-    if (s) {
-      if (prop === ITERATE_KEY) {
-        s(Reflect.ownKeys(target).length);
-      } else {
-        s(getLastValue(target, prop));
-      }
-    }
-  }
-}
-function getLastValue(target, prop) {
-  return target[prop];
-}
-function reconcile(target, value) {
-  if (target === value) return;
-  if (value === null || typeof value !== "object") return;
-  const realTarget = unwrap(target);
-  const realValue = unwrap(value);
-  const keys = /* @__PURE__ */ new Set([...Object.keys(realTarget), ...Object.keys(realValue)]);
-  for (const key of keys) {
-    if (realValue[key] === void 0 && realTarget[key] !== void 0) {
-      delete target[key];
-    } else if (realTarget[key] !== realValue[key]) {
-      target[key] = realValue[key];
-    }
-  }
 }
 
 // src/memo.ts
 function createMemo(fn) {
   return computed(fn);
 }
-var $memo = createMemo;
 
 // src/effect.ts
 function createEffect(fn) {
@@ -1150,7 +1001,6 @@ function createEffect(fn) {
   registerRootCleanup(teardown);
   return teardown;
 }
-var $effect = createEffect;
 function createRenderEffect(fn) {
   let cleanup;
   const rootForError = getCurrentRoot();
@@ -1186,8 +1036,89 @@ function createRenderEffect(fn) {
   return teardown;
 }
 
+// src/ref.ts
+function createRef() {
+  return { current: null };
+}
+
+// src/transition.ts
+function startTransition(fn) {
+  const prev = setTransitionContext(true);
+  try {
+    fn();
+  } finally {
+    setTransitionContext(prev);
+    scheduleFlush();
+  }
+}
+function useTransition() {
+  const pending = signal(false);
+  const start = (fn) => {
+    startTransition(() => {
+      pending(true);
+      try {
+        fn();
+      } finally {
+        pending(false);
+      }
+    });
+  };
+  return [() => pending(), start];
+}
+function useDeferredValue(getValue) {
+  const deferredValue = signal(getValue());
+  createEffect(() => {
+    const newValue = getValue();
+    const currentDeferred = untrack(() => deferredValue());
+    if (currentDeferred !== newValue) {
+      startTransition(() => {
+        deferredValue(newValue);
+      });
+    }
+  });
+  return () => deferredValue();
+}
+
+// src/scheduler.ts
+function batch2(fn) {
+  return batch(fn);
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+
+// src/jsx.ts
+var Fragment = Symbol("Fragment");
+
+// src/delegated-events.ts
+var DelegatedEventNames = [
+  "beforeinput",
+  "click",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+
 // src/constants.ts
-var booleans = [
+var isDev4 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var booleans = isDev4 ? [
   "allowfullscreen",
   "async",
   "alpha",
@@ -1235,9 +1166,9 @@ var booleans = [
   "shadowrootdelegatesfocus",
   "shadowrootserializable",
   "sharedstoragewritable"
-];
+] : [];
 var BooleanAttributes = new Set(booleans);
-var Properties = /* @__PURE__ */ new Set([
+var properties = isDev4 ? [
   // Core properties
   "className",
   "value",
@@ -1265,18 +1196,15 @@ var Properties = /* @__PURE__ */ new Set([
   "sharedStorageWritable",
   // All lowercase booleans
   ...booleans
-]);
+] : [];
+var Properties = new Set(properties);
 var ChildProperties = /* @__PURE__ */ new Set([
   "innerHTML",
   "textContent",
   "innerText",
   "children"
 ]);
-var Aliases = {
-  className: "class",
-  htmlFor: "for"
-};
-var PropAliases = {
+var PropAliases = isDev4 ? {
   // Direct mapping
   class: "className",
   // Element-specific mappings
@@ -1363,40 +1291,19 @@ var PropAliases = {
     IFRAME: 1,
     IMG: 1
   }
-};
-function getPropAlias(prop, tagName) {
-  const a = PropAliases[prop];
+} : {};
+function getPropAlias(prop2, tagName) {
+  if (!isDev4) return void 0;
+  const a = PropAliases[prop2];
   if (typeof a === "object") {
     return a[tagName] ? a["$"] : void 0;
   }
   return a;
 }
 var $$EVENTS = "_$FICT_DELEGATE";
-var DelegatedEvents = /* @__PURE__ */ new Set([
-  "beforeinput",
-  "click",
-  "dblclick",
-  "contextmenu",
-  "focusin",
-  "focusout",
-  "input",
-  "keydown",
-  "keyup",
-  "mousedown",
-  "mousemove",
-  "mouseout",
-  "mouseover",
-  "mouseup",
-  "pointerdown",
-  "pointermove",
-  "pointerout",
-  "pointerover",
-  "pointerup",
-  "touchend",
-  "touchmove",
-  "touchstart"
-]);
-var SVGElements = /* @__PURE__ */ new Set([
+var delegatedEvents = isDev4 ? DelegatedEventNames : [];
+var DelegatedEvents = new Set(delegatedEvents);
+var svgElements = isDev4 ? [
   "altGlyph",
   "altGlyphDef",
   "altGlyphItem",
@@ -1474,12 +1381,13 @@ var SVGElements = /* @__PURE__ */ new Set([
   "use",
   "view",
   "vkern"
-]);
+] : [];
+var SVGElements = new Set(svgElements);
 var SVGNamespace = {
   xlink: "http://www.w3.org/1999/xlink",
   xml: "http://www.w3.org/XML/1998/namespace"
 };
-var UnitlessStyles = /* @__PURE__ */ new Set([
+var unitlessList = isDev4 ? [
   "animationIterationCount",
   "animation-iteration-count",
   "borderImageOutset",
@@ -1555,680 +1463,8 @@ var UnitlessStyles = /* @__PURE__ */ new Set([
   "stroke-opacity",
   "strokeWidth",
   "stroke-width"
-]);
-
-// src/jsx.ts
-var Fragment = Symbol("Fragment");
-
-// src/hooks.ts
-var ctxStack = [];
-function assertRenderContext(ctx, hookName) {
-  if (!ctx.rendering) {
-    throw new Error(`${hookName} can only be used during render execution`);
-  }
-}
-function __fictUseContext() {
-  if (ctxStack.length === 0) {
-    const ctx2 = { slots: [], cursor: 0, rendering: true };
-    ctxStack.push(ctx2);
-    return ctx2;
-  }
-  const ctx = ctxStack[ctxStack.length - 1];
-  ctx.cursor = 0;
-  ctx.rendering = true;
-  return ctx;
-}
-function __fictPushContext() {
-  const ctx = { slots: [], cursor: 0 };
-  ctxStack.push(ctx);
-  return ctx;
-}
-function __fictPopContext() {
-  ctxStack.pop();
-}
-function __fictResetContext() {
-  ctxStack.length = 0;
-}
-function __fictUseSignal(ctx, initial, slot) {
-  assertRenderContext(ctx, "__fictUseSignal");
-  const index = slot ?? ctx.cursor++;
-  if (!ctx.slots[index]) {
-    ctx.slots[index] = signal(initial);
-  }
-  return ctx.slots[index];
-}
-function __fictUseMemo(ctx, fn, slot) {
-  assertRenderContext(ctx, "__fictUseMemo");
-  const index = slot ?? ctx.cursor++;
-  if (!ctx.slots[index]) {
-    ctx.slots[index] = createMemo(fn);
-  }
-  return ctx.slots[index];
-}
-function __fictUseEffect(ctx, fn, slot) {
-  assertRenderContext(ctx, "__fictUseEffect");
-  const index = slot ?? ctx.cursor++;
-  if (!ctx.slots[index]) {
-    ctx.slots[index] = createEffect(fn);
-  }
-}
-function __fictRender(ctx, fn) {
-  ctxStack.push(ctx);
-  ctx.cursor = 0;
-  ctx.rendering = true;
-  try {
-    return fn();
-  } finally {
-    ctx.rendering = false;
-    ctxStack.pop();
-  }
-}
-
-// src/props.ts
-var propGetters = /* @__PURE__ */ new WeakSet();
-var rawToProxy = /* @__PURE__ */ new WeakMap();
-var proxyToRaw = /* @__PURE__ */ new WeakMap();
-function __fictProp(getter) {
-  if (typeof getter === "function" && getter.length === 0) {
-    propGetters.add(getter);
-  }
-  return getter;
-}
-function isPropGetter(value) {
-  return typeof value === "function" && propGetters.has(value);
-}
-function createPropsProxy(props) {
-  if (!props || typeof props !== "object") {
-    return props;
-  }
-  if (proxyToRaw.has(props)) {
-    return props;
-  }
-  const cached = rawToProxy.get(props);
-  if (cached) {
-    return cached;
-  }
-  const proxy = new Proxy(props, {
-    get(target, prop, receiver) {
-      const value = Reflect.get(target, prop, receiver);
-      if (isPropGetter(value)) {
-        return value();
-      }
-      return value;
-    },
-    set(target, prop, value, receiver) {
-      return Reflect.set(target, prop, value, receiver);
-    },
-    has(target, prop) {
-      return prop in target;
-    },
-    ownKeys(target) {
-      return Reflect.ownKeys(target);
-    },
-    getOwnPropertyDescriptor(target, prop) {
-      return Object.getOwnPropertyDescriptor(target, prop);
-    }
-  });
-  rawToProxy.set(props, proxy);
-  proxyToRaw.set(proxy, props);
-  return proxy;
-}
-function unwrapProps(props) {
-  if (!props || typeof props !== "object") {
-    return props;
-  }
-  return proxyToRaw.get(props) ?? props;
-}
-function __fictPropsRest(props, exclude) {
-  const raw = unwrapProps(props);
-  const out = {};
-  const excludeSet = new Set(exclude);
-  for (const key of Reflect.ownKeys(raw)) {
-    if (excludeSet.has(key)) continue;
-    out[key] = raw[key];
-  }
-  return createPropsProxy(out);
-}
-function mergeProps(...sources) {
-  const validSources = sources.filter(
-    (s) => s != null && (typeof s === "object" || typeof s === "function")
-  );
-  if (validSources.length === 0) {
-    return {};
-  }
-  if (validSources.length === 1 && typeof validSources[0] === "object") {
-    return validSources[0];
-  }
-  const resolveSource = (src) => {
-    const value = typeof src === "function" ? src() : src;
-    if (!value || typeof value !== "object") return void 0;
-    return unwrapProps(value);
-  };
-  return new Proxy({}, {
-    get(_, prop) {
-      for (let i = validSources.length - 1; i >= 0; i--) {
-        const src = validSources[i];
-        const raw = resolveSource(src);
-        if (!raw || !(prop in raw)) continue;
-        const value = raw[prop];
-        if (typeof src === "function" && !isPropGetter(value)) {
-          return __fictProp(() => {
-            const latest = resolveSource(src);
-            if (!latest || !(prop in latest)) return void 0;
-            return latest[prop];
-          });
-        }
-        return value;
-      }
-      return void 0;
-    },
-    has(_, prop) {
-      for (const src of validSources) {
-        const raw = resolveSource(src);
-        if (raw && prop in raw) {
-          return true;
-        }
-      }
-      return false;
-    },
-    ownKeys() {
-      const keys = /* @__PURE__ */ new Set();
-      for (const src of validSources) {
-        const raw = resolveSource(src);
-        if (raw) {
-          for (const key of Reflect.ownKeys(raw)) {
-            keys.add(key);
-          }
-        }
-      }
-      return Array.from(keys);
-    },
-    getOwnPropertyDescriptor(_, prop) {
-      for (let i = validSources.length - 1; i >= 0; i--) {
-        const raw = resolveSource(validSources[i]);
-        if (raw && prop in raw) {
-          return {
-            enumerable: true,
-            configurable: true,
-            get: () => {
-              const value = raw[prop];
-              return value;
-            }
-          };
-        }
-      }
-      return void 0;
-    }
-  });
-}
-function useProp(getter) {
-  return __fictProp(createMemo(getter));
-}
-
-// src/transition.ts
-function startTransition(fn) {
-  const prev = setTransitionContext(true);
-  try {
-    fn();
-  } finally {
-    setTransitionContext(prev);
-    scheduleFlush();
-  }
-}
-function useTransition() {
-  const pending = signal(false);
-  const start = (fn) => {
-    startTransition(() => {
-      pending(true);
-      try {
-        fn();
-      } finally {
-        pending(false);
-      }
-    });
-  };
-  return [() => pending(), start];
-}
-function useDeferredValue(getValue) {
-  const deferredValue = signal(getValue());
-  createEffect(() => {
-    const newValue = getValue();
-    const currentDeferred = untrack(() => deferredValue());
-    if (currentDeferred !== newValue) {
-      startTransition(() => {
-        deferredValue(newValue);
-      });
-    }
-  });
-  return () => deferredValue();
-}
-
-// src/scheduler.ts
-function batch2(fn) {
-  return batch(fn);
-}
-function untrack2(fn) {
-  return untrack(fn);
-}
-
-// src/dom.ts
-var SVG_NS = "http://www.w3.org/2000/svg";
-var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
-var isDev = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
-function render(view, container) {
-  const root = createRootContext();
-  const prev = pushRoot(root);
-  let dom;
-  try {
-    const output = view();
-    dom = createElement(output);
-  } finally {
-    popRoot(prev);
-  }
-  container.replaceChildren(dom);
-  container.setAttribute("data-fict-fine-grained", "1");
-  flushOnMount(root);
-  const teardown = () => {
-    destroyRoot(root);
-    container.innerHTML = "";
-  };
-  return teardown;
-}
-function createElement(node) {
-  return createElementWithContext(node, null);
-}
-function resolveNamespace(tagName, namespace) {
-  if (tagName === "svg") return "svg";
-  if (tagName === "math") return "mathml";
-  if (namespace === "mathml") return "mathml";
-  if (namespace === "svg") return "svg";
-  if (SVGElements.has(tagName)) return "svg";
-  return null;
-}
-function createElementWithContext(node, namespace) {
-  if (node instanceof Node) {
-    return node;
-  }
-  if (node === null || node === void 0 || node === false) {
-    return document.createTextNode("");
-  }
-  if (typeof node === "object" && node !== null && !(node instanceof Node)) {
-    if ("marker" in node) {
-      const handle = node;
-      if (typeof handle.dispose === "function") {
-        registerRootCleanup(handle.dispose);
-      }
-      if (typeof handle.flush === "function") {
-        const runFlush = () => handle.flush && handle.flush();
-        if (typeof queueMicrotask === "function") {
-          queueMicrotask(runFlush);
-        } else {
-          Promise.resolve().then(runFlush).catch(() => void 0);
-        }
-      }
-      return createElement(handle.marker);
-    }
-    const nodeRecord = node;
-    if (nodeRecord[PRIMITIVE_PROXY]) {
-      const primitiveGetter = nodeRecord[Symbol.toPrimitive];
-      const value = typeof primitiveGetter === "function" ? primitiveGetter.call(node, "default") : node;
-      return document.createTextNode(value == null || value === false ? "" : String(value));
-    }
-  }
-  if (Array.isArray(node)) {
-    const frag = document.createDocumentFragment();
-    for (const child of node) {
-      appendChildNode(frag, child, namespace);
-    }
-    return frag;
-  }
-  if (typeof node === "string" || typeof node === "number") {
-    return document.createTextNode(String(node));
-  }
-  if (typeof node === "boolean") {
-    return document.createTextNode("");
-  }
-  const vnode = node;
-  if (typeof vnode.type === "function") {
-    const rawProps = unwrapProps(vnode.props ?? {});
-    const baseProps = vnode.key === void 0 ? rawProps : new Proxy(rawProps, {
-      get(target, prop, receiver) {
-        if (prop === "key") return vnode.key;
-        return Reflect.get(target, prop, receiver);
-      },
-      has(target, prop) {
-        if (prop === "key") return true;
-        return prop in target;
-      },
-      ownKeys(target) {
-        const keys = new Set(Reflect.ownKeys(target));
-        keys.add("key");
-        return Array.from(keys);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        if (prop === "key") {
-          return { enumerable: true, configurable: true, value: vnode.key };
-        }
-        return Object.getOwnPropertyDescriptor(target, prop);
-      }
-    });
-    const props = createPropsProxy(baseProps);
-    __fictPushContext();
-    try {
-      const rendered = vnode.type(props);
-      return createElementWithContext(rendered, namespace);
-    } catch (err) {
-      if (handleSuspend(err)) {
-        return document.createComment("fict:suspend");
-      }
-      handleError(err, { source: "render", componentName: vnode.type.name });
-      throw err;
-    } finally {
-      __fictPopContext();
-    }
-  }
-  if (vnode.type === Fragment) {
-    const frag = document.createDocumentFragment();
-    const children = vnode.props?.children;
-    appendChildren(frag, children, namespace);
-    return frag;
-  }
-  const tagName = typeof vnode.type === "string" ? vnode.type : "div";
-  const resolvedNamespace = resolveNamespace(tagName, namespace);
-  const el = resolvedNamespace === "svg" ? document.createElementNS(SVG_NS, tagName) : resolvedNamespace === "mathml" ? document.createElementNS(MATHML_NS, tagName) : document.createElement(tagName);
-  applyProps(el, vnode.props ?? {}, resolvedNamespace === "svg");
-  appendChildren(
-    el,
-    vnode.props?.children,
-    tagName === "foreignObject" ? null : resolvedNamespace
-  );
-  return el;
-}
-function template(html, isImportNode, isSVG, isMathML) {
-  let node = null;
-  const create = () => {
-    const t = isMathML ? document.createElementNS(MATHML_NS, "template") : document.createElement("template");
-    t.innerHTML = html;
-    if (isSVG) {
-      return t.content.firstChild.firstChild;
-    }
-    if (isMathML) {
-      return t.firstChild;
-    }
-    return t.content.firstChild;
-  };
-  const fn = isImportNode ? () => untrack2(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
-  fn.cloneNode = fn;
-  return fn;
-}
-function isBindingHandle(node) {
-  return node !== null && typeof node === "object" && "marker" in node && "dispose" in node && typeof node.dispose === "function";
-}
-function appendChildNode(parent, child, namespace) {
-  if (child === null || child === void 0 || child === false) {
-    return;
-  }
-  if (isBindingHandle(child)) {
-    appendChildNode(parent, child.marker, namespace);
-    child.flush?.();
-    return;
-  }
-  if (typeof child === "function" && child.length === 0) {
-    const childGetter = child;
-    createChildBinding(parent, childGetter, (node) => createElementWithContext(node, namespace));
-    return;
-  }
-  if (Array.isArray(child)) {
-    for (const item of child) {
-      appendChildNode(parent, item, namespace);
-    }
-    return;
-  }
-  let domNode;
-  if (typeof child !== "object" || child === null) {
-    domNode = document.createTextNode(String(child ?? ""));
-  } else {
-    domNode = createElementWithContext(child, namespace);
-  }
-  if (domNode.nodeType === 11) {
-    const children = Array.from(domNode.childNodes);
-    for (const node of children) {
-      appendChildNode(parent, node, namespace);
-    }
-    return;
-  }
-  if (domNode.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
-    parent.ownerDocument.adoptNode(domNode);
-  }
-  try {
-    parent.appendChild(domNode);
-  } catch (e) {
-    if (parent.ownerDocument) {
-      const clone = parent.ownerDocument.importNode(domNode, true);
-      parent.appendChild(clone);
-      return;
-    }
-    throw e;
-  }
-}
-function appendChildren(parent, children, namespace) {
-  if (children === void 0) return;
-  if (Array.isArray(children)) {
-    for (const child of children) {
-      appendChildren(parent, child, namespace);
-    }
-    return;
-  }
-  appendChildNode(parent, children, namespace);
-}
-function applyRef(el, value) {
-  if (typeof value === "function") {
-    const refFn = value;
-    refFn(el);
-    const root = getCurrentRoot();
-    if (root) {
-      registerRootCleanup(() => {
-        refFn(null);
-      });
-    } else if (isDev) {
-      console.warn(
-        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
-      );
-    }
-  } else if (value && typeof value === "object" && "current" in value) {
-    const refObj = value;
-    refObj.current = el;
-    const root = getCurrentRoot();
-    if (root) {
-      registerRootCleanup(() => {
-        refObj.current = null;
-      });
-    } else if (isDev) {
-      console.warn(
-        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
-      );
-    }
-  }
-}
-function applyProps(el, props, isSVG = false) {
-  props = unwrapProps(props);
-  const tagName = el.tagName;
-  const isCE = tagName.includes("-") || "is" in props;
-  for (const [key, value] of Object.entries(props)) {
-    if (key === "children") continue;
-    if (key === "ref") {
-      applyRef(el, value);
-      continue;
-    }
-    if (isEventKey(key)) {
-      bindEvent(
-        el,
-        eventNameFromProp(key),
-        value
-      );
-      continue;
-    }
-    if (key.slice(0, 3) === "on:") {
-      bindEvent(
-        el,
-        key.slice(3),
-        value,
-        false
-        // Non-delegated
-      );
-      continue;
-    }
-    if (key.slice(0, 10) === "oncapture:") {
-      bindEvent(
-        el,
-        key.slice(10),
-        value,
-        true
-        // Capture
-      );
-      continue;
-    }
-    if (key === "class" || key === "className") {
-      createClassBinding(el, value);
-      continue;
-    }
-    if (key === "classList") {
-      createClassBinding(el, value);
-      continue;
-    }
-    if (key === "style") {
-      createStyleBinding(
-        el,
-        value
-      );
-      continue;
-    }
-    if (key === "dangerouslySetInnerHTML" && value && typeof value === "object") {
-      const htmlValue = value.__html;
-      if (htmlValue !== void 0) {
-        if (isReactive(htmlValue)) {
-          createAttributeBinding(el, "innerHTML", htmlValue, setInnerHTML);
-        } else {
-          el.innerHTML = htmlValue;
-        }
-      }
-      continue;
-    }
-    if (ChildProperties.has(key)) {
-      createAttributeBinding(el, key, value, setProperty);
-      continue;
-    }
-    if (key.slice(0, 5) === "attr:") {
-      createAttributeBinding(el, key.slice(5), value, setAttribute);
-      continue;
-    }
-    if (key.slice(0, 5) === "bool:") {
-      createAttributeBinding(el, key.slice(5), value, setBoolAttribute);
-      continue;
-    }
-    if (key.slice(0, 5) === "prop:") {
-      createAttributeBinding(el, key.slice(5), value, setProperty);
-      continue;
-    }
-    const propAlias = !isSVG ? getPropAlias(key, tagName) : void 0;
-    if (propAlias || !isSVG && Properties.has(key) || isCE && !isSVG) {
-      const propName = propAlias || key;
-      if (isCE && !Properties.has(key)) {
-        createAttributeBinding(
-          el,
-          toPropertyName(propName),
-          value,
-          setProperty
-        );
-      } else {
-        createAttributeBinding(el, propName, value, setProperty);
-      }
-      continue;
-    }
-    if (isSVG && key.indexOf(":") > -1) {
-      const [prefix, name] = key.split(":");
-      const ns = SVGNamespace[prefix];
-      if (ns) {
-        createAttributeBinding(
-          el,
-          key,
-          value,
-          (el2, _key, val) => setAttributeNS(el2, ns, name, val)
-        );
-        continue;
-      }
-    }
-    const attrName = Aliases[key] || key;
-    createAttributeBinding(el, attrName, value, setAttribute);
-  }
-}
-function toPropertyName(name) {
-  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
-}
-var setAttribute = (el, key, value) => {
-  if (value === void 0 || value === null || value === false) {
-    el.removeAttribute(key);
-    return;
-  }
-  if (value === true) {
-    el.setAttribute(key, "");
-    return;
-  }
-  const valueType = typeof value;
-  if (valueType === "string" || valueType === "number") {
-    el.setAttribute(key, String(value));
-    return;
-  }
-  if (key in el) {
-    ;
-    el[key] = value;
-    return;
-  }
-  el.setAttribute(key, String(value));
-};
-var setProperty = (el, key, value) => {
-  if (value === void 0 || value === null) {
-    const fallback = key === "checked" || key === "selected" ? false : "";
-    el[key] = fallback;
-    return;
-  }
-  if (key === "style" && typeof value === "object" && value !== null) {
-    for (const k in value) {
-      const v = value[k];
-      if (v !== void 0) {
-        ;
-        el.style[k] = String(v);
-      }
-    }
-    return;
-  }
-  ;
-  el[key] = value;
-};
-var setInnerHTML = (el, _key, value) => {
-  ;
-  el.innerHTML = value == null ? "" : String(value);
-};
-var setBoolAttribute = (el, key, value) => {
-  if (value) {
-    el.setAttribute(key, "");
-  } else {
-    el.removeAttribute(key);
-  }
-};
-function setAttributeNS(el, namespace, name, value) {
-  if (value == null) {
-    el.removeAttributeNS(namespace, name);
-  } else {
-    el.setAttributeNS(namespace, name, String(value));
-  }
-}
-function isEventKey(key) {
-  return key.startsWith("on") && key.length > 2 && key[2].toUpperCase() === key[2];
-}
-function eventNameFromProp(key) {
-  return key.slice(2).toLowerCase();
-}
+] : ["opacity", "zIndex"];
+var UnitlessStyles = new Set(unitlessList);
 
 // src/node-ops.ts
 function toNodeArray(node) {
@@ -2301,757 +1537,83 @@ function insertNodesBefore(parent, nodes, anchor) {
       parent.insertBefore(node, anchor);
     } catch (e) {
       if (parent.ownerDocument) {
-        try {
-          const clone = parent.ownerDocument.importNode(node, true);
-          parent.insertBefore(clone, anchor);
-          return;
-        } catch {
-        }
-      }
-      throw e;
-    }
-    return;
-  }
-  const doc = parent.ownerDocument;
-  if (doc) {
-    const frag = doc.createDocumentFragment();
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      if (node === void 0 || node === null) continue;
-      if (node.nodeType === 11) {
-        const childrenArr = Array.from(node.childNodes);
-        for (let j = 0; j < childrenArr.length; j++) {
-          frag.appendChild(childrenArr[j]);
-        }
-      } else {
-        if (node.ownerDocument !== doc) {
-          doc.adoptNode(node);
-        }
-        frag.appendChild(node);
-      }
-    }
-    parent.insertBefore(frag, anchor);
-    return;
-  }
-  const insertSingle = (nodeToInsert, anchorNode) => {
-    if (nodeToInsert.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
-      parent.ownerDocument.adoptNode(nodeToInsert);
-    }
-    try {
-      parent.insertBefore(nodeToInsert, anchorNode);
-      return nodeToInsert;
-    } catch (e) {
-      if (parent.ownerDocument) {
-        try {
-          const clone = parent.ownerDocument.importNode(nodeToInsert, true);
-          parent.insertBefore(clone, anchorNode);
-          return clone;
-        } catch {
-        }
-      }
-      throw e;
-    }
-  };
-  for (let i = nodes.length - 1; i >= 0; i--) {
-    const node = nodes[i];
-    if (node === void 0 || node === null) continue;
-    const isFrag = node.nodeType === 11;
-    if (isFrag) {
-      const childrenArr = Array.from(node.childNodes);
-      for (let j = childrenArr.length - 1; j >= 0; j--) {
-        const child = childrenArr[j];
-        anchor = insertSingle(child, anchor);
-      }
-    } else {
-      anchor = insertSingle(node, anchor);
-    }
-  }
-}
-function removeNodes(nodes) {
-  for (const node of nodes) {
-    node.parentNode?.removeChild(node);
-  }
-}
-
-// src/reconcile.ts
-function reconcileArrays(parentNode, a, b) {
-  const bLength = b.length;
-  let aEnd = a.length;
-  let bEnd = bLength;
-  let aStart = 0;
-  let bStart = 0;
-  const after = aEnd > 0 ? a[aEnd - 1].nextSibling : null;
-  let map = null;
-  while (aStart < aEnd || bStart < bEnd) {
-    if (a[aStart] === b[bStart]) {
-      aStart++;
-      bStart++;
-      continue;
-    }
-    while (a[aEnd - 1] === b[bEnd - 1]) {
-      aEnd--;
-      bEnd--;
-    }
-    if (aEnd === aStart) {
-      const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] ?? null : after;
-      const count = bEnd - bStart;
-      const doc = parentNode.ownerDocument;
-      if (count > 1 && doc) {
-        const frag = doc.createDocumentFragment();
-        for (let i = bStart; i < bEnd; i++) {
-          frag.appendChild(b[i]);
-        }
-        parentNode.insertBefore(frag, node);
-        bStart = bEnd;
-      } else {
-        while (bStart < bEnd) {
-          parentNode.insertBefore(b[bStart++], node);
-        }
-      }
-    } else if (bEnd === bStart) {
-      while (aStart < aEnd) {
-        const nodeToRemove = a[aStart];
-        if (!map || !map.has(nodeToRemove)) {
-          nodeToRemove.parentNode?.removeChild(nodeToRemove);
-        }
-        aStart++;
-      }
-    } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
-      const node = a[--aEnd].nextSibling;
-      parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling);
-      parentNode.insertBefore(b[--bEnd], node);
-      a[aEnd] = b[bEnd];
-    } else {
-      if (!map) {
-        map = /* @__PURE__ */ new Map();
-        let i = bStart;
-        while (i < bEnd) {
-          map.set(b[i], i++);
-        }
-      }
-      const index = map.get(a[aStart]);
-      if (index != null) {
-        if (bStart < index && index < bEnd) {
-          let i = aStart;
-          let sequence = 1;
-          let t;
-          while (++i < aEnd && i < bEnd) {
-            t = map.get(a[i]);
-            if (t == null || t !== index + sequence) break;
-            sequence++;
-          }
-          if (sequence > index - bStart) {
-            const node = a[aStart];
-            while (bStart < index) {
-              parentNode.insertBefore(b[bStart++], node);
-            }
-          } else {
-            parentNode.replaceChild(b[bStart++], a[aStart++]);
-          }
-        } else {
-          aStart++;
-        }
-      } else {
-        const nodeToRemove = a[aStart++];
-        nodeToRemove.parentNode?.removeChild(nodeToRemove);
-      }
-    }
-  }
-}
-
-// src/list-helpers.ts
-var isDev2 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
-function moveNodesBefore(parent, nodes, anchor) {
-  for (let i = nodes.length - 1; i >= 0; i--) {
-    const node = nodes[i];
-    if (!node || !(node instanceof Node)) {
-      throw new Error("Invalid node in moveNodesBefore");
-    }
-    if (node.nextSibling !== anchor) {
-      if (node.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
-        parent.ownerDocument.adoptNode(node);
-      }
-      try {
-        parent.insertBefore(node, anchor);
-      } catch (e) {
-        if (parent.ownerDocument) {
-          try {
-            const clone = parent.ownerDocument.importNode(node, true);
-            parent.insertBefore(clone, anchor);
-            continue;
-          } catch {
-          }
-        }
-        throw e;
-      }
-    }
-    anchor = node;
-  }
-}
-function moveMarkerBlock(parent, block, anchor) {
-  const nodes = collectBlockNodes(block);
-  if (nodes.length === 0) return;
-  moveNodesBefore(parent, nodes, anchor);
-}
-function destroyMarkerBlock(block) {
-  if (block.root) {
-    destroyRoot(block.root);
-  }
-  removeBlockRange(block);
-}
-function collectBlockNodes(block) {
-  const nodes = [];
-  let cursor = block.start;
-  while (cursor) {
-    nodes.push(cursor);
-    if (cursor === block.end) {
-      break;
-    }
-    cursor = cursor.nextSibling;
-  }
-  return nodes;
-}
-function removeBlockRange(block) {
-  let cursor = block.start;
-  while (cursor) {
-    const next = cursor.nextSibling;
-    cursor.parentNode?.removeChild(cursor);
-    if (cursor === block.end) {
-      break;
-    }
-    cursor = next;
-  }
-}
-var MAX_SAFE_VERSION = 9007199254740991;
-function createVersionedSignalAccessor(initialValue) {
-  let current = initialValue;
-  let version = 0;
-  const track2 = signal(version);
-  function accessor(value) {
-    if (arguments.length === 0) {
-      track2();
-      return current;
-    }
-    current = value;
-    version = version >= MAX_SAFE_VERSION ? 1 : version + 1;
-    track2(version);
-  }
-  return accessor;
-}
-function createKeyedListContainer() {
-  const startMarker = document.createComment("fict:list:start");
-  const endMarker = document.createComment("fict:list:end");
-  const dispose = () => {
-    for (const block of container.blocks.values()) {
-      destroyRoot(block.root);
-    }
-    container.blocks.clear();
-    container.nextBlocks.clear();
-    if (!startMarker.parentNode || !endMarker.parentNode) {
-      container.currentNodes = [];
-      container.nextNodes = [];
-      container.orderedBlocks.length = 0;
-      container.nextOrderedBlocks.length = 0;
-      container.orderedIndexByKey.clear();
-      return;
-    }
-    const range = document.createRange();
-    range.setStartBefore(startMarker);
-    range.setEndAfter(endMarker);
-    range.deleteContents();
-    container.currentNodes = [];
-    container.nextNodes = [];
-    container.nextBlocks.clear();
-    container.orderedBlocks.length = 0;
-    container.nextOrderedBlocks.length = 0;
-    container.orderedIndexByKey.clear();
-  };
-  const container = {
-    startMarker,
-    endMarker,
-    blocks: /* @__PURE__ */ new Map(),
-    nextBlocks: /* @__PURE__ */ new Map(),
-    currentNodes: [startMarker, endMarker],
-    nextNodes: [],
-    orderedBlocks: [],
-    nextOrderedBlocks: [],
-    orderedIndexByKey: /* @__PURE__ */ new Map(),
-    dispose
-  };
-  return container;
-}
-function createKeyedBlock(key, item, index, render2, needsIndex = true, hostRoot) {
-  const itemSig = createVersionedSignalAccessor(item);
-  const indexSig = needsIndex ? signal(index) : ((next) => {
-    if (arguments.length === 0) return index;
-    index = next;
-    return index;
-  });
-  const root = createRootContext(hostRoot);
-  const prevRoot = pushRoot(root);
-  let nodes = [];
-  let scopeDispose;
-  const prevSub = setActiveSub(void 0);
-  try {
-    scopeDispose = effectScope(() => {
-      const rendered = render2(itemSig, indexSig, key);
-      if (rendered instanceof Node || Array.isArray(rendered) && rendered.every((n) => n instanceof Node)) {
-        nodes = toNodeArray(rendered);
-      } else {
-        const element = createElement(rendered);
-        nodes = toNodeArray(element);
-      }
-    });
-    if (scopeDispose) {
-      root.cleanups.push(scopeDispose);
-    }
-  } finally {
-    setActiveSub(prevSub);
-    popRoot(prevRoot);
-  }
-  return {
-    key,
-    nodes,
-    root,
-    item: itemSig,
-    index: indexSig,
-    rawItem: item,
-    rawIndex: index
-  };
-}
-function getFirstNodeAfter(marker) {
-  return marker.nextSibling;
-}
-function isNodeBetweenMarkers(node, startMarker, endMarker) {
-  let current = startMarker.nextSibling;
-  while (current && current !== endMarker) {
-    if (current === node) return true;
-    current = current.nextSibling;
-  }
-  return false;
-}
-function reorderBySwap(parent, first, second) {
-  if (first === second) return false;
-  const firstNodes = first.nodes;
-  const secondNodes = second.nodes;
-  if (firstNodes.length === 0 || secondNodes.length === 0) return false;
-  const lastFirst = firstNodes[firstNodes.length - 1];
-  const lastSecond = secondNodes[secondNodes.length - 1];
-  const afterFirst = lastFirst.nextSibling;
-  const afterSecond = lastSecond.nextSibling;
-  moveNodesBefore(parent, firstNodes, afterSecond);
-  moveNodesBefore(parent, secondNodes, afterFirst);
-  return true;
-}
-function getLISIndices(sequence) {
-  const predecessors = new Array(sequence.length);
-  const result = [];
-  for (let i = 0; i < sequence.length; i++) {
-    const value = sequence[i];
-    if (value < 0) {
-      predecessors[i] = -1;
-      continue;
-    }
-    let low = 0;
-    let high = result.length;
-    while (low < high) {
-      const mid = low + high >> 1;
-      if (sequence[result[mid]] < value) {
-        low = mid + 1;
-      } else {
-        high = mid;
-      }
-    }
-    predecessors[i] = low > 0 ? result[low - 1] : -1;
-    if (low === result.length) {
-      result.push(i);
-    } else {
-      result[low] = i;
-    }
-  }
-  const lis = new Array(result.length);
-  let k = result.length > 0 ? result[result.length - 1] : -1;
-  for (let i = result.length - 1; i >= 0; i--) {
-    lis[i] = k;
-    k = predecessors[k];
-  }
-  return lis;
-}
-function reorderByLIS(parent, endMarker, prev, next) {
-  const positions = /* @__PURE__ */ new Map();
-  for (let i = 0; i < prev.length; i++) {
-    positions.set(prev[i], i);
-  }
-  const sequence = new Array(next.length);
-  for (let i = 0; i < next.length; i++) {
-    const position = positions.get(next[i]);
-    if (position === void 0) return false;
-    sequence[i] = position;
-  }
-  const lisIndices = getLISIndices(sequence);
-  if (lisIndices.length === sequence.length) return true;
-  const inLIS = new Array(sequence.length).fill(false);
-  for (let i = 0; i < lisIndices.length; i++) {
-    inLIS[lisIndices[i]] = true;
-  }
-  let anchor = endMarker;
-  let moved = false;
-  for (let i = next.length - 1; i >= 0; i--) {
-    const block = next[i];
-    const nodes = block.nodes;
-    if (nodes.length === 0) continue;
-    if (inLIS[i]) {
-      anchor = nodes[0];
-      continue;
-    }
-    moveNodesBefore(parent, nodes, anchor);
-    anchor = nodes[0];
-    moved = true;
-  }
-  return moved;
-}
-function createKeyedList(getItems, keyFn, renderItem, needsIndex) {
-  const resolvedNeedsIndex = arguments.length >= 4 ? !!needsIndex : renderItem.length > 1;
-  return createFineGrainedKeyedList(getItems, keyFn, renderItem, resolvedNeedsIndex);
-}
-function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
-  const container = createKeyedListContainer();
-  const hostRoot = getCurrentRoot();
-  const fragment = document.createDocumentFragment();
-  fragment.append(container.startMarker, container.endMarker);
-  let disposed = false;
-  let effectDispose;
-  let connectObserver = null;
-  let effectStarted = false;
-  let startScheduled = false;
-  const getConnectedParent = () => {
-    const endParent = container.endMarker.parentNode;
-    const startParent = container.startMarker.parentNode;
-    if (endParent && startParent && endParent === startParent && endParent.nodeType !== 11) {
-      return endParent;
-    }
-    return null;
-  };
-  const performDiff = () => {
-    if (disposed) return;
-    const parent = getConnectedParent();
-    if (!parent) return;
-    batch2(() => {
-      const oldBlocks = container.blocks;
-      const newBlocks = container.nextBlocks;
-      const prevOrderedBlocks = container.orderedBlocks;
-      const nextOrderedBlocks = container.nextOrderedBlocks;
-      const orderedIndexByKey = container.orderedIndexByKey;
-      const newItems = getItems();
-      if (newItems.length === 0) {
-        if (oldBlocks.size > 0) {
-          for (const block of oldBlocks.values()) {
-            destroyRoot(block.root);
-          }
-          const range = document.createRange();
-          range.setStartAfter(container.startMarker);
-          range.setEndBefore(container.endMarker);
-          range.deleteContents();
-        }
-        oldBlocks.clear();
-        newBlocks.clear();
-        prevOrderedBlocks.length = 0;
-        nextOrderedBlocks.length = 0;
-        orderedIndexByKey.clear();
-        container.currentNodes.length = 0;
-        container.currentNodes.push(container.startMarker, container.endMarker);
-        container.nextNodes.length = 0;
-        return;
-      }
-      const prevCount = prevOrderedBlocks.length;
-      if (prevCount > 0 && newItems.length === prevCount && orderedIndexByKey.size === prevCount) {
-        let stableOrder = true;
-        const seen = /* @__PURE__ */ new Set();
-        for (let i = 0; i < prevCount; i++) {
-          const item = newItems[i];
-          const key = keyFn(item, i);
-          if (seen.has(key) || prevOrderedBlocks[i].key !== key) {
-            stableOrder = false;
-            break;
-          }
-          seen.add(key);
-        }
-        if (stableOrder) {
-          for (let i = 0; i < prevCount; i++) {
-            const item = newItems[i];
-            const block = prevOrderedBlocks[i];
-            if (block.rawItem !== item) {
-              block.rawItem = item;
-              block.item(item);
-            }
-            if (needsIndex && block.rawIndex !== i) {
-              block.rawIndex = i;
-              block.index(i);
-            }
-          }
-          return;
-        }
-      }
-      newBlocks.clear();
-      nextOrderedBlocks.length = 0;
-      orderedIndexByKey.clear();
-      const createdBlocks = [];
-      let appendCandidate = prevCount > 0 && newItems.length >= prevCount;
-      const appendedBlocks = [];
-      let mismatchCount = 0;
-      let mismatchFirst = -1;
-      let mismatchSecond = -1;
-      let hasDuplicateKey = false;
-      newItems.forEach((item, index) => {
-        const key = keyFn(item, index);
-        let block = oldBlocks.get(key);
-        const existed = block !== void 0;
-        if (block) {
-          if (block.rawItem !== item) {
-            block.rawItem = item;
-            block.item(item);
-          }
-          if (needsIndex && block.rawIndex !== index) {
-            block.rawIndex = index;
-            block.index(index);
-          }
-        }
-        if (block) {
-          newBlocks.set(key, block);
-          oldBlocks.delete(key);
-        } else {
-          const existingBlock = newBlocks.get(key);
-          if (existingBlock) {
-            if (isDev2) {
-              console.warn(
-                `[fict] Duplicate key "${String(key)}" detected in list rendering. Each item should have a unique key. The previous item with this key will be replaced.`
-              );
-            }
-            destroyRoot(existingBlock.root);
-            removeNodes(existingBlock.nodes);
-          }
-          block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot);
-          createdBlocks.push(block);
-        }
-        const resolvedBlock = block;
-        newBlocks.set(key, resolvedBlock);
-        const position = orderedIndexByKey.get(key);
-        if (position !== void 0) {
-          appendCandidate = false;
-          hasDuplicateKey = true;
-          const prior = nextOrderedBlocks[position];
-          if (prior && prior !== resolvedBlock) {
-            destroyRoot(prior.root);
-            removeNodes(prior.nodes);
-          }
-          nextOrderedBlocks[position] = resolvedBlock;
-        } else {
-          if (appendCandidate) {
-            if (index < prevCount) {
-              if (!prevOrderedBlocks[index] || prevOrderedBlocks[index].key !== key) {
-                appendCandidate = false;
-              }
-            } else if (existed) {
-              appendCandidate = false;
-            }
-          }
-          const nextIndex = nextOrderedBlocks.length;
-          orderedIndexByKey.set(key, nextIndex);
-          nextOrderedBlocks.push(resolvedBlock);
-          if (mismatchCount < 3 && (nextIndex >= prevCount || prevOrderedBlocks[nextIndex] !== resolvedBlock)) {
-            if (mismatchCount === 0) {
-              mismatchFirst = nextIndex;
-            } else if (mismatchCount === 1) {
-              mismatchSecond = nextIndex;
-            }
-            mismatchCount++;
-          }
-        }
-        if (appendCandidate && index >= prevCount) {
-          appendedBlocks.push(resolvedBlock);
-        }
-      });
-      const canAppend = appendCandidate && prevCount > 0 && newItems.length > prevCount && oldBlocks.size === 0 && appendedBlocks.length > 0;
-      if (canAppend) {
-        const appendedNodes = [];
-        for (const block of appendedBlocks) {
-          for (let i = 0; i < block.nodes.length; i++) {
-            appendedNodes.push(block.nodes[i]);
-          }
-        }
-        if (appendedNodes.length > 0) {
-          insertNodesBefore(parent, appendedNodes, container.endMarker);
-          const currentNodes = container.currentNodes;
-          currentNodes.pop();
-          for (let i = 0; i < appendedNodes.length; i++) {
-            currentNodes.push(appendedNodes[i]);
-          }
-          currentNodes.push(container.endMarker);
-        }
-        container.blocks = newBlocks;
-        container.nextBlocks = oldBlocks;
-        container.orderedBlocks = nextOrderedBlocks;
-        container.nextOrderedBlocks = prevOrderedBlocks;
-        for (const block of createdBlocks) {
-          if (newBlocks.get(block.key) === block) {
-            flushOnMount(block.root);
-          }
-        }
-        return;
-      }
-      if (oldBlocks.size > 0) {
-        for (const block of oldBlocks.values()) {
-          destroyRoot(block.root);
-          removeNodes(block.nodes);
-        }
-        oldBlocks.clear();
-      }
-      const canReorderInPlace = createdBlocks.length === 0 && oldBlocks.size === 0 && nextOrderedBlocks.length === prevOrderedBlocks.length;
-      let skipReconcile = false;
-      let updateNodeBuffer = true;
-      if (canReorderInPlace && nextOrderedBlocks.length > 0 && !hasDuplicateKey) {
-        if (mismatchCount === 0) {
-          skipReconcile = true;
-          updateNodeBuffer = false;
-        } else if (mismatchCount === 2 && prevOrderedBlocks[mismatchFirst] === nextOrderedBlocks[mismatchSecond] && prevOrderedBlocks[mismatchSecond] === nextOrderedBlocks[mismatchFirst]) {
-          if (reorderBySwap(
-            parent,
-            prevOrderedBlocks[mismatchFirst],
-            prevOrderedBlocks[mismatchSecond]
-          )) {
-            skipReconcile = true;
-          }
-        } else if (reorderByLIS(parent, container.endMarker, prevOrderedBlocks, nextOrderedBlocks)) {
-          skipReconcile = true;
+        try {
+          const clone = parent.ownerDocument.importNode(node, true);
+          parent.insertBefore(clone, anchor);
+          return;
+        } catch {
         }
       }
-      if (!skipReconcile && (newBlocks.size > 0 || container.currentNodes.length > 0)) {
-        const prevNodes = container.currentNodes;
-        const nextNodes = container.nextNodes;
-        nextNodes.length = 0;
-        nextNodes.push(container.startMarker);
-        for (let i = 0; i < nextOrderedBlocks.length; i++) {
-          const nodes = nextOrderedBlocks[i].nodes;
-          for (let j = 0; j < nodes.length; j++) {
-            nextNodes.push(nodes[j]);
-          }
-        }
-        nextNodes.push(container.endMarker);
-        reconcileArrays(parent, prevNodes, nextNodes);
-        container.currentNodes = nextNodes;
-        container.nextNodes = prevNodes;
-      } else if (skipReconcile && updateNodeBuffer) {
-        const prevNodes = container.currentNodes;
-        const nextNodes = container.nextNodes;
-        nextNodes.length = 0;
-        nextNodes.push(container.startMarker);
-        for (let i = 0; i < nextOrderedBlocks.length; i++) {
-          const nodes = nextOrderedBlocks[i].nodes;
-          for (let j = 0; j < nodes.length; j++) {
-            nextNodes.push(nodes[j]);
-          }
+      throw e;
+    }
+    return;
+  }
+  const doc = parent.ownerDocument;
+  if (doc) {
+    const frag = doc.createDocumentFragment();
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node === void 0 || node === null) continue;
+      if (node.nodeType === 11) {
+        const childrenArr = Array.from(node.childNodes);
+        for (let j = 0; j < childrenArr.length; j++) {
+          frag.appendChild(childrenArr[j]);
         }
-        nextNodes.push(container.endMarker);
-        container.currentNodes = nextNodes;
-        container.nextNodes = prevNodes;
-      }
-      container.blocks = newBlocks;
-      container.nextBlocks = oldBlocks;
-      container.orderedBlocks = nextOrderedBlocks;
-      container.nextOrderedBlocks = prevOrderedBlocks;
-      for (const block of createdBlocks) {
-        if (newBlocks.get(block.key) === block) {
-          flushOnMount(block.root);
+      } else {
+        if (node.ownerDocument !== doc) {
+          doc.adoptNode(node);
         }
+        frag.appendChild(node);
       }
-    });
-  };
-  const disconnectObserver = () => {
-    connectObserver?.disconnect();
-    connectObserver = null;
-  };
-  const ensureEffectStarted = () => {
-    if (disposed || effectStarted) return effectStarted;
-    const parent = getConnectedParent();
-    if (!parent) return false;
-    const start = () => {
-      effectDispose = createRenderEffect(performDiff);
-      effectStarted = true;
-    };
-    if (hostRoot) {
-      const prev = pushRoot(hostRoot);
-      try {
-        start();
-      } finally {
-        popRoot(prev);
-      }
-    } else {
-      start();
     }
-    return true;
-  };
-  const waitForConnection = () => {
-    if (connectObserver || typeof MutationObserver === "undefined") return;
-    connectObserver = new MutationObserver(() => {
-      if (disposed) return;
-      if (getConnectedParent()) {
-        disconnectObserver();
-        if (ensureEffectStarted()) {
-          flush();
+    parent.insertBefore(frag, anchor);
+    return;
+  }
+  const insertSingle = (nodeToInsert, anchorNode) => {
+    if (nodeToInsert.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
+      parent.ownerDocument.adoptNode(nodeToInsert);
+    }
+    try {
+      parent.insertBefore(nodeToInsert, anchorNode);
+      return nodeToInsert;
+    } catch (e) {
+      if (parent.ownerDocument) {
+        try {
+          const clone = parent.ownerDocument.importNode(nodeToInsert, true);
+          parent.insertBefore(clone, anchorNode);
+          return clone;
+        } catch {
         }
       }
-    });
-    connectObserver.observe(document, { childList: true, subtree: true });
-  };
-  const scheduleStart = () => {
-    if (startScheduled || disposed || effectStarted) return;
-    startScheduled = true;
-    const run = () => {
-      startScheduled = false;
-      if (!ensureEffectStarted()) {
-        waitForConnection();
-      }
-    };
-    if (typeof queueMicrotask === "function") {
-      queueMicrotask(run);
-    } else {
-      Promise.resolve().then(run).catch(() => void 0);
+      throw e;
     }
   };
-  scheduleStart();
-  return {
-    get marker() {
-      scheduleStart();
-      return fragment;
-    },
-    startMarker: container.startMarker,
-    endMarker: container.endMarker,
-    // Flush pending items - call after markers are inserted into DOM
-    flush: () => {
-      if (disposed) return;
-      scheduleStart();
-      if (ensureEffectStarted()) {
-        flush();
-      } else {
-        waitForConnection();
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const node = nodes[i];
+    if (node === void 0 || node === null) continue;
+    const isFrag = node.nodeType === 11;
+    if (isFrag) {
+      const childrenArr = Array.from(node.childNodes);
+      for (let j = childrenArr.length - 1; j >= 0; j--) {
+        const child = childrenArr[j];
+        anchor = insertSingle(child, anchor);
       }
-    },
-    dispose: () => {
-      disposed = true;
-      effectDispose?.();
-      disconnectObserver();
-      container.dispose();
+    } else {
+      anchor = insertSingle(node, anchor);
     }
-  };
+  }
+}
+function removeNodes(nodes) {
+  for (const node of nodes) {
+    node.parentNode?.removeChild(node);
+  }
 }
 
 // src/binding.ts
+var isDev5 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
 function isReactive(value) {
   return typeof value === "function" && value.length === 0;
 }
-function unwrap2(value) {
-  return isReactive(value) ? value() : value;
-}
 function callEventHandler(handler, event, node, data) {
   if (!handler) return;
   const context = node ?? event.currentTarget ?? void 0;
@@ -3076,46 +1638,6 @@ function callEventHandler(handler, event, node, data) {
   };
   invoke(handler);
 }
-var PRIMITIVE_PROXY = Symbol("fict:primitive-proxy");
-var PRIMITIVE_PROXY_RAW_VALUE = Symbol("fict:primitive-proxy:raw-value");
-function unwrapPrimitive(value) {
-  if (value && typeof value === "object" && PRIMITIVE_PROXY in value) {
-    const getRawValue = value[PRIMITIVE_PROXY_RAW_VALUE];
-    if (typeof getRawValue === "function") {
-      return getRawValue();
-    }
-  }
-  return value;
-}
-function createTextBinding(value) {
-  const text = document.createTextNode("");
-  if (isReactive(value)) {
-    createRenderEffect(() => {
-      const v = value();
-      const fmt = formatTextValue(v);
-      if (text.data !== fmt) {
-        text.data = fmt;
-      }
-    });
-  } else {
-    text.data = formatTextValue(value);
-  }
-  return text;
-}
-function bindText(textNode, getValue) {
-  return createRenderEffect(() => {
-    const value = formatTextValue(getValue());
-    if (textNode.data !== value) {
-      textNode.data = value;
-    }
-  });
-}
-function formatTextValue(value) {
-  if (value == null || value === false) {
-    return "";
-  }
-  return String(value);
-}
 function createAttributeBinding(el, key, value, setter) {
   if (isReactive(value)) {
     createRenderEffect(() => {
@@ -3125,45 +1647,6 @@ function createAttributeBinding(el, key, value, setter) {
     setter(el, key, value);
   }
 }
-function bindAttribute(el, key, getValue) {
-  let prevValue = void 0;
-  return createRenderEffect(() => {
-    const value = getValue();
-    if (value === prevValue) return;
-    prevValue = value;
-    if (value === void 0 || value === null || value === false) {
-      el.removeAttribute(key);
-    } else if (value === true) {
-      el.setAttribute(key, "");
-    } else {
-      el.setAttribute(key, String(value));
-    }
-  });
-}
-function bindProperty(el, key, getValue) {
-  const PROPERTY_BINDING_KEYS = /* @__PURE__ */ new Set([
-    "value",
-    "checked",
-    "selected",
-    "disabled",
-    "readOnly",
-    "multiple",
-    "muted"
-  ]);
-  let prevValue = void 0;
-  return createRenderEffect(() => {
-    const next = getValue();
-    if (next === prevValue) return;
-    prevValue = next;
-    if (PROPERTY_BINDING_KEYS.has(key) && (next === void 0 || next === null)) {
-      const fallback = key === "checked" || key === "selected" ? false : "";
-      el[key] = fallback;
-      return;
-    }
-    ;
-    el[key] = next;
-  });
-}
 function createStyleBinding(el, value) {
   const target = el;
   if (isReactive(value)) {
@@ -3177,15 +1660,6 @@ function createStyleBinding(el, value) {
     applyStyle(target, value, void 0);
   }
 }
-function bindStyle(el, getValue) {
-  const target = el;
-  let prev;
-  return createRenderEffect(() => {
-    const next = getValue();
-    applyStyle(target, next, prev);
-    prev = next;
-  });
-}
 function applyStyle(el, value, prev) {
   if (typeof value === "string") {
     el.style.cssText = value;
@@ -3203,14 +1677,14 @@ function applyStyle(el, value, prev) {
         }
       }
     }
-    for (const [prop, v] of Object.entries(styles)) {
+    for (const [prop2, v] of Object.entries(styles)) {
       if (v != null) {
-        const cssProperty = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
-        const unitless = isUnitlessStyleProperty(prop) || isUnitlessStyleProperty(cssProperty);
+        const cssProperty = prop2.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const unitless = isUnitlessStyleProperty(prop2) || isUnitlessStyleProperty(cssProperty);
         const valueStr = typeof v === "number" && !unitless ? `${v}px` : String(v);
         el.style.setProperty(cssProperty, valueStr);
       } else {
-        const cssProperty = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const cssProperty = prop2.replace(/([A-Z])/g, "-$1").toLowerCase();
         el.style.removeProperty(cssProperty);
       }
     }
@@ -3226,9 +1700,7 @@ function applyStyle(el, value, prev) {
     }
   }
 }
-function isUnitlessStyleProperty(prop) {
-  return UnitlessStyles.has(prop);
-}
+var isUnitlessStyleProperty = isDev5 ? (prop2) => UnitlessStyles.has(prop2) : (prop2) => prop2 === "opacity" || prop2 === "zIndex";
 function createClassBinding(el, value) {
   if (isReactive(value)) {
     let prev = {};
@@ -3240,22 +1712,6 @@ function createClassBinding(el, value) {
     applyClass(el, value, {});
   }
 }
-function bindClass(el, getValue) {
-  let prev = {};
-  let prevString;
-  return createRenderEffect(() => {
-    const next = getValue();
-    if (typeof next === "string") {
-      if (next === prevString) return;
-      prevString = next;
-      el.className = next;
-      prev = {};
-      return;
-    }
-    prevString = void 0;
-    prev = applyClass(el, next, prev);
-  });
-}
 function toggleClassKey(node, key, value) {
   const classNames = key.trim().split(/\s+/);
   for (let i = 0, len = classNames.length; i < len; i++) {
@@ -3297,119 +1753,6 @@ function applyClass(el, value, prev) {
   }
   return prevState;
 }
-function classList(node, value, prev = {}) {
-  return applyClass(node, value, prev);
-}
-function insert(parent, getValue, markerOrCreateElement, createElementFn) {
-  const hostRoot = getCurrentRoot();
-  let marker;
-  let ownsMarker = false;
-  let createFn = createElementFn;
-  if (markerOrCreateElement instanceof Node) {
-    marker = markerOrCreateElement;
-    createFn = createElementFn;
-  } else {
-    marker = document.createComment("fict:insert");
-    parent.appendChild(marker);
-    createFn = markerOrCreateElement;
-    ownsMarker = true;
-  }
-  let currentNodes = [];
-  let currentText = null;
-  let currentRoot2 = null;
-  const clearCurrentNodes = () => {
-    if (currentNodes.length > 0) {
-      removeNodes(currentNodes);
-      currentNodes = [];
-    }
-  };
-  const setTextNode = (textValue, shouldInsert, parentNode) => {
-    if (!currentText) {
-      currentText = document.createTextNode(textValue);
-    } else if (currentText.data !== textValue) {
-      currentText.data = textValue;
-    }
-    if (!shouldInsert) {
-      clearCurrentNodes();
-      return;
-    }
-    if (currentNodes.length === 1 && currentNodes[0] === currentText) {
-      return;
-    }
-    clearCurrentNodes();
-    insertNodesBefore(parentNode, [currentText], marker);
-    currentNodes = [currentText];
-  };
-  const dispose = createRenderEffect(() => {
-    const value = getValue();
-    const parentNode = marker.parentNode;
-    const isPrimitive = value == null || value === false || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-    if (isPrimitive) {
-      if (currentRoot2) {
-        destroyRoot(currentRoot2);
-        currentRoot2 = null;
-      }
-      if (!parentNode) {
-        clearCurrentNodes();
-        return;
-      }
-      const textValue = value == null || value === false ? "" : String(value);
-      const shouldInsert = value != null && value !== false;
-      setTextNode(textValue, shouldInsert, parentNode);
-      return;
-    }
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-      currentRoot2 = null;
-    }
-    clearCurrentNodes();
-    const root = createRootContext(hostRoot);
-    const prev = pushRoot(root);
-    let nodes = [];
-    try {
-      let newNode;
-      if (value instanceof Node) {
-        newNode = value;
-      } else if (Array.isArray(value)) {
-        if (value.every((v) => v instanceof Node)) {
-          newNode = value;
-        } else {
-          if (createFn) {
-            const mapped = [];
-            for (const item of value) {
-              mapped.push(...toNodeArray(createFn(item)));
-            }
-            newNode = mapped;
-          } else {
-            newNode = document.createTextNode(String(value));
-          }
-        }
-      } else {
-        newNode = createFn ? createFn(value) : document.createTextNode(String(value));
-      }
-      nodes = toNodeArray(newNode);
-      if (parentNode) {
-        insertNodesBefore(parentNode, nodes, marker);
-      }
-    } finally {
-      popRoot(prev);
-      flushOnMount(root);
-    }
-    currentRoot2 = root;
-    currentNodes = nodes;
-  });
-  return () => {
-    dispose();
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-      currentRoot2 = null;
-    }
-    clearCurrentNodes();
-    if (ownsMarker) {
-      marker.parentNode?.removeChild(marker);
-    }
-  };
-}
 function createChildBinding(parent, getValue, createElementFn) {
   const marker = document.createComment("fict:child");
   parent.appendChild(marker);
@@ -3471,15 +1814,6 @@ function delegateEvents(eventNames, doc = window.document) {
     }
   }
 }
-function clearDelegatedEvents(doc = window.document) {
-  const e = doc[$$EVENTS];
-  if (e) {
-    for (const name of e.keys()) {
-      doc.removeEventListener(name, globalEventHandler);
-    }
-    delete doc[$$EVENTS];
-  }
-}
 function globalEventHandler(e) {
   const asNode = (value) => value && typeof value.nodeType === "number" ? value : null;
   const asElement = (value) => {
@@ -3560,785 +1894,664 @@ function globalEventHandler(e) {
         walkUpTree();
         break;
       }
-      if (node.parentNode === oriCurrentTarget) {
-        break;
+      if (node.parentNode === oriCurrentTarget) {
+        break;
+      }
+    }
+  } else {
+    walkUpTree();
+  }
+  retarget(oriTarget);
+}
+function bindEvent(el, eventName, handler, options) {
+  if (handler == null) return () => {
+  };
+  const rootRef = getCurrentRoot();
+  if (isDev5 && DelegatedEvents.has(eventName) && !options) {
+    const key = `$$${eventName}`;
+    delegateEvents([eventName]);
+    const resolveHandler = isReactive(handler) ? handler : () => handler;
+    el[key] = function(...args) {
+      try {
+        const fn = resolveHandler();
+        callEventHandler(fn, args[0], el);
+      } catch (err) {
+        if (!handleError(err, { source: "event", eventName }, rootRef)) {
+          throw err;
+        }
+      }
+    };
+    return () => {
+      el[key] = void 0;
+    };
+  }
+  const getHandler = isReactive(handler) ? handler : () => handler;
+  const wrapped = (event) => {
+    try {
+      const resolved = getHandler();
+      callEventHandler(resolved, event, el);
+    } catch (err) {
+      if (handleError(err, { source: "event", eventName }, rootRef)) {
+        return;
+      }
+      throw err;
+    }
+  };
+  el.addEventListener(eventName, wrapped, options);
+  const cleanup = () => el.removeEventListener(eventName, wrapped, options);
+  registerRootCleanup(cleanup);
+  return cleanup;
+}
+function createPortal(container, render2, createElementFn) {
+  const parentRoot = getCurrentRoot();
+  const marker = document.createComment("fict:portal");
+  container.appendChild(marker);
+  let currentNodes = [];
+  let currentRoot2 = null;
+  const dispose = createRenderEffect(() => {
+    if (currentRoot2) {
+      destroyRoot(currentRoot2);
+      currentRoot2 = null;
+    }
+    if (currentNodes.length > 0) {
+      removeNodes(currentNodes);
+      currentNodes = [];
+    }
+    const root = createRootContext(parentRoot);
+    const prev = pushRoot(root);
+    let handledError = false;
+    try {
+      const output = render2();
+      if (output != null && output !== false) {
+        const el = createElementFn(output);
+        const nodes = toNodeArray(el);
+        if (marker.parentNode) {
+          insertNodesBefore(marker.parentNode, nodes, marker);
+        }
+        currentNodes = nodes;
+      }
+    } catch (err) {
+      if (handleSuspend(err, root)) {
+        handledError = true;
+        destroyRoot(root);
+        currentNodes = [];
+        return;
+      }
+      if (handleError(err, { source: "renderChild" }, root)) {
+        handledError = true;
+        destroyRoot(root);
+        currentNodes = [];
+        return;
+      }
+      throw err;
+    } finally {
+      popRoot(prev);
+      if (!handledError) {
+        flushOnMount(root);
+        currentRoot2 = root;
+      } else {
+        currentRoot2 = null;
       }
     }
-  } else {
-    walkUpTree();
+  });
+  const portalDispose = () => {
+    dispose();
+    if (currentRoot2) {
+      destroyRoot(currentRoot2);
+    }
+    if (currentNodes.length > 0) {
+      removeNodes(currentNodes);
+    }
+    marker.parentNode?.removeChild(marker);
+  };
+  if (parentRoot) {
+    parentRoot.destroyCallbacks.push(portalDispose);
   }
-  retarget(oriTarget);
+  return {
+    marker,
+    dispose: portalDispose
+  };
 }
-function addEventListener(node, name, handler, delegate) {
-  if (handler == null) return;
-  if (delegate) {
-    if (Array.isArray(handler)) {
-      ;
-      node[`$$${name}`] = handler[0];
-      node[`$$${name}Data`] = handler[1];
-    } else {
-      ;
-      node[`$$${name}`] = handler;
-    }
-  } else if (Array.isArray(handler)) {
-    const handlerFn = handler[0];
-    node.addEventListener(name, (e) => handlerFn.call(node, handler[1], e));
-  } else {
-    node.addEventListener(name, handler);
+
+// src/hooks.ts
+var isDev6 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var ctxStack = [];
+function __fictPushContext() {
+  const ctx = { slots: [], cursor: 0 };
+  ctxStack.push(ctx);
+  return ctx;
+}
+function __fictPopContext() {
+  ctxStack.pop();
+}
+
+// src/props.ts
+var propGetters = /* @__PURE__ */ new WeakSet();
+var rawToProxy = /* @__PURE__ */ new WeakMap();
+var proxyToRaw = /* @__PURE__ */ new WeakMap();
+function __fictProp(getter) {
+  if (typeof getter === "function" && getter.length === 0) {
+    propGetters.add(getter);
   }
+  return getter;
 }
-function bindEvent(el, eventName, handler, options2) {
-  if (handler == null) return () => {
-  };
-  const rootRef = getCurrentRoot();
-  if (DelegatedEvents.has(eventName) && !options2) {
-    const key = `$$${eventName}`;
-    delegateEvents([eventName]);
-    const resolveHandler = isReactive(handler) ? handler : () => handler;
-    el[key] = function(...args) {
-      try {
-        const fn = resolveHandler();
-        callEventHandler(fn, args[0], el);
-      } catch (err) {
-        if (!handleError(err, { source: "event", eventName }, rootRef)) {
-          throw err;
-        }
-      }
-    };
-    return () => {
-      el[key] = void 0;
-    };
+function isPropGetter(value) {
+  return typeof value === "function" && propGetters.has(value);
+}
+function createPropsProxy(props) {
+  if (!props || typeof props !== "object") {
+    return props;
   }
-  const getHandler = isReactive(handler) ? handler : () => handler;
-  const wrapped = (event) => {
-    try {
-      const resolved = getHandler();
-      callEventHandler(resolved, event, el);
-    } catch (err) {
-      if (handleError(err, { source: "event", eventName }, rootRef)) {
-        return;
+  if (proxyToRaw.has(props)) {
+    return props;
+  }
+  const cached = rawToProxy.get(props);
+  if (cached) {
+    return cached;
+  }
+  const proxy = new Proxy(props, {
+    get(target, prop2, receiver) {
+      const value = Reflect.get(target, prop2, receiver);
+      if (isPropGetter(value)) {
+        return value();
       }
-      throw err;
+      return value;
+    },
+    set(target, prop2, value, receiver) {
+      return Reflect.set(target, prop2, value, receiver);
+    },
+    has(target, prop2) {
+      return prop2 in target;
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, prop2) {
+      return Object.getOwnPropertyDescriptor(target, prop2);
     }
-  };
-  el.addEventListener(eventName, wrapped, options2);
-  const cleanup = () => el.removeEventListener(eventName, wrapped, options2);
-  registerRootCleanup(cleanup);
-  return cleanup;
+  });
+  rawToProxy.set(props, proxy);
+  proxyToRaw.set(proxy, props);
+  return proxy;
+}
+function unwrapProps(props) {
+  if (!props || typeof props !== "object") {
+    return props;
+  }
+  return proxyToRaw.get(props) ?? props;
 }
-function bindRef(el, ref) {
-  if (ref == null) return () => {
+function mergeProps(...sources) {
+  const validSources = sources.filter(
+    (s) => s != null && (typeof s === "object" || typeof s === "function")
+  );
+  if (validSources.length === 0) {
+    return {};
+  }
+  if (validSources.length === 1 && typeof validSources[0] === "object") {
+    return validSources[0];
+  }
+  const resolveSource = (src) => {
+    const value = typeof src === "function" ? src() : src;
+    if (!value || typeof value !== "object") return void 0;
+    return unwrapProps(value);
   };
-  const getRef = isReactive(ref) ? ref : () => ref;
-  const applyRef2 = (refValue) => {
-    if (refValue == null) return;
-    if (typeof refValue === "function") {
-      ;
-      refValue(el);
-    } else if (typeof refValue === "object" && "current" in refValue) {
-      ;
-      refValue.current = el;
+  const hasProp = (prop2) => {
+    for (const src of validSources) {
+      const raw = resolveSource(src);
+      if (raw && prop2 in raw) {
+        return true;
+      }
     }
+    return false;
   };
-  const initialRef = getRef();
-  applyRef2(initialRef);
-  if (isReactive(ref)) {
-    const cleanup2 = createRenderEffect(() => {
-      const currentRef = getRef();
-      applyRef2(currentRef);
-    });
-    registerRootCleanup(cleanup2);
-    const nullifyCleanup = () => {
-      const currentRef = getRef();
-      if (currentRef && typeof currentRef === "object" && "current" in currentRef) {
-        ;
-        currentRef.current = null;
+  const readProp = (prop2) => {
+    for (let i = validSources.length - 1; i >= 0; i--) {
+      const src = validSources[i];
+      const raw = resolveSource(src);
+      if (!raw || !(prop2 in raw)) continue;
+      const value = raw[prop2];
+      if (typeof src === "function" && !isPropGetter(value)) {
+        return __fictProp(() => {
+          const latest = resolveSource(src);
+          if (!latest || !(prop2 in latest)) return void 0;
+          return latest[prop2];
+        });
       }
-    };
-    registerRootCleanup(nullifyCleanup);
-    return () => {
-      cleanup2();
-      nullifyCleanup();
-    };
-  }
-  const cleanup = () => {
-    const refValue = getRef();
-    if (refValue && typeof refValue === "object" && "current" in refValue) {
-      ;
-      refValue.current = null;
+      return value;
     }
+    return void 0;
   };
-  registerRootCleanup(cleanup);
-  return cleanup;
-}
-function spread(node, props = {}, isSVG = false, skipChildren = false) {
-  const prevProps = {};
-  if (!skipChildren && "children" in props) {
-    createRenderEffect(() => {
-      prevProps.children = props.children;
-    });
-  }
-  createRenderEffect(() => {
-    if (typeof props.ref === "function") {
-      ;
-      props.ref(node);
+  return new Proxy({}, {
+    get(_, prop2) {
+      return readProp(prop2);
+    },
+    has(_, prop2) {
+      return hasProp(prop2);
+    },
+    ownKeys() {
+      const keys = /* @__PURE__ */ new Set();
+      for (const src of validSources) {
+        const raw = resolveSource(src);
+        if (raw) {
+          for (const key of Reflect.ownKeys(raw)) {
+            keys.add(key);
+          }
+        }
+      }
+      return Array.from(keys);
+    },
+    getOwnPropertyDescriptor(_, prop2) {
+      if (!hasProp(prop2)) return void 0;
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => readProp(prop2)
+      };
     }
   });
-  createRenderEffect(() => {
-    assign(node, props, isSVG, true, prevProps, true);
-  });
-  return prevProps;
 }
-function assign(node, props, isSVG = false, skipChildren = false, prevProps = {}, skipRef = false) {
-  props = props || {};
-  for (const prop in prevProps) {
-    if (!(prop in props)) {
-      if (prop === "children") continue;
-      prevProps[prop] = assignProp(node, prop, null, prevProps[prop], isSVG, skipRef, props);
+function prop(getter) {
+  if (isPropGetter(getter)) {
+    return getter;
+  }
+  return __fictProp(createMemo(getter));
+}
+
+// src/dom.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+var isDev7 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+function render(view, container) {
+  const root = createRootContext();
+  const prev = pushRoot(root);
+  let dom;
+  try {
+    const output = view();
+    dom = createElement(output);
+  } finally {
+    popRoot(prev);
+  }
+  container.replaceChildren(dom);
+  container.setAttribute("data-fict-fine-grained", "1");
+  flushOnMount(root);
+  const teardown = () => {
+    destroyRoot(root);
+    container.innerHTML = "";
+  };
+  return teardown;
+}
+function createElement(node) {
+  return createElementWithContext(node, null);
+}
+function resolveNamespace(tagName, namespace) {
+  if (tagName === "svg") return "svg";
+  if (tagName === "math") return "mathml";
+  if (namespace === "mathml") return "mathml";
+  if (namespace === "svg") return "svg";
+  if (isDev7 && SVGElements.has(tagName)) return "svg";
+  return null;
+}
+function createElementWithContext(node, namespace) {
+  if (node instanceof Node) {
+    return node;
+  }
+  if (node === null || node === void 0 || node === false) {
+    return document.createTextNode("");
+  }
+  if (typeof node === "object" && node !== null && !(node instanceof Node)) {
+    if ("marker" in node) {
+      const handle = node;
+      if (typeof handle.dispose === "function") {
+        registerRootCleanup(handle.dispose);
+      }
+      if (typeof handle.flush === "function") {
+        const runFlush = () => handle.flush && handle.flush();
+        if (typeof queueMicrotask === "function") {
+          queueMicrotask(runFlush);
+        } else {
+          Promise.resolve().then(runFlush).catch(() => void 0);
+        }
+      }
+      return createElement(handle.marker);
+    }
+  }
+  if (Array.isArray(node)) {
+    const frag = document.createDocumentFragment();
+    for (const child of node) {
+      appendChildNode(frag, child, namespace);
     }
+    return frag;
+  }
+  if (typeof node === "string" || typeof node === "number") {
+    return document.createTextNode(String(node));
   }
-  for (const prop in props) {
-    if (prop === "children") {
-      if (!skipChildren) {
-        prevProps.children = props.children;
+  if (typeof node === "boolean") {
+    return document.createTextNode("");
+  }
+  const vnode = node;
+  if (typeof vnode.type === "function") {
+    const rawProps = unwrapProps(vnode.props ?? {});
+    const baseProps = vnode.key === void 0 ? rawProps : new Proxy(rawProps, {
+      get(target, prop2, receiver) {
+        if (prop2 === "key") return vnode.key;
+        return Reflect.get(target, prop2, receiver);
+      },
+      has(target, prop2) {
+        if (prop2 === "key") return true;
+        return prop2 in target;
+      },
+      ownKeys(target) {
+        const keys = new Set(Reflect.ownKeys(target));
+        keys.add("key");
+        return Array.from(keys);
+      },
+      getOwnPropertyDescriptor(target, prop2) {
+        if (prop2 === "key") {
+          return { enumerable: true, configurable: true, value: vnode.key };
+        }
+        return Object.getOwnPropertyDescriptor(target, prop2);
+      }
+    });
+    const props = createPropsProxy(baseProps);
+    __fictPushContext();
+    try {
+      const rendered = vnode.type(props);
+      return createElementWithContext(rendered, namespace);
+    } catch (err) {
+      if (handleSuspend(err)) {
+        return document.createComment("fict:suspend");
       }
-      continue;
+      handleError(err, { source: "render", componentName: vnode.type.name });
+      throw err;
+    } finally {
+      __fictPopContext();
     }
-    const value = props[prop];
-    prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG, skipRef, props);
-  }
-}
-function assignProp(node, prop, value, prev, isSVG, skipRef, props) {
-  if (prop === "style") {
-    applyStyle(node, value, prev);
-    return value;
   }
-  if (prop === "classList") {
-    return applyClass(node, value, prev);
+  if (vnode.type === Fragment) {
+    const frag = document.createDocumentFragment();
+    const children = vnode.props?.children;
+    appendChildren(frag, children, namespace);
+    return frag;
   }
-  if (value === prev) return prev;
-  if (prop === "ref") {
-    if (!skipRef && typeof value === "function") {
-      ;
-      value(node);
-    }
-    return value;
+  const tagName = typeof vnode.type === "string" ? vnode.type : "div";
+  const resolvedNamespace = resolveNamespace(tagName, namespace);
+  const el = resolvedNamespace === "svg" ? document.createElementNS(SVG_NS, tagName) : resolvedNamespace === "mathml" ? document.createElementNS(MATHML_NS, tagName) : document.createElement(tagName);
+  applyProps(el, vnode.props ?? {}, resolvedNamespace === "svg");
+  appendChildren(
+    el,
+    vnode.props?.children,
+    tagName === "foreignObject" ? null : resolvedNamespace
+  );
+  return el;
+}
+function isBindingHandle(node) {
+  return node !== null && typeof node === "object" && "marker" in node && "dispose" in node && typeof node.dispose === "function";
+}
+function appendChildNode(parent, child, namespace) {
+  if (child === null || child === void 0 || child === false) {
+    return;
   }
-  if (prop.slice(0, 3) === "on:") {
-    const eventName = prop.slice(3);
-    if (prev) node.removeEventListener(eventName, prev);
-    if (value) node.addEventListener(eventName, value);
-    return value;
+  if (isBindingHandle(child)) {
+    appendChildNode(parent, child.marker, namespace);
+    child.flush?.();
+    return;
   }
-  if (prop.slice(0, 10) === "oncapture:") {
-    const eventName = prop.slice(10);
-    if (prev) node.removeEventListener(eventName, prev, true);
-    if (value) node.addEventListener(eventName, value, true);
-    return value;
+  if (typeof child === "function" && child.length === 0) {
+    const childGetter = child;
+    createChildBinding(parent, childGetter, (node) => createElementWithContext(node, namespace));
+    return;
   }
-  if (prop.slice(0, 2) === "on") {
-    const eventName = prop.slice(2).toLowerCase();
-    const shouldDelegate = DelegatedEvents.has(eventName);
-    if (!shouldDelegate && prev) {
-      const handler = Array.isArray(prev) ? prev[0] : prev;
-      node.removeEventListener(eventName, handler);
-    }
-    if (shouldDelegate || value) {
-      addEventListener(node, eventName, value, shouldDelegate);
-      if (shouldDelegate) delegateEvents([eventName]);
+  if (Array.isArray(child)) {
+    for (const item of child) {
+      appendChildNode(parent, item, namespace);
     }
-    return value;
-  }
-  if (prop.slice(0, 5) === "attr:") {
-    if (value == null) node.removeAttribute(prop.slice(5));
-    else node.setAttribute(prop.slice(5), String(value));
-    return value;
-  }
-  if (prop.slice(0, 5) === "bool:") {
-    if (value) node.setAttribute(prop.slice(5), "");
-    else node.removeAttribute(prop.slice(5));
-    return value;
-  }
-  if (prop.slice(0, 5) === "prop:") {
-    ;
-    node[prop.slice(5)] = value;
-    return value;
+    return;
   }
-  if (prop === "class" || prop === "className") {
-    if (value == null) node.removeAttribute("class");
-    else node.className = String(value);
-    return value;
+  let domNode;
+  if (typeof child !== "object" || child === null) {
+    domNode = document.createTextNode(String(child ?? ""));
+  } else {
+    domNode = createElementWithContext(child, namespace);
   }
-  const isCE = node.nodeName.includes("-") || "is" in props;
-  if (!isSVG) {
-    const propAlias = getPropAlias(prop, node.tagName);
-    const isProperty = Properties.has(prop);
-    const isChildProp = ChildProperties.has(prop);
-    if (propAlias || isProperty || isChildProp || isCE) {
-      const propName = propAlias || prop;
-      if (isCE && !isProperty && !isChildProp) {
-        ;
-        node[toPropertyName2(propName)] = value;
-      } else {
-        ;
-        node[propName] = value;
-      }
-      return value;
+  if (domNode.nodeType === 11) {
+    const children = Array.from(domNode.childNodes);
+    for (const node of children) {
+      appendChildNode(parent, node, namespace);
     }
+    return;
   }
-  if (isSVG && prop.indexOf(":") > -1) {
-    const [prefix, name] = prop.split(":");
-    const ns = SVGNamespace[prefix];
-    if (ns) {
-      if (value == null) node.removeAttributeNS(ns, name);
-      else node.setAttributeNS(ns, name, String(value));
-      return value;
-    }
+  if (domNode.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
+    parent.ownerDocument.adoptNode(domNode);
   }
-  const attrName = Aliases[prop] || prop;
-  if (value == null) node.removeAttribute(attrName);
-  else node.setAttribute(attrName, String(value));
-  return value;
-}
-function toPropertyName2(name) {
-  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
-}
-function createConditional(condition, renderTrue, createElementFn, renderFalse) {
-  const startMarker = document.createComment("fict:cond:start");
-  const endMarker = document.createComment("fict:cond:end");
-  const fragment = document.createDocumentFragment();
-  fragment.append(startMarker, endMarker);
-  const hostRoot = getCurrentRoot();
-  let currentNodes = [];
-  let currentRoot2 = null;
-  let lastCondition = void 0;
-  let pendingRender = false;
-  const conditionMemo = computed(condition);
-  const runConditional = () => {
-    const cond = conditionMemo();
-    const parent = startMarker.parentNode;
-    if (!parent) {
-      pendingRender = true;
-      return;
-    }
-    pendingRender = false;
-    if (lastCondition === cond && currentNodes.length > 0) {
-      return;
-    }
-    if (lastCondition === cond && lastCondition === false && renderFalse === void 0) {
-      return;
-    }
-    lastCondition = cond;
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-      currentRoot2 = null;
-    }
-    removeNodes(currentNodes);
-    currentNodes = [];
-    const render2 = cond ? renderTrue : renderFalse;
-    if (!render2) {
+  try {
+    parent.appendChild(domNode);
+  } catch (e) {
+    if (parent.ownerDocument) {
+      const clone = parent.ownerDocument.importNode(domNode, true);
+      parent.appendChild(clone);
       return;
     }
-    const root = createRootContext(hostRoot);
-    const prev = pushRoot(root);
-    let handledError = false;
-    try {
-      const output = untrack(render2);
-      if (output == null || output === false) {
-        return;
-      }
-      const el = createElementFn(output);
-      const nodes = toNodeArray(el);
-      insertNodesBefore(parent, nodes, endMarker);
-      currentNodes = nodes;
-    } catch (err) {
-      if (handleSuspend(err, root)) {
-        handledError = true;
-        destroyRoot(root);
-        return;
-      }
-      if (handleError(err, { source: "renderChild" }, root)) {
-        handledError = true;
-        destroyRoot(root);
-        return;
-      }
-      throw err;
-    } finally {
-      popRoot(prev);
-      if (!handledError) {
-        flushOnMount(root);
-        currentRoot2 = root;
-      } else {
-        currentRoot2 = null;
-      }
-    }
-  };
-  const dispose = createRenderEffect(runConditional);
-  return {
-    marker: fragment,
-    flush: () => {
-      if (pendingRender) {
-        runConditional();
-      }
-    },
-    dispose: () => {
-      dispose();
-      if (currentRoot2) {
-        destroyRoot(currentRoot2);
-      }
-      removeNodes(currentNodes);
-      currentNodes = [];
-      startMarker.parentNode?.removeChild(startMarker);
-      endMarker.parentNode?.removeChild(endMarker);
-    }
-  };
+    throw e;
+  }
 }
-function createList(items, renderItem, createElementFn, getKey) {
-  const startMarker = document.createComment("fict:list:start");
-  const endMarker = document.createComment("fict:list:end");
-  const fragment = document.createDocumentFragment();
-  fragment.append(startMarker, endMarker);
-  const hostRoot = getCurrentRoot();
-  const nodeMap = /* @__PURE__ */ new Map();
-  let pendingItems = null;
-  const runListUpdate = () => {
-    const arr = items();
-    const parent = startMarker.parentNode;
-    if (!parent) {
-      pendingItems = arr;
-      return;
-    }
-    pendingItems = null;
-    const newNodeMap = /* @__PURE__ */ new Map();
-    const blocks = [];
-    for (let i = 0; i < arr.length; i++) {
-      const item = arr[i];
-      const key = getKey ? getKey(item, i) : i;
-      const existing = nodeMap.get(key);
-      let block;
-      if (existing) {
-        const previousValue = existing.value();
-        if (!getKey && previousValue !== item) {
-          destroyRoot(existing.root);
-          removeBlockNodes(existing);
-          block = mountBlock(item, i, renderItem, parent, endMarker, createElementFn, hostRoot);
-        } else {
-          const previousIndex = existing.index();
-          existing.value(item);
-          existing.index(i);
-          const needsRerender = getKey ? true : previousValue !== item || previousIndex !== i;
-          block = needsRerender ? rerenderBlock(existing, createElementFn) : existing;
-        }
-      } else {
-        block = mountBlock(item, i, renderItem, parent, endMarker, createElementFn, hostRoot);
-      }
-      newNodeMap.set(key, block);
-      blocks.push(block);
-    }
-    for (const [key, managed] of nodeMap) {
-      if (!newNodeMap.has(key)) {
-        destroyRoot(managed.root);
-        removeBlockNodes(managed);
-      }
-    }
-    let anchor = endMarker;
-    for (let i = blocks.length - 1; i >= 0; i--) {
-      const block = blocks[i];
-      insertNodesBefore(parent, block.nodes, anchor);
-      if (block.nodes.length > 0) {
-        anchor = block.nodes[0];
-      }
-    }
-    nodeMap.clear();
-    for (const [k, v] of newNodeMap) {
-      nodeMap.set(k, v);
-    }
-  };
-  const dispose = createRenderEffect(runListUpdate);
-  return {
-    marker: fragment,
-    flush: () => {
-      if (pendingItems !== null) {
-        runListUpdate();
-      }
-    },
-    dispose: () => {
-      dispose();
-      for (const [, managed] of nodeMap) {
-        destroyRoot(managed.root);
-        removeBlockNodes(managed);
-      }
-      nodeMap.clear();
-      startMarker.parentNode?.removeChild(startMarker);
-      endMarker.parentNode?.removeChild(endMarker);
+function appendChildren(parent, children, namespace) {
+  if (children === void 0) return;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      appendChildren(parent, child, namespace);
     }
-  };
-}
-function createShow(el, condition, displayValue) {
-  const originalDisplay = displayValue ?? el.style.display;
-  createRenderEffect(() => {
-    el.style.display = condition() ? originalDisplay : "none";
-  });
+    return;
+  }
+  appendChildNode(parent, children, namespace);
 }
-function createPortal(container, render2, createElementFn) {
-  const parentRoot = getCurrentRoot();
-  const marker = document.createComment("fict:portal");
-  container.appendChild(marker);
-  let currentNodes = [];
-  let currentRoot2 = null;
-  const dispose = createRenderEffect(() => {
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-      currentRoot2 = null;
-    }
-    if (currentNodes.length > 0) {
-      removeNodes(currentNodes);
-      currentNodes = [];
-    }
-    const root = createRootContext(parentRoot);
-    const prev = pushRoot(root);
-    let handledError = false;
-    try {
-      const output = render2();
-      if (output != null && output !== false) {
-        const el = createElementFn(output);
-        const nodes = toNodeArray(el);
-        if (marker.parentNode) {
-          insertNodesBefore(marker.parentNode, nodes, marker);
-        }
-        currentNodes = nodes;
-      }
-    } catch (err) {
-      if (handleSuspend(err, root)) {
-        handledError = true;
-        destroyRoot(root);
-        currentNodes = [];
-        return;
-      }
-      if (handleError(err, { source: "renderChild" }, root)) {
-        handledError = true;
-        destroyRoot(root);
-        currentNodes = [];
-        return;
-      }
-      throw err;
-    } finally {
-      popRoot(prev);
-      if (!handledError) {
-        flushOnMount(root);
-        currentRoot2 = root;
-      } else {
-        currentRoot2 = null;
-      }
-    }
-  });
-  const portalDispose = () => {
-    dispose();
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
+function applyRef(el, value) {
+  if (typeof value === "function") {
+    const refFn = value;
+    refFn(el);
+    const root = getCurrentRoot();
+    if (root) {
+      registerRootCleanup(() => {
+        refFn(null);
+      });
+    } else if (isDev7) {
+      console.warn(
+        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
+      );
     }
-    if (currentNodes.length > 0) {
-      removeNodes(currentNodes);
+  } else if (value && typeof value === "object" && "current" in value) {
+    const refObj = value;
+    refObj.current = el;
+    const root = getCurrentRoot();
+    if (root) {
+      registerRootCleanup(() => {
+        refObj.current = null;
+      });
+    } else if (isDev7) {
+      console.warn(
+        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
+      );
     }
-    marker.parentNode?.removeChild(marker);
-  };
-  if (parentRoot) {
-    parentRoot.destroyCallbacks.push(portalDispose);
   }
-  return {
-    marker,
-    dispose: portalDispose
-  };
 }
-function mountBlock(initialValue, initialIndex, renderItem, parent, anchor, createElementFn, hostRoot) {
-  const start = document.createComment("fict:block:start");
-  const end = document.createComment("fict:block:end");
-  const valueSig = createVersionedSignalAccessor(initialValue);
-  const indexSig = signal(initialIndex);
-  const renderCurrent = () => renderItem(valueSig, indexSig);
-  const root = createRootContext(hostRoot);
-  const prev = pushRoot(root);
-  const nodes = [start];
-  let handledError = false;
-  try {
-    const output = renderCurrent();
-    if (output != null && output !== false) {
-      const el = createElementFn(output);
-      const rendered = toNodeArray(el);
-      nodes.push(...rendered);
+function applyProps(el, props, isSVG = false) {
+  props = unwrapProps(props);
+  const tagName = el.tagName;
+  const isCE = tagName.includes("-") || "is" in props;
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children") continue;
+    if (key === "ref") {
+      applyRef(el, value);
+      continue;
     }
-    nodes.push(end);
-    insertNodesBefore(parent, nodes, anchor);
-  } catch (err) {
-    if (handleSuspend(err, root)) {
-      handledError = true;
-      nodes.push(end);
-      insertNodesBefore(parent, nodes, anchor);
-    } else if (handleError(err, { source: "renderChild" }, root)) {
-      handledError = true;
-      nodes.push(end);
-      insertNodesBefore(parent, nodes, anchor);
-    } else {
-      throw err;
+    if (isEventKey(key)) {
+      bindEvent(
+        el,
+        eventNameFromProp(key),
+        value
+      );
+      continue;
     }
-  } finally {
-    popRoot(prev);
-    if (!handledError) {
-      flushOnMount(root);
-    } else {
-      destroyRoot(root);
+    if (key.slice(0, 3) === "on:") {
+      bindEvent(
+        el,
+        key.slice(3),
+        value,
+        false
+        // Non-delegated
+      );
+      continue;
     }
-  }
-  return {
-    nodes,
-    root,
-    value: valueSig,
-    index: indexSig,
-    start,
-    end,
-    renderCurrent
-  };
-}
-function rerenderBlock(block, createElementFn) {
-  const currentContent = block.nodes.slice(1, Math.max(1, block.nodes.length - 1));
-  const currentNode = currentContent.length === 1 ? currentContent[0] : null;
-  clearRoot(block.root);
-  const prev = pushRoot(block.root);
-  let nextOutput;
-  let handledError = false;
-  try {
-    nextOutput = block.renderCurrent();
-  } catch (err) {
-    if (handleSuspend(err, block.root)) {
-      handledError = true;
-      popRoot(prev);
-      destroyRoot(block.root);
-      block.nodes = [block.start, block.end];
-      return block;
+    if (key.slice(0, 10) === "oncapture:") {
+      bindEvent(
+        el,
+        key.slice(10),
+        value,
+        true
+        // Capture
+      );
+      continue;
     }
-    if (handleError(err, { source: "renderChild" }, block.root)) {
-      handledError = true;
-      popRoot(prev);
-      destroyRoot(block.root);
-      block.nodes = [block.start, block.end];
-      return block;
+    if (key === "class" || key === "className") {
+      createClassBinding(el, value);
+      continue;
     }
-    throw err;
-  } finally {
-    if (!handledError) {
-      popRoot(prev);
+    if (key === "classList") {
+      createClassBinding(el, value);
+      continue;
     }
-  }
-  if (isFragmentVNode(nextOutput) && currentContent.length > 0) {
-    const patched = patchFragmentChildren(currentContent, nextOutput.props?.children);
-    if (patched) {
-      block.nodes = [block.start, ...currentContent, block.end];
-      return block;
+    if (key === "style") {
+      createStyleBinding(
+        el,
+        value
+      );
+      continue;
     }
-  }
-  if (currentNode && patchNode(currentNode, nextOutput)) {
-    block.nodes = [block.start, currentNode, block.end];
-    return block;
-  }
-  clearContent(block);
-  if (nextOutput != null && nextOutput !== false) {
-    const newNodes = toNodeArray(
-      nextOutput instanceof Node ? nextOutput : createElementFn(nextOutput)
-    );
-    insertNodesBefore(block.start.parentNode, newNodes, block.end);
-    block.nodes = [block.start, ...newNodes, block.end];
-  } else {
-    block.nodes = [block.start, block.end];
-  }
-  return block;
-}
-function patchElement(el, output) {
-  if (output === null || output === void 0 || output === false || typeof output === "string" || typeof output === "number") {
-    el.textContent = output === null || output === void 0 || output === false ? "" : String(output);
-    return true;
-  }
-  if (output instanceof Text) {
-    el.textContent = output.data;
-    return true;
-  }
-  if (output && typeof output === "object" && !(output instanceof Node)) {
-    const vnode = output;
-    if (typeof vnode.type === "string" && vnode.type.toLowerCase() === el.tagName.toLowerCase()) {
-      const children = vnode.props?.children;
-      const props = vnode.props ?? {};
-      for (const [key, value] of Object.entries(props)) {
-        if (key === "children" || key === "key") continue;
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
-          if (key === "class" || key === "className") {
-            el.setAttribute("class", value === false || value === null ? "" : String(value));
-          } else if (key === "style" && typeof value === "string") {
-            ;
-            el.style.cssText = value;
-          } else if (value === false || value === null || value === void 0) {
-            el.removeAttribute(key);
-          } else if (value === true) {
-            el.setAttribute(key, "");
-          } else {
-            el.setAttribute(key, String(value));
-          }
+    if (key === "dangerouslySetInnerHTML" && value && typeof value === "object") {
+      const htmlValue = value.__html;
+      if (htmlValue !== void 0) {
+        if (isReactive(htmlValue)) {
+          createAttributeBinding(el, "innerHTML", htmlValue, setInnerHTML);
+        } else {
+          el.innerHTML = htmlValue;
         }
       }
-      if (typeof children === "string" || typeof children === "number" || children === null || children === void 0 || children === false) {
-        el.textContent = children === null || children === void 0 || children === false ? "" : String(children);
-        return true;
-      }
-      if (children && typeof children === "object" && !Array.isArray(children) && !(children instanceof Node)) {
-        const childVNode = children;
-        if (typeof childVNode.type === "string") {
-          const childEl = el.querySelector(childVNode.type);
-          if (childEl && patchElement(childEl, children)) {
-            return true;
-          }
-        }
+      continue;
+    }
+    if (isDev7 && ChildProperties.has(key) || key === "innerHTML" || key === "textContent" || key === "innerText" || key === "children") {
+      createAttributeBinding(el, key, value, setProperty);
+      continue;
+    }
+    if (key.slice(0, 5) === "attr:") {
+      createAttributeBinding(el, key.slice(5), value, setAttribute);
+      continue;
+    }
+    if (key.slice(0, 5) === "bool:") {
+      createAttributeBinding(el, key.slice(5), value, setBoolAttribute);
+      continue;
+    }
+    if (key.slice(0, 5) === "prop:") {
+      createAttributeBinding(el, key.slice(5), value, setProperty);
+      continue;
+    }
+    const propAlias = !isSVG && isDev7 ? getPropAlias(key, tagName) : void 0;
+    const isProperty = !isSVG ? isDev7 ? Properties.has(key) : key in el : false;
+    if (propAlias || isProperty || isCE && !isSVG) {
+      const propName = propAlias || key;
+      if (isCE && !isProperty && !propAlias) {
+        createAttributeBinding(
+          el,
+          toPropertyName(propName),
+          value,
+          setProperty
+        );
+      } else {
+        createAttributeBinding(el, propName, value, setProperty);
       }
-      return false;
+      continue;
     }
-  }
-  if (output instanceof Node) {
-    if (output.nodeType === Node.ELEMENT_NODE) {
-      const nextEl = output;
-      if (nextEl.tagName.toLowerCase() === el.tagName.toLowerCase()) {
-        el.textContent = nextEl.textContent;
-        return true;
+    if (isSVG && key.indexOf(":") > -1) {
+      const [prefix, name] = key.split(":");
+      const ns = SVGNamespace[prefix];
+      if (ns) {
+        createAttributeBinding(
+          el,
+          key,
+          value,
+          (el2, _key, val) => setAttributeNS(el2, ns, name, val)
+        );
+        continue;
       }
-    } else if (output.nodeType === Node.TEXT_NODE) {
-      el.textContent = output.data;
-      return true;
     }
+    const attrName = key === "htmlFor" ? "for" : key;
+    createAttributeBinding(el, attrName, value, setAttribute);
   }
-  return false;
-}
-function patchNode(currentNode, nextOutput) {
-  if (!currentNode) return false;
-  if (currentNode instanceof Text && (nextOutput === null || nextOutput === void 0 || nextOutput === false || typeof nextOutput === "string" || typeof nextOutput === "number" || nextOutput instanceof Text)) {
-    const nextText = nextOutput instanceof Text ? nextOutput.data : nextOutput === null || nextOutput === void 0 || nextOutput === false ? "" : String(nextOutput);
-    currentNode.data = nextText;
-    return true;
-  }
-  if (currentNode instanceof Element && patchElement(currentNode, nextOutput)) {
-    return true;
-  }
-  if (nextOutput instanceof Node && currentNode === nextOutput) {
-    return true;
-  }
-  return false;
 }
-function isFragmentVNode(value) {
-  return value != null && typeof value === "object" && !(value instanceof Node) && value.type === Fragment;
+function toPropertyName(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
 }
-function normalizeChildren(children, result = []) {
-  if (children === void 0) {
-    return result;
+var setAttribute = (el, key, value) => {
+  if (value === void 0 || value === null || value === false) {
+    el.removeAttribute(key);
+    return;
   }
-  if (Array.isArray(children)) {
-    for (const child of children) {
-      normalizeChildren(child, result);
-    }
-    return result;
+  if (value === true) {
+    el.setAttribute(key, "");
+    return;
   }
-  if (children === null || children === false) {
-    return result;
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number") {
+    el.setAttribute(key, String(value));
+    return;
   }
-  result.push(children);
-  return result;
-}
-function patchFragmentChildren(nodes, children) {
-  const normalized = normalizeChildren(children);
-  if (normalized.length !== nodes.length) {
-    return false;
+  if (key in el) {
+    ;
+    el[key] = value;
+    return;
   }
-  for (let i = 0; i < normalized.length; i++) {
-    if (!patchNode(nodes[i], normalized[i])) {
-      return false;
+  el.setAttribute(key, String(value));
+};
+var setProperty = (el, key, value) => {
+  if (value === void 0 || value === null) {
+    const fallback = key === "checked" || key === "selected" ? false : "";
+    el[key] = fallback;
+    return;
+  }
+  if (key === "style" && typeof value === "object" && value !== null) {
+    for (const k in value) {
+      const v = value[k];
+      if (v !== void 0) {
+        ;
+        el.style[k] = String(v);
+      }
     }
+    return;
   }
-  return true;
-}
-function clearContent(block) {
-  const nodes = block.nodes.slice(1, Math.max(1, block.nodes.length - 1));
-  removeNodes(nodes);
-}
-function removeBlockNodes(block) {
-  let cursor = block.start;
-  const end = block.end;
-  while (cursor) {
-    const next = cursor.nextSibling;
-    cursor.parentNode?.removeChild(cursor);
-    if (cursor === end) break;
-    cursor = next;
+  ;
+  el[key] = value;
+};
+var setInnerHTML = (el, _key, value) => {
+  ;
+  el.innerHTML = value == null ? "" : String(value);
+};
+var setBoolAttribute = (el, key, value) => {
+  if (value) {
+    el.setAttribute(key, "");
+  } else {
+    el.removeAttribute(key);
+  }
+};
+function setAttributeNS(el, namespace, name, value) {
+  if (value == null) {
+    el.removeAttributeNS(namespace, name);
+  } else {
+    el.setAttributeNS(namespace, name, String(value));
   }
 }
-
-// src/scope.ts
-function createScope() {
-  let dispose = null;
-  const stop = () => {
-    if (dispose) {
-      dispose();
-      dispose = null;
-    }
-  };
-  const run = (fn) => {
-    stop();
-    const { dispose: rootDispose, value } = createRoot(fn);
-    dispose = rootDispose;
-    return value;
-  };
-  registerRootCleanup(stop);
-  return { run, stop };
-}
-function runInScope(flag, fn) {
-  const scope = createScope();
-  const evaluate = () => isReactive(flag) ? flag() : !!flag;
-  createEffect(() => {
-    const enabled = evaluate();
-    if (enabled) {
-      scope.run(fn);
-    } else {
-      scope.stop();
-    }
-  });
-  onCleanup(scope.stop);
-}
-
-// src/versioned-signal.ts
-function createVersionedSignal(initialValue, options2) {
-  const equals = options2?.equals ?? Object.is;
-  const value = signal(initialValue);
-  const version = signal(0);
-  const bumpVersion = () => {
-    const next = version() + 1;
-    version(next);
-  };
-  return {
-    read: () => {
-      version();
-      return value();
-    },
-    write: (next) => {
-      const prev = value();
-      if (!equals(prev, next)) {
-        value(next);
-        return;
-      }
-      bumpVersion();
-    },
-    force: () => {
-      bumpVersion();
-    },
-    peekVersion: () => version(),
-    peekValue: () => value()
-  };
+function isEventKey(key) {
+  return key.startsWith("on") && key.length > 2 && key[2].toUpperCase() === key[2];
 }
-
-// src/ref.ts
-function createRef() {
-  return { current: null };
+function eventNameFromProp(key) {
+  return key.slice(2).toLowerCase();
 }
 
 // src/error-boundary.ts
@@ -4566,100 +2779,119 @@ function Suspense(props) {
   }
   return fragment;
 }
+
+// src/context.ts
+var contextStorage = /* @__PURE__ */ new WeakMap();
+function getContextMap(root) {
+  let map = contextStorage.get(root);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    contextStorage.set(root, map);
+  }
+  return map;
+}
+function createContext(defaultValue) {
+  const id = Symbol("fict.context");
+  const context = {
+    id,
+    defaultValue,
+    Provider: null
+  };
+  context.Provider = function Provider(props) {
+    const hostRoot = getCurrentRoot();
+    const providerRoot = createRootContext(hostRoot);
+    const contextMap = getContextMap(providerRoot);
+    contextMap.set(id, props.value);
+    const fragment = document.createDocumentFragment();
+    const marker = document.createComment("fict:ctx");
+    fragment.appendChild(marker);
+    let cleanup;
+    let activeNodes = [];
+    const renderChildren = (children) => {
+      if (cleanup) {
+        cleanup();
+        cleanup = void 0;
+      }
+      if (activeNodes.length) {
+        removeNodes(activeNodes);
+        activeNodes = [];
+      }
+      if (children == null || children === false) {
+        return;
+      }
+      const prev = pushRoot(providerRoot);
+      let nodes = [];
+      try {
+        const output = createElement(children);
+        nodes = toNodeArray(output);
+        const parentNode = marker.parentNode;
+        if (parentNode) {
+          insertNodesBefore(parentNode, nodes, marker);
+        }
+      } finally {
+        popRoot(prev);
+        flushOnMount(providerRoot);
+      }
+      cleanup = () => {
+        destroyRoot(providerRoot);
+        removeNodes(nodes);
+      };
+      activeNodes = nodes;
+    };
+    createRenderEffect(() => {
+      contextMap.set(id, props.value);
+      renderChildren(props.children);
+    });
+    return fragment;
+  };
+  return context;
+}
+function useContext(context) {
+  let root = getCurrentRoot();
+  while (root) {
+    const contextMap = contextStorage.get(root);
+    if (contextMap && contextMap.has(context.id)) {
+      return contextMap.get(context.id);
+    }
+    root = root.parent;
+  }
+  return context.defaultValue;
+}
+function hasContext(context) {
+  let root = getCurrentRoot();
+  while (root) {
+    const contextMap = contextStorage.get(root);
+    if (contextMap && contextMap.has(context.id)) {
+      return true;
+    }
+    root = root.parent;
+  }
+  return false;
+}
 export {
-  $effect,
-  $memo,
-  $state,
-  Aliases,
-  BooleanAttributes,
-  ChildProperties,
-  DelegatedEvents,
   ErrorBoundary,
   Fragment,
-  Properties,
-  SVGElements,
-  SVGNamespace,
   Suspense,
-  UnitlessStyles,
-  __fictPopContext,
-  __fictProp,
-  __fictPropsRest,
-  __fictPushContext,
-  __fictRender,
-  __fictResetContext,
-  __fictUseContext,
-  __fictUseEffect,
-  __fictUseMemo,
-  __fictUseSignal,
-  addEventListener,
-  assign,
   batch2 as batch,
-  bindAttribute,
-  bindClass,
-  bindEvent,
-  bindProperty,
-  bindRef,
-  bindStyle,
-  bindText,
-  callEventHandler,
-  classList,
-  clearDelegatedEvents,
-  createAttributeBinding,
-  createChildBinding,
-  createClassBinding,
-  createConditional,
+  createContext,
   createEffect,
   createElement,
-  createKeyedBlock,
-  createKeyedList,
-  createKeyedListContainer,
-  createList,
   createMemo,
   createPortal,
-  createPropsProxy,
   createRef,
-  createRenderEffect,
   createRoot,
-  createScope,
-  createSelector,
-  createShow,
-  signal as createSignal,
-  createStore,
-  createStyleBinding,
   createSuspenseToken,
-  createTextBinding,
-  createVersionedSignal,
-  delegateEvents,
-  destroyMarkerBlock,
-  effectScope,
-  getDevtoolsHook,
-  getFirstNodeAfter,
-  getPropAlias,
-  insert,
-  insertNodesBefore,
-  isNodeBetweenMarkers,
-  isReactive,
+  hasContext,
   mergeProps,
-  moveMarkerBlock,
-  moveNodesBefore,
   onCleanup,
   onDestroy,
   onMount,
-  __fictProp as prop,
-  reconcileArrays,
-  removeNodes,
+  prop,
   render,
-  runInScope,
-  setCycleProtectionOptions,
-  spread,
   startTransition,
-  template,
-  toNodeArray,
   untrack2 as untrack,
-  unwrap2 as unwrap,
-  unwrapPrimitive,
+  useContext,
   useDeferredValue,
-  useProp,
   useTransition
 };
 //# sourceMappingURL=index.dev.js.map