@fictjs/runtime 0.0.2

package/dist/index.dev.js

@@ -0,0 +1,4240 @@
+// src/devtools.ts
+function getGlobalHook() {
+  if (typeof globalThis === "undefined") return void 0;
+  return globalThis.__FICT_DEVTOOLS_HOOK__;
+}
+function getDevtoolsHook() {
+  return getGlobalHook();
+}
+
+// src/cycle-guard.ts
+var defaultOptions = {
+  maxFlushCyclesPerMicrotask: 1e4,
+  maxEffectRunsPerFlush: 2e4,
+  windowSize: 5,
+  highUsageRatio: 0.8,
+  maxRootReentrantDepth: 10,
+  enableWindowWarning: true,
+  devMode: false
+};
+var options = {
+  ...defaultOptions
+};
+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);
+    }
+    if (!flushWarned) {
+      flushWarned = true;
+      console.warn(message, { effectRuns: next });
+    }
+    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);
+    }
+    if (!rootWarned) {
+      rootWarned = true;
+      console.warn(message, { depth });
+    }
+    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 ?? "");
+}
+
+// src/lifecycle.ts
+var currentRoot;
+var currentEffectCleanups;
+var globalErrorHandlers = /* @__PURE__ */ new WeakMap();
+var globalSuspenseHandlers = /* @__PURE__ */ new WeakMap();
+function createRootContext(parent = currentRoot) {
+  return { parent, cleanups: [], destroyCallbacks: [] };
+}
+function pushRoot(root) {
+  if (!enterRootGuard(root)) {
+    return currentRoot;
+  }
+  const prev = currentRoot;
+  currentRoot = root;
+  return prev;
+}
+function getCurrentRoot() {
+  return currentRoot;
+}
+function popRoot(prev) {
+  if (currentRoot) {
+    exitRootGuard(currentRoot);
+  }
+  currentRoot = prev;
+}
+function onMount(fn) {
+  if (currentRoot) {
+    ;
+    (currentRoot.onMountCallbacks || (currentRoot.onMountCallbacks = [])).push(fn);
+    return;
+  }
+  runLifecycle(fn);
+}
+function onDestroy(fn) {
+  if (currentRoot) {
+    currentRoot.destroyCallbacks.push(() => runLifecycle(fn));
+    return;
+  }
+  runLifecycle(fn);
+}
+function onCleanup(fn) {
+  registerEffectCleanup(fn);
+}
+function flushOnMount(root) {
+  const cbs = root.onMountCallbacks;
+  if (!cbs || cbs.length === 0) return;
+  for (let i = 0; i < cbs.length; i++) {
+    const cleanup = cbs[i]();
+    if (typeof cleanup === "function") {
+      root.cleanups.push(cleanup);
+    }
+  }
+  cbs.length = 0;
+}
+function registerRootCleanup(fn) {
+  if (currentRoot) {
+    currentRoot.cleanups.push(fn);
+  }
+}
+function clearRoot(root) {
+  runCleanupList(root.cleanups);
+  if (root.onMountCallbacks) {
+    root.onMountCallbacks.length = 0;
+  }
+}
+function destroyRoot(root) {
+  clearRoot(root);
+  runCleanupList(root.destroyCallbacks);
+  if (root.errorHandlers) {
+    root.errorHandlers.length = 0;
+  }
+  if (globalErrorHandlers.has(root)) {
+    globalErrorHandlers.delete(root);
+  }
+  if (root.suspenseHandlers) {
+    root.suspenseHandlers.length = 0;
+  }
+  if (globalSuspenseHandlers.has(root)) {
+    globalSuspenseHandlers.delete(root);
+  }
+}
+function createRoot(fn) {
+  const root = createRootContext();
+  const prev = pushRoot(root);
+  let value;
+  try {
+    value = fn();
+  } finally {
+    popRoot(prev);
+  }
+  flushOnMount(root);
+  return {
+    dispose: () => destroyRoot(root),
+    value
+  };
+}
+function withEffectCleanups(bucket, fn) {
+  const prev = currentEffectCleanups;
+  currentEffectCleanups = bucket;
+  try {
+    return fn();
+  } finally {
+    currentEffectCleanups = prev;
+  }
+}
+function registerEffectCleanup(fn) {
+  if (currentEffectCleanups) {
+    currentEffectCleanups.push(fn);
+  } else {
+    registerRootCleanup(fn);
+  }
+}
+function runCleanupList(list) {
+  let error;
+  for (let i = list.length - 1; i >= 0; i--) {
+    try {
+      const cleanup = list[i];
+      if (cleanup) cleanup();
+    } catch (err) {
+      if (error === void 0) {
+        error = err;
+      }
+    }
+  }
+  list.length = 0;
+  if (error !== void 0) {
+    if (!handleError(error, { source: "cleanup" })) {
+      throw error;
+    }
+  }
+}
+function runLifecycle(fn) {
+  const cleanup = fn();
+  if (typeof cleanup === "function") {
+    cleanup();
+  }
+}
+function registerErrorHandler(fn) {
+  if (!currentRoot) {
+    throw new Error("registerErrorHandler must be called within a root");
+  }
+  if (!currentRoot.errorHandlers) {
+    currentRoot.errorHandlers = [];
+  }
+  currentRoot.errorHandlers.push(fn);
+  const existing = globalErrorHandlers.get(currentRoot);
+  if (existing) {
+    existing.push(fn);
+  } else {
+    globalErrorHandlers.set(currentRoot, [fn]);
+  }
+}
+function registerSuspenseHandler(fn) {
+  if (!currentRoot) {
+    throw new Error("registerSuspenseHandler must be called within a root");
+  }
+  if (!currentRoot.suspenseHandlers) {
+    currentRoot.suspenseHandlers = [];
+  }
+  currentRoot.suspenseHandlers.push(fn);
+  const existing = globalSuspenseHandlers.get(currentRoot);
+  if (existing) {
+    existing.push(fn);
+  } else {
+    globalSuspenseHandlers.set(currentRoot, [fn]);
+  }
+}
+function handleError(err, info, startRoot) {
+  let root = startRoot ?? currentRoot;
+  let error = err;
+  while (root) {
+    const handlers = root.errorHandlers;
+    if (handlers && handlers.length) {
+      for (let i = handlers.length - 1; i >= 0; i--) {
+        const handler = handlers[i];
+        try {
+          const handled = handler(error, info);
+          if (handled !== false) {
+            return true;
+          }
+        } catch (nextErr) {
+          error = nextErr;
+        }
+      }
+    }
+    root = root.parent;
+  }
+  const globalForRoot = startRoot ? globalErrorHandlers.get(startRoot) : currentRoot ? globalErrorHandlers.get(currentRoot) : void 0;
+  if (globalForRoot && globalForRoot.length) {
+    for (let i = globalForRoot.length - 1; i >= 0; i--) {
+      const handler = globalForRoot[i];
+      try {
+        const handled = handler(error, info);
+        if (handled !== false) {
+          return true;
+        }
+      } catch (nextErr) {
+        error = nextErr;
+      }
+    }
+  }
+  throw error;
+}
+function handleSuspend(token, startRoot) {
+  let root = startRoot ?? currentRoot;
+  while (root) {
+    const handlers = root.suspenseHandlers;
+    if (handlers && handlers.length) {
+      for (let i = handlers.length - 1; i >= 0; i--) {
+        const handler = handlers[i];
+        const handled = handler(token);
+        if (handled !== false) return true;
+      }
+    }
+    root = root.parent;
+  }
+  const globalForRoot = startRoot && globalSuspenseHandlers.get(startRoot) ? globalSuspenseHandlers.get(startRoot) : currentRoot ? globalSuspenseHandlers.get(currentRoot) : void 0;
+  if (globalForRoot && globalForRoot.length) {
+    for (let i = globalForRoot.length - 1; i >= 0; i--) {
+      const handler = globalForRoot[i];
+      const handled = handler(token);
+      if (handled !== false) return true;
+    }
+  }
+  return false;
+}
+
+// src/signal.ts
+var Mutable = 1;
+var Watching = 2;
+var Running = 4;
+var Recursed = 8;
+var Dirty = 16;
+var Pending = 32;
+var MutableDirty = 17;
+var MutablePending = 33;
+var MutableRunning = 5;
+var WatchingRunning = 6;
+var cycle = 0;
+var batchDepth = 0;
+var activeSub;
+var flushScheduled = false;
+var highPriorityQueue = [];
+var lowPriorityQueue = [];
+var isInTransition = false;
+var enqueueMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => {
+  Promise.resolve().then(fn);
+};
+function link(dep, sub, version) {
+  const prevDep = sub.depsTail;
+  if (prevDep !== void 0 && prevDep.dep === dep) return;
+  const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+  if (nextDep !== void 0 && nextDep.dep === dep) {
+    nextDep.version = version;
+    sub.depsTail = nextDep;
+    return;
+  }
+  const prevSub = dep.subsTail;
+  if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+  const newLink = { version, dep, sub, prevDep, nextDep, prevSub, nextSub: void 0 };
+  sub.depsTail = newLink;
+  dep.subsTail = newLink;
+  if (nextDep !== void 0) nextDep.prevDep = newLink;
+  if (prevDep !== void 0) prevDep.nextDep = newLink;
+  else sub.deps = newLink;
+  if (prevSub !== void 0) prevSub.nextSub = newLink;
+  else dep.subs = newLink;
+}
+function unlink(lnk, sub = lnk.sub) {
+  const dep = lnk.dep;
+  const prevDep = lnk.prevDep;
+  const nextDep = lnk.nextDep;
+  const nextSub = lnk.nextSub;
+  const prevSub = lnk.prevSub;
+  if (nextDep !== void 0) nextDep.prevDep = prevDep;
+  else sub.depsTail = prevDep;
+  if (prevDep !== void 0) prevDep.nextDep = nextDep;
+  else sub.deps = nextDep;
+  if (nextSub !== void 0) nextSub.prevSub = prevSub;
+  else dep.subsTail = prevSub;
+  if (prevSub !== void 0) prevSub.nextSub = nextSub;
+  else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+  return nextDep;
+}
+function unwatched(dep) {
+  if (!(dep.flags & Mutable)) {
+    disposeNode(dep);
+  } else if ("getter" in dep && dep.getter !== void 0) {
+    dep.depsTail = void 0;
+    dep.flags = MutableDirty;
+    purgeDeps(dep);
+  }
+}
+function propagate(firstLink) {
+  let link2 = firstLink;
+  let next = link2.nextSub;
+  let stack;
+  top: for (; ; ) {
+    const sub = link2.sub;
+    let flags = sub.flags;
+    if (!(flags & 60)) {
+      sub.flags = flags | Pending;
+    } else if (!(flags & 12)) {
+      flags = 0;
+    } else if (!(flags & Running)) {
+      sub.flags = flags & ~Recursed | Pending;
+    } else if (!(flags & 48)) {
+      let vlink = sub.depsTail;
+      let valid = false;
+      while (vlink !== void 0) {
+        if (vlink === link2) {
+          valid = true;
+          break;
+        }
+        vlink = vlink.prevDep;
+      }
+      if (valid) {
+        sub.flags = flags | 40;
+        flags &= Mutable;
+      } else {
+        flags = 0;
+      }
+    } else {
+      flags = 0;
+    }
+    if (flags & Watching) notify(sub);
+    if (flags & Mutable) {
+      const subSubs = sub.subs;
+      if (subSubs !== void 0) {
+        const nextSub = subSubs.nextSub;
+        if (nextSub !== void 0) {
+          stack = { value: next, prev: stack };
+          next = nextSub;
+        }
+        link2 = subSubs;
+        continue;
+      }
+    }
+    if (next !== void 0) {
+      link2 = next;
+      next = link2.nextSub;
+      continue;
+    }
+    while (stack !== void 0) {
+      link2 = stack.value;
+      stack = stack.prev;
+      if (link2 !== void 0) {
+        next = link2.nextSub;
+        continue top;
+      }
+    }
+    break;
+  }
+}
+function checkDirty(firstLink, sub) {
+  let link2 = firstLink;
+  let stack;
+  let checkDepth = 0;
+  let dirty = false;
+  top: for (; ; ) {
+    const dep = link2.dep;
+    const depFlags = dep.flags;
+    if (sub.flags & Dirty) {
+      dirty = true;
+    } else if ((depFlags & MutableDirty) === MutableDirty) {
+      if (update(dep)) {
+        const subs = dep.subs;
+        if (subs !== void 0 && subs.nextSub !== void 0) shallowPropagate(subs);
+        dirty = true;
+      }
+    } else if ((depFlags & MutablePending) === MutablePending) {
+      if (link2.nextSub !== void 0 || link2.prevSub !== void 0) {
+        stack = { value: link2, prev: stack };
+      }
+      link2 = dep.deps;
+      sub = dep;
+      ++checkDepth;
+      continue;
+    }
+    if (!dirty) {
+      const nextDep = link2.nextDep;
+      if (nextDep !== void 0) {
+        link2 = nextDep;
+        continue;
+      }
+    }
+    while (checkDepth-- > 0) {
+      const firstSub = sub.subs;
+      const hasMultipleSubs = firstSub.nextSub !== void 0;
+      if (hasMultipleSubs) {
+        link2 = stack.value;
+        stack = stack.prev;
+      } else {
+        link2 = firstSub;
+      }
+      if (dirty) {
+        if (update(sub)) {
+          if (hasMultipleSubs) shallowPropagate(firstSub);
+          sub = link2.sub;
+          continue;
+        }
+        dirty = false;
+      } else {
+        sub.flags &= ~Pending;
+      }
+      sub = link2.sub;
+      const nextDep = link2.nextDep;
+      if (nextDep !== void 0) {
+        link2 = nextDep;
+        continue top;
+      }
+    }
+    return dirty;
+  }
+}
+function shallowPropagate(firstLink) {
+  let link2 = firstLink;
+  do {
+    const sub = link2.sub;
+    const flags = sub.flags;
+    if ((flags & 48) === Pending) {
+      sub.flags = flags | Dirty;
+      if ((flags & 6) === Watching) notify(sub);
+    }
+    link2 = link2.nextSub;
+  } while (link2 !== void 0);
+}
+function update(node) {
+  return "getter" in node && node.getter !== void 0 ? updateComputed(node) : updateSignal(node);
+}
+function notify(effect2) {
+  effect2.flags &= ~Watching;
+  const effects = [];
+  for (; ; ) {
+    effects.push(effect2);
+    const nextLink = effect2.subs;
+    if (nextLink === void 0) break;
+    effect2 = nextLink.sub;
+    if (effect2 === void 0 || !(effect2.flags & Watching)) break;
+    effect2.flags &= ~Watching;
+  }
+  const targetQueue = isInTransition ? lowPriorityQueue : highPriorityQueue;
+  for (let i = effects.length - 1; i >= 0; i--) {
+    targetQueue.push(effects[i]);
+  }
+}
+function purgeDeps(sub) {
+  const depsTail = sub.depsTail;
+  let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+  while (dep !== void 0) dep = unlink(dep, sub);
+}
+function disposeNode(node) {
+  node.depsTail = void 0;
+  node.flags = 0;
+  purgeDeps(node);
+  const sub = node.subs;
+  if (sub !== void 0) unlink(sub, node);
+}
+function updateSignal(s) {
+  s.flags = Mutable;
+  const current = s.currentValue;
+  const pending = s.pendingValue;
+  if (current !== pending) {
+    s.currentValue = pending;
+    return true;
+  }
+  return false;
+}
+function updateComputed(c) {
+  ++cycle;
+  const oldValue = c.value;
+  c.depsTail = void 0;
+  c.flags = MutableRunning;
+  const prevSub = activeSub;
+  activeSub = c;
+  try {
+    const newValue = c.getter(oldValue);
+    activeSub = prevSub;
+    c.flags &= ~Running;
+    purgeDeps(c);
+    if (oldValue !== newValue) {
+      c.value = newValue;
+      return true;
+    }
+    return false;
+  } catch (e) {
+    activeSub = prevSub;
+    c.flags &= ~Running;
+    throw e;
+  }
+}
+function runEffect(e) {
+  const flags = e.flags;
+  if (flags & Dirty || flags & Pending && e.deps && checkDirty(e.deps, e)) {
+    ++cycle;
+    effectRunDevtools(e);
+    e.depsTail = void 0;
+    e.flags = WatchingRunning;
+    const prevSub = activeSub;
+    activeSub = e;
+    try {
+      e.fn();
+      activeSub = prevSub;
+      e.flags = Watching;
+      purgeDeps(e);
+    } catch (err) {
+      activeSub = prevSub;
+      e.flags = Watching;
+      throw err;
+    }
+  } else {
+    e.flags = Watching;
+  }
+}
+function scheduleFlush() {
+  const hasWork = highPriorityQueue.length > 0 || lowPriorityQueue.length > 0;
+  if (flushScheduled || !hasWork) return;
+  if (batchDepth > 0) return;
+  flushScheduled = true;
+  enqueueMicrotask(() => {
+    flush();
+  });
+}
+function flush() {
+  beginFlushGuard();
+  if (batchDepth > 0) {
+    scheduleFlush();
+    endFlushGuard();
+    return;
+  }
+  const hasWork = highPriorityQueue.length > 0 || lowPriorityQueue.length > 0;
+  if (!hasWork) {
+    flushScheduled = false;
+    endFlushGuard();
+    return;
+  }
+  flushScheduled = false;
+  let highIndex = 0;
+  while (highIndex < highPriorityQueue.length) {
+    const e = highPriorityQueue[highIndex];
+    if (!beforeEffectRunGuard()) {
+      if (highIndex > 0) {
+        highPriorityQueue.copyWithin(0, highIndex);
+        highPriorityQueue.length -= highIndex;
+      }
+      endFlushGuard();
+      return;
+    }
+    highIndex++;
+    runEffect(e);
+  }
+  highPriorityQueue.length = 0;
+  let lowIndex = 0;
+  while (lowIndex < lowPriorityQueue.length) {
+    if (highPriorityQueue.length > 0) {
+      if (lowIndex > 0) {
+        lowPriorityQueue.copyWithin(0, lowIndex);
+        lowPriorityQueue.length -= lowIndex;
+      }
+      scheduleFlush();
+      endFlushGuard();
+      return;
+    }
+    const e = lowPriorityQueue[lowIndex];
+    if (!beforeEffectRunGuard()) {
+      if (lowIndex > 0) {
+        lowPriorityQueue.copyWithin(0, lowIndex);
+        lowPriorityQueue.length -= lowIndex;
+      }
+      endFlushGuard();
+      return;
+    }
+    lowIndex++;
+    runEffect(e);
+  }
+  lowPriorityQueue.length = 0;
+  endFlushGuard();
+}
+function signal(initialValue) {
+  const s = {
+    currentValue: initialValue,
+    pendingValue: initialValue,
+    subs: void 0,
+    subsTail: void 0,
+    flags: Mutable,
+    __id: void 0
+  };
+  registerSignalDevtools(initialValue, s);
+  return signalOper.bind(s);
+}
+function signalOper(value) {
+  if (arguments.length > 0) {
+    if (this.pendingValue !== value) {
+      this.pendingValue = value;
+      this.flags = MutableDirty;
+      updateSignalDevtools(this, value);
+      const subs = this.subs;
+      if (subs !== void 0) {
+        propagate(subs);
+        if (!batchDepth) scheduleFlush();
+      }
+    }
+    return;
+  }
+  const flags = this.flags;
+  if (flags & Dirty) {
+    if (updateSignal(this)) {
+      const subs = this.subs;
+      if (subs !== void 0) shallowPropagate(subs);
+    }
+  }
+  let sub = activeSub;
+  while (sub !== void 0) {
+    if (sub.flags & 3) {
+      link(this, sub, cycle);
+      break;
+    }
+    const subSubs = sub.subs;
+    sub = subSubs !== void 0 ? subSubs.sub : void 0;
+  }
+  return this.currentValue;
+}
+function computed(getter) {
+  const c = {
+    value: void 0,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: 0,
+    getter
+  };
+  const bound = computedOper.bind(c);
+  return bound;
+}
+function computedOper() {
+  const flags = this.flags;
+  if (flags & Dirty) {
+    if (updateComputed(this)) {
+      const subs = this.subs;
+      if (subs !== void 0) shallowPropagate(subs);
+    }
+  } else if (flags & Pending) {
+    if (this.deps && checkDirty(this.deps, this)) {
+      if (updateComputed(this)) {
+        const subs = this.subs;
+        if (subs !== void 0) shallowPropagate(subs);
+      }
+    } else {
+      this.flags = flags & ~Pending;
+    }
+  } else if (!flags) {
+    this.flags = MutableRunning;
+    const prevSub = setActiveSub(this);
+    try {
+      this.value = this.getter(void 0);
+    } finally {
+      setActiveSub(prevSub);
+      this.flags &= ~Running;
+    }
+  }
+  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;
+  }
+  return effectOper.bind(e);
+}
+function effectOper() {
+  disposeNode(this);
+}
+function batch(fn) {
+  ++batchDepth;
+  try {
+    return fn();
+  } finally {
+    if (--batchDepth === 0) flush();
+  }
+}
+function setActiveSub(sub) {
+  const prev = activeSub;
+  activeSub = sub;
+  return prev;
+}
+function untrack(fn) {
+  const prev = activeSub;
+  activeSub = void 0;
+  try {
+    return fn();
+  } finally {
+    activeSub = prev;
+  }
+}
+function setTransitionContext(value) {
+  const prev = isInTransition;
+  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();
+  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;
+  });
+  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");
+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);
+    },
+    set(target, prop, value2, receiver) {
+      if (prop === PROXY || prop === TARGET) return false;
+      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);
+      }
+      return result;
+    },
+    deleteProperty(target, prop) {
+      const result = Reflect.deleteProperty(target, prop);
+      if (result) {
+        trigger(target, prop);
+      }
+      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) {
+    s = signal(getLastValue(target, prop));
+    signals.set(prop, s);
+  }
+  s();
+}
+function trigger(target, prop) {
+  const signals = signalCache.get(target);
+  if (signals) {
+    const s = signals.get(prop);
+    if (s) {
+      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) {
+  let cleanups = [];
+  const rootForError = getCurrentRoot();
+  const run = () => {
+    runCleanupList(cleanups);
+    const bucket = [];
+    withEffectCleanups(bucket, () => {
+      try {
+        const maybeCleanup = fn();
+        if (typeof maybeCleanup === "function") {
+          bucket.push(maybeCleanup);
+        }
+      } catch (err) {
+        if (handleError(err, { source: "effect" }, rootForError)) {
+          return;
+        }
+        throw err;
+      }
+    });
+    cleanups = bucket;
+  };
+  const disposeEffect = effect(run);
+  const teardown = () => {
+    runCleanupList(cleanups);
+    disposeEffect();
+  };
+  registerRootCleanup(teardown);
+  return teardown;
+}
+var $effect = createEffect;
+function createRenderEffect(fn) {
+  let cleanup;
+  const rootForError = getCurrentRoot();
+  const run = () => {
+    if (cleanup) {
+      cleanup();
+      cleanup = void 0;
+    }
+    try {
+      const maybeCleanup = fn();
+      if (typeof maybeCleanup === "function") {
+        cleanup = maybeCleanup;
+      }
+    } catch (err) {
+      if (handleError(err, { source: "effect" }, rootForError)) {
+        return;
+      }
+      throw err;
+    }
+  };
+  const disposeEffect = effect(run);
+  const teardown = () => {
+    if (cleanup) {
+      cleanup();
+      cleanup = void 0;
+    }
+    disposeEffect();
+  };
+  registerRootCleanup(teardown);
+  return teardown;
+}
+
+// src/hooks.ts
+var ctxStack = [];
+function __fictUseContext() {
+  if (ctxStack.length === 0) {
+    const ctx2 = { slots: [], cursor: 0 };
+    ctxStack.push(ctx2);
+    return ctx2;
+  }
+  const ctx = ctxStack[ctxStack.length - 1];
+  ctx.cursor = 0;
+  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) {
+  const index = slot ?? ctx.cursor++;
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = signal(initial);
+  }
+  return ctx.slots[index];
+}
+function __fictUseMemo(ctx, fn, slot) {
+  const index = slot ?? ctx.cursor++;
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = createMemo(fn);
+  }
+  return ctx.slots[index];
+}
+function __fictUseEffect(ctx, fn, slot) {
+  const index = slot ?? ctx.cursor++;
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = createEffect(fn);
+  }
+}
+function __fictRender(ctx, fn) {
+  ctxStack.push(ctx);
+  ctx.cursor = 0;
+  try {
+    return fn();
+  } finally {
+    ctxStack.pop();
+  }
+}
+
+// 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()
+  };
+}
+
+// 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) {
+      if (typeof prop === "symbol") {
+        return void 0;
+      }
+      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/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) => {
+    pending(true);
+    startTransition(() => {
+      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/constants.ts
+var booleans = [
+  "allowfullscreen",
+  "async",
+  "alpha",
+  // HTMLInputElement
+  "autofocus",
+  // HTMLElement prop
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  // HTMLElement prop
+  "indeterminate",
+  "inert",
+  // HTMLElement prop
+  "ismap",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "seamless",
+  // HTMLIframeElement - non-standard
+  "selected",
+  // Experimental attributes
+  "adauctionheaders",
+  "browsingtopics",
+  "credentialless",
+  "defaultchecked",
+  "defaultmuted",
+  "defaultselected",
+  "defer",
+  "disablepictureinpicture",
+  "disableremoteplayback",
+  "preservespitch",
+  "shadowrootclonable",
+  "shadowrootcustomelementregistry",
+  "shadowrootdelegatesfocus",
+  "shadowrootserializable",
+  "sharedstoragewritable"
+];
+var BooleanAttributes = new Set(booleans);
+var Properties = /* @__PURE__ */ new Set([
+  // Core properties
+  "className",
+  "value",
+  // CamelCase booleans
+  "readOnly",
+  "noValidate",
+  "formNoValidate",
+  "isMap",
+  "noModule",
+  "playsInline",
+  // Experimental (camelCase)
+  "adAuctionHeaders",
+  "allowFullscreen",
+  "browsingTopics",
+  "defaultChecked",
+  "defaultMuted",
+  "defaultSelected",
+  "disablePictureInPicture",
+  "disableRemotePlayback",
+  "preservesPitch",
+  "shadowRootClonable",
+  "shadowRootCustomElementRegistry",
+  "shadowRootDelegatesFocus",
+  "shadowRootSerializable",
+  "sharedStorageWritable",
+  // All lowercase booleans
+  ...booleans
+]);
+var ChildProperties = /* @__PURE__ */ new Set([
+  "innerHTML",
+  "textContent",
+  "innerText",
+  "children"
+]);
+var Aliases = {
+  className: "class",
+  htmlFor: "for"
+};
+var PropAliases = {
+  // Direct mapping
+  class: "className",
+  // Element-specific mappings
+  novalidate: {
+    $: "noValidate",
+    FORM: 1
+  },
+  formnovalidate: {
+    $: "formNoValidate",
+    BUTTON: 1,
+    INPUT: 1
+  },
+  ismap: {
+    $: "isMap",
+    IMG: 1
+  },
+  nomodule: {
+    $: "noModule",
+    SCRIPT: 1
+  },
+  playsinline: {
+    $: "playsInline",
+    VIDEO: 1
+  },
+  readonly: {
+    $: "readOnly",
+    INPUT: 1,
+    TEXTAREA: 1
+  },
+  // Experimental element-specific
+  adauctionheaders: {
+    $: "adAuctionHeaders",
+    IFRAME: 1
+  },
+  allowfullscreen: {
+    $: "allowFullscreen",
+    IFRAME: 1
+  },
+  browsingtopics: {
+    $: "browsingTopics",
+    IMG: 1
+  },
+  defaultchecked: {
+    $: "defaultChecked",
+    INPUT: 1
+  },
+  defaultmuted: {
+    $: "defaultMuted",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  defaultselected: {
+    $: "defaultSelected",
+    OPTION: 1
+  },
+  disablepictureinpicture: {
+    $: "disablePictureInPicture",
+    VIDEO: 1
+  },
+  disableremoteplayback: {
+    $: "disableRemotePlayback",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  preservespitch: {
+    $: "preservesPitch",
+    AUDIO: 1,
+    VIDEO: 1
+  },
+  shadowrootclonable: {
+    $: "shadowRootClonable",
+    TEMPLATE: 1
+  },
+  shadowrootdelegatesfocus: {
+    $: "shadowRootDelegatesFocus",
+    TEMPLATE: 1
+  },
+  shadowrootserializable: {
+    $: "shadowRootSerializable",
+    TEMPLATE: 1
+  },
+  sharedstoragewritable: {
+    $: "sharedStorageWritable",
+    IFRAME: 1,
+    IMG: 1
+  }
+};
+function getPropAlias(prop, tagName) {
+  const a = PropAliases[prop];
+  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([
+  "altGlyph",
+  "altGlyphDef",
+  "altGlyphItem",
+  "animate",
+  "animateColor",
+  "animateMotion",
+  "animateTransform",
+  "circle",
+  "clipPath",
+  "color-profile",
+  "cursor",
+  "defs",
+  "desc",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "font",
+  "font-face",
+  "font-face-format",
+  "font-face-name",
+  "font-face-src",
+  "font-face-uri",
+  "foreignObject",
+  "g",
+  "glyph",
+  "glyphRef",
+  "hkern",
+  "image",
+  "line",
+  "linearGradient",
+  "marker",
+  "mask",
+  "metadata",
+  "missing-glyph",
+  "mpath",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "set",
+  "stop",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "textPath",
+  "tref",
+  "tspan",
+  "use",
+  "view",
+  "vkern"
+]);
+var SVGNamespace = {
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace"
+};
+var UnitlessStyles = /* @__PURE__ */ new Set([
+  "animationIterationCount",
+  "animation-iteration-count",
+  "borderImageOutset",
+  "border-image-outset",
+  "borderImageSlice",
+  "border-image-slice",
+  "borderImageWidth",
+  "border-image-width",
+  "boxFlex",
+  "box-flex",
+  "boxFlexGroup",
+  "box-flex-group",
+  "boxOrdinalGroup",
+  "box-ordinal-group",
+  "columnCount",
+  "column-count",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flex-grow",
+  "flexPositive",
+  "flex-positive",
+  "flexShrink",
+  "flex-shrink",
+  "flexNegative",
+  "flex-negative",
+  "flexOrder",
+  "flex-order",
+  "gridRow",
+  "grid-row",
+  "gridRowEnd",
+  "grid-row-end",
+  "gridRowSpan",
+  "grid-row-span",
+  "gridRowStart",
+  "grid-row-start",
+  "gridColumn",
+  "grid-column",
+  "gridColumnEnd",
+  "grid-column-end",
+  "gridColumnSpan",
+  "grid-column-span",
+  "gridColumnStart",
+  "grid-column-start",
+  "fontWeight",
+  "font-weight",
+  "lineClamp",
+  "line-clamp",
+  "lineHeight",
+  "line-height",
+  "opacity",
+  "order",
+  "orphans",
+  "tabSize",
+  "tab-size",
+  "widows",
+  "zIndex",
+  "z-index",
+  "zoom",
+  "fillOpacity",
+  "fill-opacity",
+  "floodOpacity",
+  "flood-opacity",
+  "stopOpacity",
+  "stop-opacity",
+  "strokeDasharray",
+  "stroke-dasharray",
+  "strokeDashoffset",
+  "stroke-dashoffset",
+  "strokeMiterlimit",
+  "stroke-miterlimit",
+  "strokeOpacity",
+  "stroke-opacity",
+  "strokeWidth",
+  "stroke-width"
+]);
+
+// src/node-ops.ts
+function toNodeArray(node) {
+  try {
+    if (Array.isArray(node)) {
+      let allNodes = true;
+      for (const item of node) {
+        let isItemNode = false;
+        try {
+          isItemNode = item instanceof Node;
+        } catch {
+          isItemNode = false;
+        }
+        if (!isItemNode) {
+          allNodes = false;
+          break;
+        }
+      }
+      if (allNodes) {
+        return node;
+      }
+      const result = [];
+      for (const item of node) {
+        result.push(...toNodeArray(item));
+      }
+      return result;
+    }
+    if (node === null || node === void 0 || node === false) {
+      return [];
+    }
+  } catch {
+    return [];
+  }
+  let isNode = false;
+  try {
+    isNode = node instanceof Node;
+  } catch {
+    isNode = false;
+  }
+  if (isNode) {
+    try {
+      if (node instanceof DocumentFragment) {
+        return Array.from(node.childNodes);
+      }
+    } catch {
+    }
+    return [node];
+  }
+  try {
+    if (typeof node === "object" && node !== null && "marker" in node) {
+      return toNodeArray(node.marker);
+    }
+  } catch {
+  }
+  try {
+    return [document.createTextNode(String(node))];
+  } catch {
+    return [document.createTextNode("")];
+  }
+}
+function insertNodesBefore(parent, nodes, anchor) {
+  if (nodes.length === 0) return;
+  if (nodes.length === 1) {
+    const node = nodes[0];
+    if (node === void 0 || node === null) return;
+    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);
+          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/binding.ts
+function isReactive(value) {
+  return typeof value === "function" && value.length === 0;
+}
+function unwrap2(value) {
+  return isReactive(value) ? value() : value;
+}
+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 createValueProxy(read) {
+  const getPrimitivePrototype = (value) => {
+    switch (typeof value) {
+      case "string":
+        return String.prototype;
+      case "number":
+        return Number.prototype;
+      case "boolean":
+        return Boolean.prototype;
+      case "bigint":
+        return BigInt.prototype;
+      case "symbol":
+        return Symbol.prototype;
+      default:
+        return void 0;
+    }
+  };
+  const target = {};
+  const handler = {
+    get(_target, prop, receiver) {
+      if (prop === PRIMITIVE_PROXY) {
+        return true;
+      }
+      if (prop === PRIMITIVE_PROXY_RAW_VALUE) {
+        return () => read();
+      }
+      if (prop === Symbol.toPrimitive) {
+        return (hint) => {
+          const value2 = read();
+          if (value2 != null && (typeof value2 === "object" || typeof value2 === "function")) {
+            const toPrimitive = value2[Symbol.toPrimitive];
+            if (typeof toPrimitive === "function") {
+              return toPrimitive.call(value2, hint);
+            }
+            if (hint === "string") return value2.toString?.() ?? "[object Object]";
+            if (hint === "number") return value2.valueOf?.() ?? value2;
+            return value2.valueOf?.() ?? value2;
+          }
+          return value2;
+        };
+      }
+      if (prop === "valueOf") {
+        return () => {
+          const value2 = read();
+          if (value2 != null && (typeof value2 === "object" || typeof value2 === "function")) {
+            return typeof value2.valueOf === "function" ? value2.valueOf() : value2;
+          }
+          return value2;
+        };
+      }
+      if (prop === "toString") {
+        return () => String(read());
+      }
+      const value = read();
+      if (value != null && (typeof value === "object" || typeof value === "function")) {
+        return Reflect.get(value, prop, receiver === _target ? value : receiver);
+      }
+      const proto = getPrimitivePrototype(value);
+      if (proto && prop in proto) {
+        const descriptor = Reflect.get(proto, prop, value);
+        return typeof descriptor === "function" ? descriptor.bind(value) : descriptor;
+      }
+      return void 0;
+    },
+    set(_target, prop, newValue, receiver) {
+      const value = read();
+      if (value != null && (typeof value === "object" || typeof value === "function")) {
+        return Reflect.set(value, prop, newValue, receiver === _target ? value : receiver);
+      }
+      return false;
+    },
+    has(_target, prop) {
+      if (prop === PRIMITIVE_PROXY || prop === PRIMITIVE_PROXY_RAW_VALUE) {
+        return true;
+      }
+      const value = read();
+      if (value != null && (typeof value === "object" || typeof value === "function")) {
+        return prop in value;
+      }
+      const proto = getPrimitivePrototype(value);
+      return proto ? prop in proto : false;
+    },
+    ownKeys() {
+      const value = read();
+      if (value != null && (typeof value === "object" || typeof value === "function")) {
+        return Reflect.ownKeys(value);
+      }
+      const proto = getPrimitivePrototype(value);
+      return proto ? Reflect.ownKeys(proto) : [];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const value = read();
+      if (value != null && (typeof value === "object" || typeof value === "function")) {
+        return Object.getOwnPropertyDescriptor(value, prop);
+      }
+      const proto = getPrimitivePrototype(value);
+      return proto ? Object.getOwnPropertyDescriptor(proto, prop) || void 0 : void 0;
+    }
+  };
+  return new Proxy(target, 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(() => {
+      setter(el, key, value());
+    });
+  } else {
+    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) {
+  if (isReactive(value)) {
+    let prev;
+    createRenderEffect(() => {
+      const next = value();
+      applyStyle(el, next, prev);
+      prev = next;
+    });
+  } else {
+    applyStyle(el, value, void 0);
+  }
+}
+function bindStyle(el, getValue) {
+  let prev;
+  return createRenderEffect(() => {
+    const next = getValue();
+    applyStyle(el, next, prev);
+    prev = next;
+  });
+}
+function applyStyle(el, value, prev) {
+  if (typeof value === "string") {
+    el.style.cssText = value;
+  } else if (value && typeof value === "object") {
+    const styles = value;
+    if (typeof prev === "string") {
+      el.style.cssText = "";
+    }
+    if (prev && typeof prev === "object") {
+      const prevStyles = prev;
+      for (const key of Object.keys(prevStyles)) {
+        if (!(key in styles)) {
+          const cssProperty = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+          el.style.removeProperty(cssProperty);
+        }
+      }
+    }
+    for (const [prop, v] of Object.entries(styles)) {
+      if (v != null) {
+        const cssProperty = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const unitless = isUnitlessStyleProperty(prop) || 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();
+        el.style.removeProperty(cssProperty);
+      }
+    }
+  } else {
+    if (prev && typeof prev === "object") {
+      const prevStyles = prev;
+      for (const key of Object.keys(prevStyles)) {
+        const cssProperty = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+        el.style.removeProperty(cssProperty);
+      }
+    } else if (typeof prev === "string") {
+      el.style.cssText = "";
+    }
+  }
+}
+function isUnitlessStyleProperty(prop) {
+  return UnitlessStyles.has(prop);
+}
+function createClassBinding(el, value) {
+  if (isReactive(value)) {
+    let prev = {};
+    createRenderEffect(() => {
+      const next = value();
+      prev = applyClass(el, next, prev);
+    });
+  } else {
+    applyClass(el, value, {});
+  }
+}
+function bindClass(el, getValue) {
+  let prev = {};
+  return createRenderEffect(() => {
+    const next = getValue();
+    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++) {
+    node.classList.toggle(classNames[i], value);
+  }
+}
+function applyClass(el, value, prev) {
+  const prevState = prev && typeof prev === "object" ? prev : {};
+  if (typeof value === "string") {
+    el.className = value;
+    return {};
+  }
+  if (value && typeof value === "object") {
+    const classes = value;
+    const classKeys = Object.keys(classes);
+    const prevKeys = Object.keys(prevState);
+    for (let i = 0, len = prevKeys.length; i < len; i++) {
+      const key = prevKeys[i];
+      if (!key || key === "undefined" || classes[key]) continue;
+      toggleClassKey(el, key, false);
+      delete prevState[key];
+    }
+    for (let i = 0, len = classKeys.length; i < len; i++) {
+      const key = classKeys[i];
+      const classValue = !!classes[key];
+      if (!key || key === "undefined" || prevState[key] === classValue || !classValue) continue;
+      toggleClassKey(el, key, true);
+      prevState[key] = classValue;
+    }
+    return prevState;
+  }
+  if (!value) {
+    for (const key of Object.keys(prevState)) {
+      if (key && key !== "undefined") {
+        toggleClassKey(el, key, false);
+      }
+    }
+    return {};
+  }
+  return prevState;
+}
+function classList(node, value, prev = {}) {
+  return applyClass(node, value, prev);
+}
+function insert(parent, getValue, markerOrCreateElement, createElementFn) {
+  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();
+    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 {
+          newNode = createFn ? createFn(value) : 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);
+  const dispose = createRenderEffect(() => {
+    const root = createRootContext();
+    const prev = pushRoot(root);
+    let nodes = [];
+    let handledError = false;
+    try {
+      const value = getValue();
+      if (value == null || value === false) {
+        return;
+      }
+      const output = createElementFn(value);
+      nodes = toNodeArray(output);
+      const parentNode = marker.parentNode;
+      if (parentNode) {
+        insertNodesBefore(parentNode, nodes, marker);
+      }
+      return () => {
+        destroyRoot(root);
+        removeNodes(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);
+      }
+    }
+  });
+  return {
+    marker,
+    dispose: () => {
+      dispose();
+      marker.parentNode?.removeChild(marker);
+    }
+  };
+}
+function delegateEvents(eventNames, doc = window.document) {
+  const e = doc[$$EVENTS] || (doc[$$EVENTS] = /* @__PURE__ */ new Set());
+  for (let i = 0, l = eventNames.length; i < l; i++) {
+    const name = eventNames[i];
+    if (!e.has(name)) {
+      e.add(name);
+      doc.addEventListener(name, globalEventHandler);
+    }
+  }
+}
+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) {
+  let node = e.target;
+  const key = `$$${e.type}`;
+  const dataKey = `${key}Data`;
+  const oriTarget = e.target;
+  const oriCurrentTarget = e.currentTarget;
+  const retarget = (value) => Object.defineProperty(e, "target", {
+    configurable: true,
+    value
+  });
+  const handleNode = () => {
+    if (!node) return false;
+    const handler = node[key];
+    if (handler && !node.disabled) {
+      const resolveData = (value) => {
+        if (typeof value === "function") {
+          try {
+            const fn = value;
+            return fn.length > 0 ? fn(e) : fn();
+          } catch {
+            return value();
+          }
+        }
+        return value;
+      };
+      const rawData = node[dataKey];
+      const hasData = rawData !== void 0;
+      const resolvedNodeData = hasData ? resolveData(rawData) : void 0;
+      if (typeof handler === "function") {
+        if (hasData) {
+          ;
+          handler.call(node, resolvedNodeData, e);
+        } else {
+          ;
+          handler.call(node, e);
+        }
+      } else if (Array.isArray(handler)) {
+        const tupleData = resolveData(handler[1]);
+        handler[0].call(node, tupleData, e);
+      }
+      if (e.cancelBubble) return false;
+    }
+    const shadowHost = node.host;
+    if (shadowHost && typeof shadowHost !== "string" && !shadowHost._$host && node.contains(e.target)) {
+      retarget(shadowHost);
+    }
+    return true;
+  };
+  const walkUpTree = () => {
+    while (handleNode() && node) {
+      node = node._$host || node.parentNode || node.host;
+    }
+  };
+  Object.defineProperty(e, "currentTarget", {
+    configurable: true,
+    get() {
+      return node || document;
+    }
+  });
+  if (e.composedPath) {
+    const path = e.composedPath();
+    retarget(path[0]);
+    for (let i = 0; i < path.length - 2; i++) {
+      node = path[i];
+      if (!handleNode()) break;
+      if (node._$host) {
+        node = node._$host;
+        walkUpTree();
+        break;
+      }
+      if (node.parentNode === oriCurrentTarget) {
+        break;
+      }
+    }
+  } else {
+    walkUpTree();
+  }
+  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, options2) {
+  if (handler == null) return () => {
+  };
+  const rootRef = getCurrentRoot();
+  if (DelegatedEvents.has(eventName) && !options2) {
+    const key = `$$${eventName}`;
+    delegateEvents([eventName]);
+    const createWrapped = (resolve) => {
+      const wrapped2 = function(...args) {
+        try {
+          const fn = resolve();
+          if (typeof fn === "function") {
+            return fn.apply(this, args);
+          } else if (fn && typeof fn.handleEvent === "function") {
+            return fn.handleEvent.apply(fn, args);
+          }
+        } catch (err) {
+          handleError(err, { source: "event", eventName }, rootRef);
+        }
+      };
+      return wrapped2;
+    };
+    const resolveHandler = isReactive(handler) ? handler : () => handler;
+    el[key] = createWrapped(resolveHandler);
+    return () => {
+      el[key] = void 0;
+    };
+  }
+  const getHandler = isReactive(handler) ? handler : () => handler;
+  const wrapped = (event) => {
+    try {
+      const resolved = getHandler();
+      if (typeof resolved === "function") {
+        ;
+        resolved(event);
+      } else if (resolved && typeof resolved.handleEvent === "function") {
+        ;
+        resolved.handleEvent(event);
+      }
+    } catch (err) {
+      if (handleError(err, { source: "event", eventName }, rootRef)) {
+        return;
+      }
+      throw err;
+    }
+  };
+  el.addEventListener(eventName, wrapped, options2);
+  const cleanup = () => el.removeEventListener(eventName, wrapped, options2);
+  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 = 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 = 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[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 = Aliases[prop] || 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);
+  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();
+    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);
+    }
+  };
+}
+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 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);
+        } else {
+          const previousIndex = existing.index();
+          existing.value(item);
+          existing.index(i);
+          if (previousValue === item) {
+            bumpBlockVersion(existing);
+          }
+          const needsRerender = getKey ? true : previousValue !== item || previousIndex !== i;
+          block = needsRerender ? rerenderBlock(existing, createElementFn) : existing;
+        }
+      } else {
+        block = mountBlock(item, i, renderItem, parent, endMarker, createElementFn);
+      }
+      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 createShow(el, condition, displayValue) {
+  const originalDisplay = displayValue ?? el.style.display;
+  createRenderEffect(() => {
+    el.style.display = condition() ? originalDisplay : "none";
+  });
+}
+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();
+    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);
+    }
+    if (currentNodes.length > 0) {
+      removeNodes(currentNodes);
+    }
+    marker.parentNode?.removeChild(marker);
+  };
+  if (parentRoot) {
+    parentRoot.destroyCallbacks.push(portalDispose);
+  }
+  return {
+    marker,
+    dispose: portalDispose
+  };
+}
+function mountBlock(initialValue, initialIndex, renderItem, parent, anchor, createElementFn) {
+  const start = document.createComment("fict:block:start");
+  const end = document.createComment("fict:block:end");
+  const valueSig = signal(initialValue);
+  const indexSig = signal(initialIndex);
+  const versionSig = signal(0);
+  const valueProxy = createValueProxy(() => {
+    versionSig();
+    return valueSig();
+  });
+  const renderCurrent = () => renderItem(valueProxy, indexSig());
+  const root = createRootContext();
+  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);
+    }
+    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;
+    }
+  } finally {
+    popRoot(prev);
+    if (!handledError) {
+      flushOnMount(root);
+    } else {
+      destroyRoot(root);
+    }
+  }
+  return {
+    nodes,
+    root,
+    value: valueSig,
+    index: indexSig,
+    version: versionSig,
+    start,
+    end,
+    valueProxy,
+    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 (handleError(err, { source: "renderChild" }, block.root)) {
+      handledError = true;
+      popRoot(prev);
+      destroyRoot(block.root);
+      block.nodes = [block.start, block.end];
+      return block;
+    }
+    throw err;
+  } finally {
+    if (!handledError) {
+      popRoot(prev);
+    }
+  }
+  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 (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 (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;
+          }
+        }
+      }
+      return false;
+    }
+  }
+  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;
+      }
+    } else if (output.nodeType === Node.TEXT_NODE) {
+      el.textContent = output.data;
+      return true;
+    }
+  }
+  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 normalizeChildren(children, result = []) {
+  if (children === void 0) {
+    return result;
+  }
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      normalizeChildren(child, result);
+    }
+    return result;
+  }
+  if (children === null || children === false) {
+    return result;
+  }
+  result.push(children);
+  return result;
+}
+function patchFragmentChildren(nodes, children) {
+  const normalized = normalizeChildren(children);
+  if (normalized.length !== nodes.length) {
+    return false;
+  }
+  for (let i = 0; i < normalized.length; i++) {
+    if (!patchNode(nodes[i], normalized[i])) {
+      return false;
+    }
+  }
+  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;
+  }
+}
+function bumpBlockVersion(block) {
+  block.version(block.version() + 1);
+}
+
+// src/dom.ts
+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) {
+  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) {
+      return createElement(node.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);
+    }
+    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);
+    try {
+      __fictPushContext();
+      const rendered = vnode.type(props);
+      __fictPopContext();
+      return createElement(rendered);
+    } catch (err) {
+      __fictPopContext();
+      if (handleSuspend(err)) {
+        return document.createComment("fict:suspend");
+      }
+      handleError(err, { source: "render", componentName: vnode.type.name });
+      throw err;
+    }
+  }
+  if (vnode.type === Fragment) {
+    const frag = document.createDocumentFragment();
+    const children = vnode.props?.children;
+    appendChildren(frag, children);
+    return frag;
+  }
+  const tagName = typeof vnode.type === "string" ? vnode.type : "div";
+  const el = document.createElement(tagName);
+  applyProps(el, vnode.props ?? {});
+  return el;
+}
+function template(html, isImportNode, isSVG, isMathML) {
+  let node = null;
+  const create = () => {
+    const t = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "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) {
+  if (child === null || child === void 0 || child === false) {
+    return;
+  }
+  if (isBindingHandle(child)) {
+    appendChildNode(parent, child.marker);
+    child.flush?.();
+    return;
+  }
+  if (typeof child === "function" && child.length === 0) {
+    const childGetter = child;
+    createChildBinding(parent, childGetter, createElement);
+    return;
+  }
+  if (Array.isArray(child)) {
+    for (const item of child) {
+      appendChildNode(parent, item);
+    }
+    return;
+  }
+  let domNode;
+  if (typeof child !== "object" || child === null) {
+    domNode = document.createTextNode(String(child ?? ""));
+  } else {
+    domNode = createElement(child);
+  }
+  if (domNode.nodeType === 11) {
+    const children = Array.from(domNode.childNodes);
+    for (const node of children) {
+      appendChildNode(parent, node);
+    }
+    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) {
+  if (children === void 0) return;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      appendChildren(parent, child);
+    }
+    return;
+  }
+  appendChildNode(parent, children);
+}
+function applyRef(el, value) {
+  if (typeof value === "function") {
+    const refFn = value;
+    refFn(el);
+    if (getCurrentRoot()) {
+      registerRootCleanup(() => {
+        refFn(null);
+      });
+    }
+  } else if (value && typeof value === "object" && "current" in value) {
+    const refObj = value;
+    refObj.current = el;
+    if (getCurrentRoot()) {
+      registerRootCleanup(() => {
+        refObj.current = null;
+      });
+    }
+  }
+}
+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,
+          toPropertyName2(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);
+  }
+  const children = props.children;
+  appendChildren(el, children);
+}
+function toPropertyName2(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();
+}
+
+// src/error-boundary.ts
+function ErrorBoundary(props) {
+  const fragment = document.createDocumentFragment();
+  const marker = document.createComment("fict:error-boundary");
+  fragment.appendChild(marker);
+  const currentView = signal(props.children ?? null);
+  let cleanup;
+  let activeNodes = [];
+  let renderingFallback = false;
+  const toView = (err) => {
+    if (err != null) {
+      return typeof props.fallback === "function" ? props.fallback(err) : props.fallback;
+    }
+    return props.children ?? null;
+  };
+  const renderValue = (value) => {
+    if (cleanup) {
+      cleanup();
+      cleanup = void 0;
+    }
+    if (activeNodes.length) {
+      removeNodes(activeNodes);
+      activeNodes = [];
+    }
+    if (value == null || value === false) {
+      return;
+    }
+    const root = createRootContext();
+    const prev = pushRoot(root);
+    let nodes = [];
+    try {
+      const output = createElement(value);
+      nodes = toNodeArray(output);
+      const parentNode = marker.parentNode;
+      if (parentNode) {
+        insertNodesBefore(parentNode, nodes, marker);
+      }
+    } catch (err) {
+      popRoot(prev);
+      flushOnMount(root);
+      destroyRoot(root);
+      if (renderingFallback) {
+        throw err;
+      }
+      renderingFallback = true;
+      try {
+        renderValue(toView(err));
+      } finally {
+        renderingFallback = false;
+      }
+      props.onError?.(err);
+      return;
+    }
+    popRoot(prev);
+    flushOnMount(root);
+    cleanup = () => {
+      destroyRoot(root);
+      removeNodes(nodes);
+    };
+    activeNodes = nodes;
+  };
+  createEffect(() => {
+    const value = currentView();
+    renderValue(value);
+  });
+  registerErrorHandler((err) => {
+    renderValue(toView(err));
+    props.onError?.(err);
+    return true;
+  });
+  if (props.resetKeys !== void 0) {
+    const isGetter = typeof props.resetKeys === "function" && props.resetKeys.length === 0;
+    const getter = isGetter ? props.resetKeys : void 0;
+    let prev = isGetter ? getter() : props.resetKeys;
+    createEffect(() => {
+      const next = getter ? getter() : props.resetKeys;
+      if (prev !== next) {
+        prev = next;
+        renderValue(toView(null));
+      }
+    });
+  }
+  return fragment;
+}
+
+// src/suspense.ts
+function createSuspenseToken() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    token: {
+      then: promise.then.bind(promise)
+    },
+    resolve,
+    reject
+  };
+}
+var isThenable = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
+function Suspense(props) {
+  const currentView = signal(props.children ?? null);
+  const pending = signal(0);
+  let resolvedOnce = false;
+  let epoch = 0;
+  const hostRoot = getCurrentRoot();
+  const toFallback = (err) => typeof props.fallback === "function" ? props.fallback(err) : props.fallback;
+  const switchView = (view) => {
+    currentView(view);
+    renderView(view);
+  };
+  const renderView = (view) => {
+    if (cleanup) {
+      cleanup();
+      cleanup = void 0;
+    }
+    if (activeNodes.length) {
+      removeNodes(activeNodes);
+      activeNodes = [];
+    }
+    if (view == null || view === false) {
+      return;
+    }
+    const root = createRootContext(hostRoot);
+    const prev = pushRoot(root);
+    let nodes = [];
+    try {
+      const output = createElement(view);
+      nodes = toNodeArray(output);
+      const suspendedAttempt = nodes.length > 0 && nodes.every((node) => node instanceof Comment && node.data === "fict:suspend");
+      if (suspendedAttempt) {
+        popRoot(prev);
+        destroyRoot(root);
+        return;
+      }
+      const parentNode = marker.parentNode;
+      if (parentNode) {
+        insertNodesBefore(parentNode, nodes, marker);
+      }
+    } catch (err) {
+      popRoot(prev);
+      flushOnMount(root);
+      destroyRoot(root);
+      handleError(err, { source: "render" });
+      return;
+    }
+    popRoot(prev);
+    flushOnMount(root);
+    cleanup = () => {
+      destroyRoot(root);
+      removeNodes(nodes);
+    };
+    activeNodes = nodes;
+  };
+  const fragment = document.createDocumentFragment();
+  const marker = document.createComment("fict:suspense");
+  fragment.appendChild(marker);
+  let cleanup;
+  let activeNodes = [];
+  const onResolveMaybe = () => {
+    if (!resolvedOnce) {
+      resolvedOnce = true;
+      props.onResolve?.();
+    }
+  };
+  registerSuspenseHandler((token) => {
+    const tokenEpoch = epoch;
+    pending(pending() + 1);
+    switchView(toFallback());
+    const thenable = token.then ? token : isThenable(token) ? token : null;
+    if (thenable) {
+      thenable.then(
+        () => {
+          if (epoch !== tokenEpoch) return;
+          pending(Math.max(0, pending() - 1));
+          if (pending() === 0) {
+            switchView(props.children ?? null);
+            onResolveMaybe();
+          }
+        },
+        (err) => {
+          if (epoch !== tokenEpoch) return;
+          pending(Math.max(0, pending() - 1));
+          props.onReject?.(err);
+          handleError(err, { source: "render" }, hostRoot);
+        }
+      );
+      return true;
+    }
+    return false;
+  });
+  createEffect(() => {
+    renderView(currentView());
+  });
+  if (props.resetKeys !== void 0) {
+    const isGetter = typeof props.resetKeys === "function" && props.resetKeys.length === 0;
+    const getter = isGetter ? props.resetKeys : void 0;
+    let prev = isGetter ? getter() : props.resetKeys;
+    createEffect(() => {
+      const next = getter ? getter() : props.resetKeys;
+      if (prev !== next) {
+        prev = next;
+        epoch++;
+        pending(0);
+        switchView(props.children ?? null);
+      }
+    });
+  }
+  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
+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;
+  }
+}
+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++;
+    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();
+    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) {
+  const itemSig = createVersionedSignalAccessor(item);
+  const indexSig = needsIndex ? signal(index) : ((next) => {
+    if (arguments.length === 0) return index;
+    index = next;
+    return index;
+  });
+  const root = createRootContext();
+  const prevRoot = pushRoot(root);
+  const prevSub = setActiveSub(void 0);
+  let nodes = [];
+  try {
+    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 {
+    setActiveSub(prevSub);
+    popRoot(prevRoot);
+    flushOnMount(root);
+  }
+  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 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 fragment = document.createDocumentFragment();
+  fragment.append(container.startMarker, container.endMarker);
+  let pendingItems = null;
+  let disposed = false;
+  const performDiff = () => {
+    if (disposed) return;
+    batch2(() => {
+      const newItems = pendingItems || getItems();
+      pendingItems = null;
+      const oldBlocks = container.blocks;
+      const newBlocks = container.nextBlocks;
+      const prevOrderedBlocks = container.orderedBlocks;
+      const nextOrderedBlocks = container.nextOrderedBlocks;
+      const orderedIndexByKey = container.orderedIndexByKey;
+      newBlocks.clear();
+      nextOrderedBlocks.length = 0;
+      orderedIndexByKey.clear();
+      const endParent = container.endMarker.parentNode;
+      const startParent = container.startMarker.parentNode;
+      const parent = endParent && startParent && endParent === startParent && endParent.isConnected ? endParent : null;
+      if (!parent) {
+        pendingItems = newItems;
+        queueMicrotask(performDiff);
+        return;
+      }
+      if (newItems.length === 0) {
+        if (oldBlocks.size > 0) {
+          for (const block of oldBlocks.values()) {
+            destroyRoot(block.root);
+            removeNodes(block.nodes);
+          }
+        }
+        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;
+      let appendCandidate = prevCount > 0 && newItems.length >= prevCount;
+      const appendedBlocks = [];
+      newItems.forEach((item, index) => {
+        const key = keyFn(item, index);
+        const existed = oldBlocks.has(key);
+        let block = oldBlocks.get(key);
+        if (block) {
+          if (block.rawItem !== item) {
+            block.rawItem = item;
+            block.item(item);
+          }
+          if (needsIndex && block.rawIndex !== index) {
+            block.rawIndex = index;
+            block.index(index);
+          }
+        }
+        const existingBlock = newBlocks.get(key);
+        if (existingBlock && existingBlock !== block) {
+          destroyRoot(existingBlock.root);
+          removeNodes(existingBlock.nodes);
+        }
+        if (block) {
+          newBlocks.set(key, block);
+          oldBlocks.delete(key);
+        } else {
+          const existingBlock2 = newBlocks.get(key);
+          if (existingBlock2) {
+            destroyRoot(existingBlock2.root);
+            removeNodes(existingBlock2.nodes);
+          }
+          block = createKeyedBlock(key, item, index, renderItem, needsIndex);
+        }
+        const resolvedBlock = block;
+        newBlocks.set(key, resolvedBlock);
+        const position = orderedIndexByKey.get(key);
+        if (position !== void 0) {
+          appendCandidate = false;
+        }
+        if (appendCandidate) {
+          if (index < prevCount) {
+            if (!prevOrderedBlocks[index] || prevOrderedBlocks[index].key !== key) {
+              appendCandidate = false;
+            }
+          } else if (existed) {
+            appendCandidate = false;
+          }
+        }
+        if (position !== void 0) {
+          const prior = nextOrderedBlocks[position];
+          if (prior && prior !== resolvedBlock) {
+            destroyRoot(prior.root);
+            removeNodes(prior.nodes);
+          }
+          nextOrderedBlocks[position] = resolvedBlock;
+        } else {
+          orderedIndexByKey.set(key, nextOrderedBlocks.length);
+          nextOrderedBlocks.push(resolvedBlock);
+        }
+        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;
+        return;
+      }
+      if (oldBlocks.size > 0) {
+        for (const block of oldBlocks.values()) {
+          destroyRoot(block.root);
+          removeNodes(block.nodes);
+        }
+        oldBlocks.clear();
+      }
+      if (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;
+      }
+      container.blocks = newBlocks;
+      container.nextBlocks = oldBlocks;
+      container.orderedBlocks = nextOrderedBlocks;
+      container.nextOrderedBlocks = prevOrderedBlocks;
+    });
+  };
+  const effectDispose = createRenderEffect(performDiff);
+  return {
+    marker: fragment,
+    startMarker: container.startMarker,
+    endMarker: container.endMarker,
+    // Flush pending items - call after markers are inserted into DOM
+    flush: () => {
+      if (pendingItems !== null) {
+        performDiff();
+      }
+    },
+    dispose: () => {
+      disposed = true;
+      effectDispose?.();
+      container.dispose();
+    }
+  };
+}
+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,
+  classList,
+  clearDelegatedEvents,
+  createAttributeBinding,
+  createChildBinding,
+  createClassBinding,
+  createConditional,
+  createEffect,
+  createElement,
+  createKeyedBlock,
+  createKeyedList,
+  createKeyedListContainer,
+  createList,
+  createMemo,
+  createPortal,
+  createPropsProxy,
+  createRef,
+  createRenderEffect,
+  createRoot,
+  createSelector,
+  createShow,
+  signal as createSignal,
+  createStore,
+  createStyleBinding,
+  createSuspenseToken,
+  createTextBinding,
+  createVersionedSignal,
+  delegateEvents,
+  destroyMarkerBlock,
+  getDevtoolsHook,
+  getFirstNodeAfter,
+  getPropAlias,
+  insert,
+  insertNodesBefore,
+  isNodeBetweenMarkers,
+  isReactive,
+  mergeProps,
+  moveMarkerBlock,
+  moveNodesBefore,
+  onCleanup,
+  onDestroy,
+  onMount,
+  __fictProp as prop,
+  reconcileArrays,
+  removeNodes,
+  render,
+  setCycleProtectionOptions,
+  spread,
+  startTransition,
+  template,
+  toNodeArray,
+  untrack2 as untrack,
+  unwrap2 as unwrap,
+  unwrapPrimitive,
+  useDeferredValue,
+  useProp,
+  useTransition
+};
+//# sourceMappingURL=index.dev.js.map