@fictjs/runtime 0.0.13 → 0.0.14

package/dist/index.dev.js

@@ -573,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--) {
@@ -851,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,
@@ -905,23 +880,6 @@ 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 result;
@@ -966,7 +924,6 @@ function setTransitionContext(value) {
   isInTransition = value;
   return prev;
 }
-var $state = signal;
 var registerSignalDevtools = () => void 0;
 var updateSignalDevtools = () => {
 };
@@ -1005,163 +962,11 @@ if (isDev3) {
     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();
-  };
-}
-
-// 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;
-    }
-  };
-  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) {
@@ -1196,7 +1001,6 @@ function createEffect(fn) {
   registerRootCleanup(teardown);
   return teardown;
 }
-var $effect = createEffect;
 function createRenderEffect(fn) {
   let cleanup;
   const rootForError = getCurrentRoot();
@@ -1232,6 +1036,86 @@ 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 isDev4 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
 var booleans = isDev4 ? [
@@ -1320,10 +1204,6 @@ var ChildProperties = /* @__PURE__ */ new Set([
   "innerText",
   "children"
 ]);
-var Aliases = {
-  className: "class",
-  htmlFor: "for"
-};
 var PropAliases = isDev4 ? {
   // Direct mapping
   class: "className",
@@ -1412,39 +1292,16 @@ var PropAliases = isDev4 ? {
     IMG: 1
   }
 } : {};
-function getPropAlias(prop, tagName) {
+function getPropAlias(prop2, tagName) {
   if (!isDev4) return void 0;
-  const a = PropAliases[prop];
+  const a = PropAliases[prop2];
   if (typeof a === "object") {
     return a[tagName] ? a["$"] : void 0;
   }
   return a;
 }
 var $$EVENTS = "_$FICT_DELEGATE";
-var delegatedEvents = isDev4 ? [
-  "beforeinput",
-  "click",
-  "dblclick",
-  "contextmenu",
-  "focusin",
-  "focusout",
-  "input",
-  "keydown",
-  "keyup",
-  "mousedown",
-  "mousemove",
-  "mouseout",
-  "mouseover",
-  "mouseup",
-  "pointerdown",
-  "pointermove",
-  "pointerout",
-  "pointerover",
-  "pointerup",
-  "touchend",
-  "touchmove",
-  "touchstart"
-] : [];
+var delegatedEvents = isDev4 ? DelegatedEventNames : [];
 var DelegatedEvents = new Set(delegatedEvents);
 var svgElements = isDev4 ? [
   "altGlyph",
@@ -1609,9 +1466,6 @@ var unitlessList = isDev4 ? [
 ] : ["opacity", "zIndex"];
 var UnitlessStyles = new Set(unitlessList);
 
-// src/jsx.ts
-var Fragment = Symbol("Fragment");
-
 // src/node-ops.ts
 function toNodeArray(node) {
   try {
@@ -1755,60 +1609,11 @@ function removeNodes(nodes) {
   }
 }
 
-// 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/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;
@@ -1833,35 +1638,6 @@ function callEventHandler(handler, event, node, data) {
   };
   invoke(handler);
 }
-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(() => {
@@ -1871,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)) {
@@ -1923,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;
@@ -1949,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);
       }
     }
@@ -1972,7 +1700,7 @@ function applyStyle(el, value, prev) {
     }
   }
 }
-var isUnitlessStyleProperty = isDev5 ? (prop) => UnitlessStyles.has(prop) : (prop) => prop === "opacity" || prop === "zIndex";
+var isUnitlessStyleProperty = isDev5 ? (prop2) => UnitlessStyles.has(prop2) : (prop2) => prop2 === "opacity" || prop2 === "zIndex";
 function createClassBinding(el, value) {
   if (isReactive(value)) {
     let prev = {};
@@ -1984,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++) {
@@ -2041,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);
@@ -2215,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) => {
@@ -2313,24 +1903,6 @@ function globalEventHandler(e) {
   }
   retarget(oriTarget);
 }
-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);
-  }
-}
 function bindEvent(el, eventName, handler, options) {
   if (handler == null) return () => {
   };
@@ -2358,290 +1930,17 @@ function bindEvent(el, eventName, handler, options) {
     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 bindRef(el, ref) {
-  if (ref == null) return () => {
-  };
-  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 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;
-      }
-    };
-    registerRootCleanup(nullifyCleanup);
-    return () => {
-      cleanup2();
-      nullifyCleanup();
-    };
-  }
-  const cleanup = () => {
-    const refValue = getRef();
-    if (refValue && typeof refValue === "object" && "current" in refValue) {
-      ;
-      refValue.current = null;
-    }
-  };
-  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);
-    }
-  });
-  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);
-    }
-  }
-  for (const prop in props) {
-    if (prop === "children") {
-      if (!skipChildren) {
-        prevProps.children = props.children;
-      }
-      continue;
-    }
-    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 (value === prev) return prev;
-  if (prop === "ref") {
-    if (!skipRef && typeof value === "function") {
-      ;
-      value(node);
-    }
-    return value;
-  }
-  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 (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 (prop.slice(0, 2) === "on") {
-    const eventName = prop.slice(2).toLowerCase();
-    const shouldDelegate = isDev5 && 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]);
-    }
-    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;
-  }
-  if (prop === "class" || prop === "className") {
-    if (value == null) node.removeAttribute("class");
-    else node.className = String(value);
-    return value;
-  }
-  const isCE = node.nodeName.includes("-") || "is" in props;
-  if (!isSVG) {
-    const propAlias = isDev5 ? getPropAlias(prop, node.tagName) : void 0;
-    const isProperty = isDev5 ? Properties.has(prop) : prop in node;
-    const isChildProp = isDev5 ? ChildProperties.has(prop) : prop === "innerHTML" || prop === "textContent" || prop === "innerText" || prop === "children";
-    if (propAlias || isProperty || isChildProp || isCE) {
-      const propName = propAlias || prop;
-      if (isCE && !isProperty && !isChildProp && !propAlias) {
-        ;
-        node[toPropertyName(propName)] = value;
-      } else {
-        ;
-        node[propName] = value;
-      }
-      return value;
-    }
-  }
-  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;
-    }
-  }
-  const attrName = prop === "htmlFor" ? "for" : prop;
-  if (value == null) node.removeAttribute(attrName);
-  else node.setAttribute(attrName, String(value));
-  return value;
-}
-function toPropertyName(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) {
-      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);
+    } catch (err) {
+      if (handleError(err, { source: "event", eventName }, rootRef)) {
         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);
     }
   };
-}
-function createShow(el, condition, displayValue) {
-  const originalDisplay = displayValue ?? el.style.display;
-  createRenderEffect(() => {
-    el.style.display = condition() ? originalDisplay : "none";
-  });
+  el.addEventListener(eventName, wrapped, options);
+  const cleanup = () => el.removeEventListener(eventName, wrapped, options);
+  registerRootCleanup(cleanup);
+  return cleanup;
 }
 function createPortal(container, render2, createElementFn) {
   const parentRoot = getCurrentRoot();
@@ -2714,58 +2013,9 @@ function createPortal(container, render2, createElementFn) {
   };
 }
 
-// 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/hooks.ts
 var isDev6 = true ? true : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
 var ctxStack = [];
-function assertRenderContext(ctx, hookName) {
-  if (!ctx.rendering) {
-    const message = isDev6 ? `${hookName} can only be used during render execution` : "FICT:E_HOOK_RENDER";
-    throw new Error(message);
-  }
-}
-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);
@@ -2774,73 +2024,6 @@ function __fictPushContext() {
 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/versioned-signal.ts
-function createVersionedSignal(initialValue, options) {
-  const equals = options?.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()
-  };
-}
 
 // src/props.ts
 var propGetters = /* @__PURE__ */ new WeakSet();
@@ -2867,24 +2050,24 @@ function createPropsProxy(props) {
     return cached;
   }
   const proxy = new Proxy(props, {
-    get(target, prop, receiver) {
-      const value = Reflect.get(target, prop, receiver);
+    get(target, prop2, receiver) {
+      const value = Reflect.get(target, prop2, receiver);
       if (isPropGetter(value)) {
         return value();
       }
       return value;
     },
-    set(target, prop, value, receiver) {
-      return Reflect.set(target, prop, value, receiver);
+    set(target, prop2, value, receiver) {
+      return Reflect.set(target, prop2, value, receiver);
     },
-    has(target, prop) {
-      return prop in target;
+    has(target, prop2) {
+      return prop2 in target;
     },
     ownKeys(target) {
       return Reflect.ownKeys(target);
     },
-    getOwnPropertyDescriptor(target, prop) {
-      return Object.getOwnPropertyDescriptor(target, prop);
+    getOwnPropertyDescriptor(target, prop2) {
+      return Object.getOwnPropertyDescriptor(target, prop2);
     }
   });
   rawToProxy.set(props, proxy);
@@ -2897,16 +2080,6 @@ function unwrapProps(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")
@@ -2922,32 +2095,38 @@ function mergeProps(...sources) {
     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;
+  const hasProp = (prop2) => {
+    for (const src of validSources) {
+      const raw = resolveSource(src);
+      if (raw && prop2 in raw) {
+        return true;
       }
-      return void 0;
-    },
-    has(_, prop) {
-      for (const src of validSources) {
-        const raw = resolveSource(src);
-        if (raw && prop in raw) {
-          return true;
-        }
+    }
+    return false;
+  };
+  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];
+        });
       }
-      return false;
+      return value;
+    }
+    return void 0;
+  };
+  return new Proxy({}, {
+    get(_, prop2) {
+      return readProp(prop2);
+    },
+    has(_, prop2) {
+      return hasProp(prop2);
     },
     ownKeys() {
       const keys = /* @__PURE__ */ new Set();
@@ -2961,33 +2140,23 @@ function mergeProps(...sources) {
       }
       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;
+    getOwnPropertyDescriptor(_, prop2) {
+      if (!hasProp(prop2)) return void 0;
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => readProp(prop2)
+      };
     }
   });
 }
-function useProp(getter) {
+function prop(getter) {
+  if (isPropGetter(getter)) {
+    return getter;
+  }
   return __fictProp(createMemo(getter));
 }
 
-// src/ref.ts
-function createRef() {
-  return { current: null };
-}
-
 // src/dom.ts
 var SVG_NS = "http://www.w3.org/2000/svg";
 var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
@@ -3063,24 +2232,24 @@ function createElementWithContext(node, namespace) {
   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);
+      get(target, prop2, receiver) {
+        if (prop2 === "key") return vnode.key;
+        return Reflect.get(target, prop2, receiver);
       },
-      has(target, prop) {
-        if (prop === "key") return true;
-        return prop in target;
+      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, prop) {
-        if (prop === "key") {
+      getOwnPropertyDescriptor(target, prop2) {
+        if (prop2 === "key") {
           return { enumerable: true, configurable: true, value: vnode.key };
         }
-        return Object.getOwnPropertyDescriptor(target, prop);
+        return Object.getOwnPropertyDescriptor(target, prop2);
       }
     });
     const props = createPropsProxy(baseProps);
@@ -3115,23 +2284,6 @@ function createElementWithContext(node, namespace) {
   );
   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";
 }
@@ -3308,7 +2460,7 @@ function applyProps(el, props, isSVG = false) {
       if (isCE && !isProperty && !propAlias) {
         createAttributeBinding(
           el,
-          toPropertyName2(propName),
+          toPropertyName(propName),
           value,
           setProperty
         );
@@ -3334,7 +2486,7 @@ function applyProps(el, props, isSVG = false) {
     createAttributeBinding(el, attrName, value, setAttribute);
   }
 }
-function toPropertyName2(name) {
+function toPropertyName(name) {
   return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
 }
 var setAttribute = (el, key, value) => {
@@ -3628,728 +2780,118 @@ function Suspense(props) {
   return fragment;
 }
 
-// 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 isDev8 = 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)) {
-      const message = isDev8 ? "Invalid node in moveNodesBefore" : "FICT:E_NODE";
-      throw new Error(message);
-    }
-    if (node.nextSibling !== anchor) {
-      if (node.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
-        parent.ownerDocument.adoptNode(node);
+// 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 {
-        parent.insertBefore(node, anchor);
-      } catch (e) {
-        if (parent.ownerDocument) {
-          try {
-            const clone = parent.ownerDocument.importNode(node, true);
-            parent.insertBefore(clone, anchor);
-            continue;
-          } catch {
-          }
+        const output = createElement(children);
+        nodes = toNodeArray(output);
+        const parentNode = marker.parentNode;
+        if (parentNode) {
+          insertNodesBefore(parentNode, nodes, marker);
         }
-        throw e;
-      }
-    }
-    anchor = node;
-  }
-}
-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);
+      } finally {
+        popRoot(prev);
+        flushOnMount(providerRoot);
       }
+      cleanup = () => {
+        destroyRoot(providerRoot);
+        removeNodes(nodes);
+      };
+      activeNodes = nodes;
+    };
+    createRenderEffect(() => {
+      contextMap.set(id, props.value);
+      renderChildren(props.children);
     });
-    if (scopeDispose) {
-      root.cleanups.push(scopeDispose);
-    }
-  } finally {
-    setActiveSub(prevSub);
-    popRoot(prevRoot);
-  }
-  return {
-    key,
-    nodes,
-    root,
-    item: itemSig,
-    index: indexSig,
-    rawItem: item,
-    rawIndex: index
+    return fragment;
   };
+  return context;
 }
-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;
+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;
   }
-  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;
+  return context.defaultValue;
 }
-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;
+function hasContext(context) {
+  let root = getCurrentRoot();
+  while (root) {
+    const contextMap = contextStorage.get(root);
+    if (contextMap && contextMap.has(context.id)) {
+      return true;
     }
-    moveNodesBefore(parent, nodes, anchor);
-    anchor = nodes[0];
-    moved = true;
+    root = root.parent;
   }
-  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 (isDev8) {
-              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;
-        }
-      }
-      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]);
-          }
-        }
-        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);
-        }
-      }
-    });
-  };
-  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();
-        }
-      }
-    });
-    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);
-    }
-  };
-  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();
-      }
-    },
-    dispose: () => {
-      disposed = true;
-      effectDispose?.();
-      disconnectObserver();
-      container.dispose();
-    }
-  };
+  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,
-  createKeyedList,
   createMemo,
   createPortal,
-  createPropsProxy,
   createRef,
-  createRenderEffect,
   createRoot,
-  createScope,
-  createSelector,
-  createShow,
-  signal as createSignal,
-  createStore,
-  createStyleBinding,
   createSuspenseToken,
-  createTextBinding,
-  createVersionedSignal,
-  delegateEvents,
-  effectScope,
-  getDevtoolsHook,
-  getPropAlias,
-  insert,
-  insertNodesBefore,
-  isNodeBetweenMarkers,
-  isReactive,
+  hasContext,
   mergeProps,
-  moveNodesBefore,
   onCleanup,
   onDestroy,
   onMount,
-  __fictProp as prop,
-  reconcileArrays,
-  removeNodes,
+  prop,
   render,
-  runInScope,
-  setCycleProtectionOptions,
-  spread,
   startTransition,
-  template,
-  toNodeArray,
   untrack2 as untrack,
-  unwrap2 as unwrap,
+  useContext,
   useDeferredValue,
-  useProp,
   useTransition
 };
 //# sourceMappingURL=index.dev.js.map