@fictjs/runtime 0.0.12 → 0.0.14

package/dist/index.cjs

@@ -1,4303 +1,40 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkGJTYOFMOcjs = require('./chunk-GJTYOFMO.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-// 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;
-      }
-    }
-  }
-  return false;
-}
-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 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);
-};
-var inCleanup = false;
-var SIGNAL_MARKER = Symbol.for("fict:signal");
-var COMPUTED_MARKER = Symbol.for("fict:computed");
-var EFFECT_MARKER = Symbol.for("fict:effect");
-var EFFECT_SCOPE_MARKER = Symbol.for("fict:effectScope");
-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 & -9 | 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 (!dep.deps) {
-        const nextDep = link2.nextDep;
-        if (nextDep !== void 0) {
-          link2 = nextDep;
-          continue;
-        }
-      } else {
-        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);
-  let sub = node.subs;
-  while (sub !== void 0) {
-    const next = sub.nextSub;
-    unlink(sub);
-    sub = next;
-  }
-}
-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) {
-    if (e.runCleanup) {
-      inCleanup = true;
-      try {
-        e.runCleanup();
-      } finally {
-        inCleanup = false;
-      }
-    }
-    ++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 if (flags & Pending && e.deps) {
-    if (e.runCleanup) {
-      inCleanup = true;
-      try {
-        e.runCleanup();
-      } finally {
-        inCleanup = false;
-      }
-    }
-    if (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;
-    }
-  } 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);
-  const accessor = signalOper.bind(s);
-  accessor[SIGNAL_MARKER] = true;
-  return accessor;
-}
-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 && !inCleanup) {
-    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);
-  bound[COMPUTED_MARKER] = true;
-  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;
-  }
-  const disposer = effectOper.bind(e);
-  disposer[EFFECT_MARKER] = true;
-  return disposer;
-}
-function effectWithCleanup(fn, cleanupRunner) {
-  const e = {
-    fn,
-    subs: void 0,
-    subsTail: void 0,
-    deps: void 0,
-    depsTail: void 0,
-    flags: WatchingRunning,
-    runCleanup: cleanupRunner,
-    __id: void 0
-  };
-  registerEffectDevtools(e);
-  const prevSub = activeSub;
-  if (prevSub !== void 0) link(e, prevSub, 0);
-  activeSub = e;
-  try {
-    effectRunDevtools(e);
-    fn();
-  } finally {
-    activeSub = prevSub;
-    e.flags &= ~Running;
-  }
-  const disposer = effectOper.bind(e);
-  disposer[EFFECT_MARKER] = true;
-  return disposer;
-}
-function effectOper() {
-  disposeNode(this);
-}
-function effectScope(fn) {
-  const e = { deps: void 0, depsTail: void 0, subs: void 0, subsTail: void 0, flags: 0 };
-  const prevSub = activeSub;
-  if (prevSub !== void 0) link(e, prevSub, 0);
-  activeSub = e;
-  try {
-    fn();
-  } finally {
-    activeSub = prevSub;
-  }
-  const disposer = effectScopeOper.bind(e);
-  disposer[EFFECT_SCOPE_MARKER] = true;
-  return disposer;
-}
-function effectScopeOper() {
-  disposeNode(this);
-}
-function batch(fn) {
-  ++batchDepth;
-  let hasError = false;
-  try {
-    return fn();
-  } catch (e) {
-    hasError = true;
-    throw e;
-  } finally {
-    --batchDepth;
-    if (!hasError && 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();
-  const dispose = effect(() => {
-    const next = source();
-    if (equalityFn(current, next)) return;
-    const prevSig = observers.get(current);
-    if (prevSig) prevSig(false);
-    const nextSig = observers.get(next);
-    if (nextSig) nextSig(true);
-    current = next;
-  });
-  registerRootCleanup(() => {
-    dispose();
-    observers.clear();
-  });
-  return (key) => {
-    let sig = observers.get(key);
-    if (!sig) {
-      sig = signal(equalityFn(key, current));
-      observers.set(key, sig);
-      registerRootCleanup(() => observers.delete(key));
-    }
-    return sig();
-  };
-}
-
-// src/store.ts
-var PROXY = Symbol("fict:store-proxy");
-var TARGET = Symbol("fict:store-target");
-var ITERATE_KEY = Symbol("fict:iterate");
-function createStore(initialValue) {
-  const unwrapped = unwrap(initialValue);
-  const wrapped = wrap(unwrapped);
-  function setStore(fn) {
-    batch(() => {
-      const result = fn(wrapped);
-      if (result !== void 0) {
-        reconcile(wrapped, result);
-      }
-    });
-  }
-  return [wrapped, setStore];
-}
-var proxyCache = /* @__PURE__ */ new WeakMap();
-var signalCache = /* @__PURE__ */ new WeakMap();
-function wrap(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (value[PROXY]) return value;
-  if (proxyCache.has(value)) return proxyCache.get(value);
-  const handler = {
-    get(target, prop, receiver) {
-      if (prop === PROXY) return true;
-      if (prop === TARGET) return target;
-      const value2 = Reflect.get(target, prop, receiver);
-      track(target, prop);
-      return wrap(value2);
-    },
-    has(target, prop) {
-      const result = Reflect.has(target, prop);
-      track(target, prop);
-      return result;
-    },
-    ownKeys(target) {
-      track(target, ITERATE_KEY);
-      return Reflect.ownKeys(target);
-    },
-    getOwnPropertyDescriptor(target, prop) {
-      track(target, prop);
-      return Reflect.getOwnPropertyDescriptor(target, prop);
-    },
-    set(target, prop, value2, receiver) {
-      if (prop === PROXY || prop === TARGET) return false;
-      const hadKey = Object.prototype.hasOwnProperty.call(target, prop);
-      const oldValue = Reflect.get(target, prop, receiver);
-      if (oldValue === value2) return true;
-      const result = Reflect.set(target, prop, value2, receiver);
-      if (result) {
-        trigger(target, prop);
-        if (!hadKey) {
-          trigger(target, ITERATE_KEY);
-        }
-      }
-      return result;
-    },
-    deleteProperty(target, prop) {
-      const hadKey = Object.prototype.hasOwnProperty.call(target, prop);
-      const result = Reflect.deleteProperty(target, prop);
-      if (result) {
-        trigger(target, prop);
-        if (hadKey) {
-          trigger(target, ITERATE_KEY);
-        }
-      }
-      return result;
-    }
-  };
-  const proxy = new Proxy(value, handler);
-  proxyCache.set(value, proxy);
-  return proxy;
-}
-function unwrap(value) {
-  if (value && typeof value === "object" && value[PROXY]) {
-    return value[TARGET];
-  }
-  return value;
-}
-function track(target, prop) {
-  let signals = signalCache.get(target);
-  if (!signals) {
-    signals = /* @__PURE__ */ new Map();
-    signalCache.set(target, signals);
-  }
-  let s = signals.get(prop);
-  if (!s) {
-    const initial = prop === ITERATE_KEY ? Reflect.ownKeys(target).length : getLastValue(target, prop);
-    s = signal(initial);
-    signals.set(prop, s);
-  }
-  s();
-}
-function trigger(target, prop) {
-  const signals = signalCache.get(target);
-  if (signals) {
-    const s = signals.get(prop);
-    if (s) {
-      if (prop === ITERATE_KEY) {
-        s(Reflect.ownKeys(target).length);
-      } else {
-        s(getLastValue(target, prop));
-      }
-    }
-  }
-}
-function getLastValue(target, prop) {
-  return target[prop];
-}
-function reconcile(target, value) {
-  if (target === value) return;
-  if (value === null || typeof value !== "object") return;
-  const realTarget = unwrap(target);
-  const realValue = unwrap(value);
-  const keys = /* @__PURE__ */ new Set([...Object.keys(realTarget), ...Object.keys(realValue)]);
-  for (const key of keys) {
-    if (realValue[key] === void 0 && realTarget[key] !== void 0) {
-      delete target[key];
-    } else if (realTarget[key] !== realValue[key]) {
-      target[key] = realValue[key];
-    }
-  }
-}
-
-// src/memo.ts
-function createMemo(fn) {
-  return computed(fn);
-}
-var $memo = createMemo;
-
-// src/effect.ts
-function createEffect(fn) {
-  let cleanups = [];
-  const rootForError = getCurrentRoot();
-  const doCleanup = () => {
-    runCleanupList(cleanups);
-    cleanups = [];
-  };
-  const run = () => {
-    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 = effectWithCleanup(run, doCleanup);
-  const teardown = () => {
-    runCleanupList(cleanups);
-    disposeEffect();
-  };
-  registerRootCleanup(teardown);
-  return teardown;
-}
-var $effect = createEffect;
-function createRenderEffect(fn) {
-  let cleanup;
-  const rootForError = getCurrentRoot();
-  const doCleanup = () => {
-    if (cleanup) {
-      cleanup();
-      cleanup = void 0;
-    }
-  };
-  const run = () => {
-    try {
-      const maybeCleanup = fn();
-      if (typeof maybeCleanup === "function") {
-        cleanup = maybeCleanup;
-      }
-    } catch (err) {
-      const handled = handleError(err, { source: "effect" }, rootForError);
-      if (handled) {
-        return;
-      }
-      throw err;
-    }
-  };
-  const disposeEffect = effectWithCleanup(run, doCleanup);
-  const teardown = () => {
-    if (cleanup) {
-      cleanup();
-      cleanup = void 0;
-    }
-    disposeEffect();
-  };
-  registerRootCleanup(teardown);
-  return teardown;
-}
-
-// 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/jsx.ts
-var Fragment = Symbol("Fragment");
-
-// src/hooks.ts
-var ctxStack = [];
-function assertRenderContext(ctx, hookName) {
-  if (!ctx.rendering) {
-    throw new Error(`${hookName} can only be used during render execution`);
-  }
-}
-function __fictUseContext() {
-  if (ctxStack.length === 0) {
-    const ctx2 = { slots: [], cursor: 0, rendering: true };
-    ctxStack.push(ctx2);
-    return ctx2;
-  }
-  const ctx = ctxStack[ctxStack.length - 1];
-  ctx.cursor = 0;
-  ctx.rendering = true;
-  return ctx;
-}
-function __fictPushContext() {
-  const ctx = { slots: [], cursor: 0 };
-  ctxStack.push(ctx);
-  return ctx;
-}
-function __fictPopContext() {
-  ctxStack.pop();
-}
-function __fictResetContext() {
-  ctxStack.length = 0;
-}
-function __fictUseSignal(ctx, initial, slot) {
-  assertRenderContext(ctx, "__fictUseSignal");
-  const index = slot ?? ctx.cursor++;
-  if (!ctx.slots[index]) {
-    ctx.slots[index] = signal(initial);
-  }
-  return ctx.slots[index];
-}
-function __fictUseMemo(ctx, fn, slot) {
-  assertRenderContext(ctx, "__fictUseMemo");
-  const index = slot ?? ctx.cursor++;
-  if (!ctx.slots[index]) {
-    ctx.slots[index] = createMemo(fn);
-  }
-  return ctx.slots[index];
-}
-function __fictUseEffect(ctx, fn, slot) {
-  assertRenderContext(ctx, "__fictUseEffect");
-  const index = slot ?? ctx.cursor++;
-  if (!ctx.slots[index]) {
-    ctx.slots[index] = createEffect(fn);
-  }
-}
-function __fictRender(ctx, fn) {
-  ctxStack.push(ctx);
-  ctx.cursor = 0;
-  ctx.rendering = true;
-  try {
-    return fn();
-  } finally {
-    ctx.rendering = false;
-    ctxStack.pop();
-  }
-}
-
-// src/props.ts
-var propGetters = /* @__PURE__ */ new WeakSet();
-var rawToProxy = /* @__PURE__ */ new WeakMap();
-var proxyToRaw = /* @__PURE__ */ new WeakMap();
-function __fictProp(getter) {
-  if (typeof getter === "function" && getter.length === 0) {
-    propGetters.add(getter);
-  }
-  return getter;
-}
-function isPropGetter(value) {
-  return typeof value === "function" && propGetters.has(value);
-}
-function createPropsProxy(props) {
-  if (!props || typeof props !== "object") {
-    return props;
-  }
-  if (proxyToRaw.has(props)) {
-    return props;
-  }
-  const cached = rawToProxy.get(props);
-  if (cached) {
-    return cached;
-  }
-  const proxy = new Proxy(props, {
-    get(target, prop, receiver) {
-      const value = Reflect.get(target, prop, receiver);
-      if (isPropGetter(value)) {
-        return value();
-      }
-      return value;
-    },
-    set(target, prop, value, receiver) {
-      return Reflect.set(target, prop, value, receiver);
-    },
-    has(target, prop) {
-      return prop in target;
-    },
-    ownKeys(target) {
-      return Reflect.ownKeys(target);
-    },
-    getOwnPropertyDescriptor(target, prop) {
-      return Object.getOwnPropertyDescriptor(target, prop);
-    }
-  });
-  rawToProxy.set(props, proxy);
-  proxyToRaw.set(proxy, props);
-  return proxy;
-}
-function unwrapProps(props) {
-  if (!props || typeof props !== "object") {
-    return props;
-  }
-  return proxyToRaw.get(props) ?? props;
-}
-function __fictPropsRest(props, exclude) {
-  const raw = unwrapProps(props);
-  const out = {};
-  const excludeSet = new Set(exclude);
-  for (const key of Reflect.ownKeys(raw)) {
-    if (excludeSet.has(key)) continue;
-    out[key] = raw[key];
-  }
-  return createPropsProxy(out);
-}
-function mergeProps(...sources) {
-  const validSources = sources.filter(
-    (s) => s != null && (typeof s === "object" || typeof s === "function")
-  );
-  if (validSources.length === 0) {
-    return {};
-  }
-  if (validSources.length === 1 && typeof validSources[0] === "object") {
-    return validSources[0];
-  }
-  const resolveSource = (src) => {
-    const value = typeof src === "function" ? src() : src;
-    if (!value || typeof value !== "object") return void 0;
-    return unwrapProps(value);
-  };
-  return new Proxy({}, {
-    get(_, prop) {
-      for (let i = validSources.length - 1; i >= 0; i--) {
-        const src = validSources[i];
-        const raw = resolveSource(src);
-        if (!raw || !(prop in raw)) continue;
-        const value = raw[prop];
-        if (typeof src === "function" && !isPropGetter(value)) {
-          return __fictProp(() => {
-            const latest = resolveSource(src);
-            if (!latest || !(prop in latest)) return void 0;
-            return latest[prop];
-          });
-        }
-        return value;
-      }
-      return void 0;
-    },
-    has(_, prop) {
-      for (const src of validSources) {
-        const raw = resolveSource(src);
-        if (raw && prop in raw) {
-          return true;
-        }
-      }
-      return false;
-    },
-    ownKeys() {
-      const keys = /* @__PURE__ */ new Set();
-      for (const src of validSources) {
-        const raw = resolveSource(src);
-        if (raw) {
-          for (const key of Reflect.ownKeys(raw)) {
-            keys.add(key);
-          }
-        }
-      }
-      return Array.from(keys);
-    },
-    getOwnPropertyDescriptor(_, prop) {
-      for (let i = validSources.length - 1; i >= 0; i--) {
-        const raw = resolveSource(validSources[i]);
-        if (raw && prop in raw) {
-          return {
-            enumerable: true,
-            configurable: true,
-            get: () => {
-              const value = raw[prop];
-              return value;
-            }
-          };
-        }
-      }
-      return void 0;
-    }
-  });
-}
-function useProp(getter) {
-  return __fictProp(createMemo(getter));
-}
-
-// src/transition.ts
-function startTransition(fn) {
-  const prev = setTransitionContext(true);
-  try {
-    fn();
-  } finally {
-    setTransitionContext(prev);
-    scheduleFlush();
-  }
-}
-function useTransition() {
-  const pending = signal(false);
-  const start = (fn) => {
-    startTransition(() => {
-      pending(true);
-      try {
-        fn();
-      } finally {
-        pending(false);
-      }
-    });
-  };
-  return [() => pending(), start];
-}
-function useDeferredValue(getValue) {
-  const deferredValue = signal(getValue());
-  createEffect(() => {
-    const newValue = getValue();
-    const currentDeferred = untrack(() => deferredValue());
-    if (currentDeferred !== newValue) {
-      startTransition(() => {
-        deferredValue(newValue);
-      });
-    }
-  });
-  return () => deferredValue();
-}
-
-// src/scheduler.ts
-function batch2(fn) {
-  return batch(fn);
-}
-function untrack2(fn) {
-  return untrack(fn);
-}
-
-// src/dom.ts
-var SVG_NS = "http://www.w3.org/2000/svg";
-var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
-function render(view, container) {
-  const root = createRootContext();
-  const prev = pushRoot(root);
-  let dom;
-  try {
-    const output = view();
-    dom = createElement(output);
-  } finally {
-    popRoot(prev);
-  }
-  container.replaceChildren(dom);
-  container.setAttribute("data-fict-fine-grained", "1");
-  flushOnMount(root);
-  const teardown = () => {
-    destroyRoot(root);
-    container.innerHTML = "";
-  };
-  return teardown;
-}
-function createElement(node) {
-  return createElementWithContext(node, null);
-}
-function resolveNamespace(tagName, namespace) {
-  if (tagName === "svg") return "svg";
-  if (tagName === "math") return "mathml";
-  if (namespace === "mathml") return "mathml";
-  if (namespace === "svg") return "svg";
-  if (SVGElements.has(tagName)) return "svg";
-  return null;
-}
-function createElementWithContext(node, namespace) {
-  if (node instanceof Node) {
-    return node;
-  }
-  if (node === null || node === void 0 || node === false) {
-    return document.createTextNode("");
-  }
-  if (typeof node === "object" && node !== null && !(node instanceof Node)) {
-    if ("marker" in node) {
-      const handle = node;
-      if (typeof handle.dispose === "function") {
-        registerRootCleanup(handle.dispose);
-      }
-      if (typeof handle.flush === "function") {
-        const runFlush = () => handle.flush && handle.flush();
-        if (typeof queueMicrotask === "function") {
-          queueMicrotask(runFlush);
-        } else {
-          Promise.resolve().then(runFlush).catch(() => void 0);
-        }
-      }
-      return createElement(handle.marker);
-    }
-    const nodeRecord = node;
-    if (nodeRecord[PRIMITIVE_PROXY]) {
-      const primitiveGetter = nodeRecord[Symbol.toPrimitive];
-      const value = typeof primitiveGetter === "function" ? primitiveGetter.call(node, "default") : node;
-      return document.createTextNode(value == null || value === false ? "" : String(value));
-    }
-  }
-  if (Array.isArray(node)) {
-    const frag = document.createDocumentFragment();
-    for (const child of node) {
-      appendChildNode(frag, child, namespace);
-    }
-    return frag;
-  }
-  if (typeof node === "string" || typeof node === "number") {
-    return document.createTextNode(String(node));
-  }
-  if (typeof node === "boolean") {
-    return document.createTextNode("");
-  }
-  const vnode = node;
-  if (typeof vnode.type === "function") {
-    const rawProps = unwrapProps(vnode.props ?? {});
-    const baseProps = vnode.key === void 0 ? rawProps : new Proxy(rawProps, {
-      get(target, prop, receiver) {
-        if (prop === "key") return vnode.key;
-        return Reflect.get(target, prop, receiver);
-      },
-      has(target, prop) {
-        if (prop === "key") return true;
-        return prop in target;
-      },
-      ownKeys(target) {
-        const keys = new Set(Reflect.ownKeys(target));
-        keys.add("key");
-        return Array.from(keys);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        if (prop === "key") {
-          return { enumerable: true, configurable: true, value: vnode.key };
-        }
-        return Object.getOwnPropertyDescriptor(target, prop);
-      }
-    });
-    const props = createPropsProxy(baseProps);
-    __fictPushContext();
-    try {
-      const rendered = vnode.type(props);
-      return createElementWithContext(rendered, namespace);
-    } catch (err) {
-      if (handleSuspend(err)) {
-        return document.createComment("fict:suspend");
-      }
-      handleError(err, { source: "render", componentName: vnode.type.name });
-      throw err;
-    } finally {
-      __fictPopContext();
-    }
-  }
-  if (vnode.type === Fragment) {
-    const frag = document.createDocumentFragment();
-    const children = vnode.props?.children;
-    appendChildren(frag, children, namespace);
-    return frag;
-  }
-  const tagName = typeof vnode.type === "string" ? vnode.type : "div";
-  const resolvedNamespace = resolveNamespace(tagName, namespace);
-  const el = resolvedNamespace === "svg" ? document.createElementNS(SVG_NS, tagName) : resolvedNamespace === "mathml" ? document.createElementNS(MATHML_NS, tagName) : document.createElement(tagName);
-  applyProps(el, vnode.props ?? {}, resolvedNamespace === "svg");
-  appendChildren(
-    el,
-    vnode.props?.children,
-    tagName === "foreignObject" ? null : resolvedNamespace
-  );
-  return el;
-}
-function template(html, isImportNode, isSVG, isMathML) {
-  let node = null;
-  const create = () => {
-    const t = isMathML ? document.createElementNS(MATHML_NS, "template") : document.createElement("template");
-    t.innerHTML = html;
-    if (isSVG) {
-      return t.content.firstChild.firstChild;
-    }
-    if (isMathML) {
-      return t.firstChild;
-    }
-    return t.content.firstChild;
-  };
-  const fn = isImportNode ? () => untrack2(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
-  fn.cloneNode = fn;
-  return fn;
-}
-function isBindingHandle(node) {
-  return node !== null && typeof node === "object" && "marker" in node && "dispose" in node && typeof node.dispose === "function";
-}
-function appendChildNode(parent, child, namespace) {
-  if (child === null || child === void 0 || child === false) {
-    return;
-  }
-  if (isBindingHandle(child)) {
-    appendChildNode(parent, child.marker, namespace);
-    child.flush?.();
-    return;
-  }
-  if (typeof child === "function" && child.length === 0) {
-    const childGetter = child;
-    createChildBinding(parent, childGetter, (node) => createElementWithContext(node, namespace));
-    return;
-  }
-  if (Array.isArray(child)) {
-    for (const item of child) {
-      appendChildNode(parent, item, namespace);
-    }
-    return;
-  }
-  let domNode;
-  if (typeof child !== "object" || child === null) {
-    domNode = document.createTextNode(String(child ?? ""));
-  } else {
-    domNode = createElementWithContext(child, namespace);
-  }
-  if (domNode.nodeType === 11) {
-    const children = Array.from(domNode.childNodes);
-    for (const node of children) {
-      appendChildNode(parent, node, namespace);
-    }
-    return;
-  }
-  if (domNode.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
-    parent.ownerDocument.adoptNode(domNode);
-  }
-  try {
-    parent.appendChild(domNode);
-  } catch (e) {
-    if (parent.ownerDocument) {
-      const clone = parent.ownerDocument.importNode(domNode, true);
-      parent.appendChild(clone);
-      return;
-    }
-    throw e;
-  }
-}
-function appendChildren(parent, children, namespace) {
-  if (children === void 0) return;
-  if (Array.isArray(children)) {
-    for (const child of children) {
-      appendChildren(parent, child, namespace);
-    }
-    return;
-  }
-  appendChildNode(parent, children, namespace);
-}
-function applyRef(el, value) {
-  if (typeof value === "function") {
-    const refFn = value;
-    refFn(el);
-    const root = getCurrentRoot();
-    if (root) {
-      registerRootCleanup(() => {
-        refFn(null);
-      });
-    }
-  } else if (value && typeof value === "object" && "current" in value) {
-    const refObj = value;
-    refObj.current = el;
-    const root = getCurrentRoot();
-    if (root) {
-      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,
-          toPropertyName(propName),
-          value,
-          setProperty
-        );
-      } else {
-        createAttributeBinding(el, propName, value, setProperty);
-      }
-      continue;
-    }
-    if (isSVG && key.indexOf(":") > -1) {
-      const [prefix, name] = key.split(":");
-      const ns = SVGNamespace[prefix];
-      if (ns) {
-        createAttributeBinding(
-          el,
-          key,
-          value,
-          (el2, _key, val) => setAttributeNS(el2, ns, name, val)
-        );
-        continue;
-      }
-    }
-    const attrName = Aliases[key] || key;
-    createAttributeBinding(el, attrName, value, setAttribute);
-  }
-}
-function toPropertyName(name) {
-  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
-}
-var setAttribute = (el, key, value) => {
-  if (value === void 0 || value === null || value === false) {
-    el.removeAttribute(key);
-    return;
-  }
-  if (value === true) {
-    el.setAttribute(key, "");
-    return;
-  }
-  const valueType = typeof value;
-  if (valueType === "string" || valueType === "number") {
-    el.setAttribute(key, String(value));
-    return;
-  }
-  if (key in el) {
-    el[key] = value;
-    return;
-  }
-  el.setAttribute(key, String(value));
-};
-var setProperty = (el, key, value) => {
-  if (value === void 0 || value === null) {
-    const fallback = key === "checked" || key === "selected" ? false : "";
-    el[key] = fallback;
-    return;
-  }
-  if (key === "style" && typeof value === "object" && value !== null) {
-    for (const k in value) {
-      const v = value[k];
-      if (v !== void 0) {
-        el.style[k] = String(v);
-      }
-    }
-    return;
-  }
-  el[key] = value;
-};
-var setInnerHTML = (el, _key, value) => {
-  el.innerHTML = value == null ? "" : String(value);
-};
-var setBoolAttribute = (el, key, value) => {
-  if (value) {
-    el.setAttribute(key, "");
-  } else {
-    el.removeAttribute(key);
-  }
-};
-function setAttributeNS(el, namespace, name, value) {
-  if (value == null) {
-    el.removeAttributeNS(namespace, name);
-  } else {
-    el.setAttributeNS(namespace, name, String(value));
-  }
-}
-function isEventKey(key) {
-  return key.startsWith("on") && key.length > 2 && key[2].toUpperCase() === key[2];
-}
-function eventNameFromProp(key) {
-  return key.slice(2).toLowerCase();
-}
-
-// 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/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);
-      }
-    }
-  }
-}
-function moveNodesBefore(parent, nodes, anchor) {
-  for (let i = nodes.length - 1; i >= 0; i--) {
-    const node = nodes[i];
-    if (!node || !(node instanceof Node)) {
-      throw new Error("Invalid node in moveNodesBefore");
-    }
-    if (node.nextSibling !== anchor) {
-      if (node.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {
-        parent.ownerDocument.adoptNode(node);
-      }
-      try {
-        parent.insertBefore(node, anchor);
-      } catch (e) {
-        if (parent.ownerDocument) {
-          try {
-            const clone = parent.ownerDocument.importNode(node, true);
-            parent.insertBefore(clone, anchor);
-            continue;
-          } catch {
-          }
-        }
-        throw e;
-      }
-    }
-    anchor = node;
-  }
-}
-function moveMarkerBlock(parent, block, anchor) {
-  const nodes = collectBlockNodes(block);
-  if (nodes.length === 0) return;
-  moveNodesBefore(parent, nodes, anchor);
-}
-function destroyMarkerBlock(block) {
-  if (block.root) {
-    destroyRoot(block.root);
-  }
-  removeBlockRange(block);
-}
-function collectBlockNodes(block) {
-  const nodes = [];
-  let cursor = block.start;
-  while (cursor) {
-    nodes.push(cursor);
-    if (cursor === block.end) {
-      break;
-    }
-    cursor = cursor.nextSibling;
-  }
-  return nodes;
-}
-function removeBlockRange(block) {
-  let cursor = block.start;
-  while (cursor) {
-    const next = cursor.nextSibling;
-    cursor.parentNode?.removeChild(cursor);
-    if (cursor === block.end) {
-      break;
-    }
-    cursor = next;
-  }
-}
-var MAX_SAFE_VERSION = 9007199254740991;
-function createVersionedSignalAccessor(initialValue) {
-  let current = initialValue;
-  let version = 0;
-  const track2 = signal(version);
-  function accessor(value) {
-    if (arguments.length === 0) {
-      track2();
-      return current;
-    }
-    current = value;
-    version = version >= MAX_SAFE_VERSION ? 1 : version + 1;
-    track2(version);
-  }
-  return accessor;
-}
-function createKeyedListContainer() {
-  const startMarker = document.createComment("fict:list:start");
-  const endMarker = document.createComment("fict:list:end");
-  const dispose = () => {
-    for (const block of container.blocks.values()) {
-      destroyRoot(block.root);
-    }
-    container.blocks.clear();
-    container.nextBlocks.clear();
-    if (!startMarker.parentNode || !endMarker.parentNode) {
-      container.currentNodes = [];
-      container.nextNodes = [];
-      container.orderedBlocks.length = 0;
-      container.nextOrderedBlocks.length = 0;
-      container.orderedIndexByKey.clear();
-      return;
-    }
-    const range = document.createRange();
-    range.setStartBefore(startMarker);
-    range.setEndAfter(endMarker);
-    range.deleteContents();
-    container.currentNodes = [];
-    container.nextNodes = [];
-    container.nextBlocks.clear();
-    container.orderedBlocks.length = 0;
-    container.nextOrderedBlocks.length = 0;
-    container.orderedIndexByKey.clear();
-  };
-  const container = {
-    startMarker,
-    endMarker,
-    blocks: /* @__PURE__ */ new Map(),
-    nextBlocks: /* @__PURE__ */ new Map(),
-    currentNodes: [startMarker, endMarker],
-    nextNodes: [],
-    orderedBlocks: [],
-    nextOrderedBlocks: [],
-    orderedIndexByKey: /* @__PURE__ */ new Map(),
-    dispose
-  };
-  return container;
-}
-function createKeyedBlock(key, item, index, render2, needsIndex = true, hostRoot) {
-  const itemSig = createVersionedSignalAccessor(item);
-  const indexSig = needsIndex ? signal(index) : ((next) => {
-    if (arguments.length === 0) return index;
-    index = next;
-    return index;
-  });
-  const root = createRootContext(hostRoot);
-  const prevRoot = pushRoot(root);
-  let nodes = [];
-  let scopeDispose;
-  const prevSub = setActiveSub(void 0);
-  try {
-    scopeDispose = effectScope(() => {
-      const rendered = render2(itemSig, indexSig, key);
-      if (rendered instanceof Node || Array.isArray(rendered) && rendered.every((n) => n instanceof Node)) {
-        nodes = toNodeArray(rendered);
-      } else {
-        const element = createElement(rendered);
-        nodes = toNodeArray(element);
-      }
-    });
-    if (scopeDispose) {
-      root.cleanups.push(scopeDispose);
-    }
-  } finally {
-    setActiveSub(prevSub);
-    popRoot(prevRoot);
-  }
-  return {
-    key,
-    nodes,
-    root,
-    item: itemSig,
-    index: indexSig,
-    rawItem: item,
-    rawIndex: index
-  };
-}
-function getFirstNodeAfter(marker) {
-  return marker.nextSibling;
-}
-function isNodeBetweenMarkers(node, startMarker, endMarker) {
-  let current = startMarker.nextSibling;
-  while (current && current !== endMarker) {
-    if (current === node) return true;
-    current = current.nextSibling;
-  }
-  return false;
-}
-function reorderBySwap(parent, first, second) {
-  if (first === second) return false;
-  const firstNodes = first.nodes;
-  const secondNodes = second.nodes;
-  if (firstNodes.length === 0 || secondNodes.length === 0) return false;
-  const lastFirst = firstNodes[firstNodes.length - 1];
-  const lastSecond = secondNodes[secondNodes.length - 1];
-  const afterFirst = lastFirst.nextSibling;
-  const afterSecond = lastSecond.nextSibling;
-  moveNodesBefore(parent, firstNodes, afterSecond);
-  moveNodesBefore(parent, secondNodes, afterFirst);
-  return true;
-}
-function getLISIndices(sequence) {
-  const predecessors = new Array(sequence.length);
-  const result = [];
-  for (let i = 0; i < sequence.length; i++) {
-    const value = sequence[i];
-    if (value < 0) {
-      predecessors[i] = -1;
-      continue;
-    }
-    let low = 0;
-    let high = result.length;
-    while (low < high) {
-      const mid = low + high >> 1;
-      if (sequence[result[mid]] < value) {
-        low = mid + 1;
-      } else {
-        high = mid;
-      }
-    }
-    predecessors[i] = low > 0 ? result[low - 1] : -1;
-    if (low === result.length) {
-      result.push(i);
-    } else {
-      result[low] = i;
-    }
-  }
-  const lis = new Array(result.length);
-  let k = result.length > 0 ? result[result.length - 1] : -1;
-  for (let i = result.length - 1; i >= 0; i--) {
-    lis[i] = k;
-    k = predecessors[k];
-  }
-  return lis;
-}
-function reorderByLIS(parent, endMarker, prev, next) {
-  const positions = /* @__PURE__ */ new Map();
-  for (let i = 0; i < prev.length; i++) {
-    positions.set(prev[i], i);
-  }
-  const sequence = new Array(next.length);
-  for (let i = 0; i < next.length; i++) {
-    const position = positions.get(next[i]);
-    if (position === void 0) return false;
-    sequence[i] = position;
-  }
-  const lisIndices = getLISIndices(sequence);
-  if (lisIndices.length === sequence.length) return true;
-  const inLIS = new Array(sequence.length).fill(false);
-  for (let i = 0; i < lisIndices.length; i++) {
-    inLIS[lisIndices[i]] = true;
-  }
-  let anchor = endMarker;
-  let moved = false;
-  for (let i = next.length - 1; i >= 0; i--) {
-    const block = next[i];
-    const nodes = block.nodes;
-    if (nodes.length === 0) continue;
-    if (inLIS[i]) {
-      anchor = nodes[0];
-      continue;
-    }
-    moveNodesBefore(parent, nodes, anchor);
-    anchor = nodes[0];
-    moved = true;
-  }
-  return moved;
-}
-function createKeyedList(getItems, keyFn, renderItem, needsIndex) {
-  const resolvedNeedsIndex = arguments.length >= 4 ? !!needsIndex : renderItem.length > 1;
-  return createFineGrainedKeyedList(getItems, keyFn, renderItem, resolvedNeedsIndex);
-}
-function createFineGrainedKeyedList(getItems, keyFn, renderItem, needsIndex) {
-  const container = createKeyedListContainer();
-  const hostRoot = getCurrentRoot();
-  const fragment = document.createDocumentFragment();
-  fragment.append(container.startMarker, container.endMarker);
-  let disposed = false;
-  let effectDispose;
-  let connectObserver = null;
-  let effectStarted = false;
-  let startScheduled = false;
-  const getConnectedParent = () => {
-    const endParent = container.endMarker.parentNode;
-    const startParent = container.startMarker.parentNode;
-    if (endParent && startParent && endParent === startParent && endParent.nodeType !== 11) {
-      return endParent;
-    }
-    return null;
-  };
-  const performDiff = () => {
-    if (disposed) return;
-    const parent = getConnectedParent();
-    if (!parent) return;
-    batch2(() => {
-      const oldBlocks = container.blocks;
-      const newBlocks = container.nextBlocks;
-      const prevOrderedBlocks = container.orderedBlocks;
-      const nextOrderedBlocks = container.nextOrderedBlocks;
-      const orderedIndexByKey = container.orderedIndexByKey;
-      const newItems = getItems();
-      if (newItems.length === 0) {
-        if (oldBlocks.size > 0) {
-          for (const block of oldBlocks.values()) {
-            destroyRoot(block.root);
-          }
-          const range = document.createRange();
-          range.setStartAfter(container.startMarker);
-          range.setEndBefore(container.endMarker);
-          range.deleteContents();
-        }
-        oldBlocks.clear();
-        newBlocks.clear();
-        prevOrderedBlocks.length = 0;
-        nextOrderedBlocks.length = 0;
-        orderedIndexByKey.clear();
-        container.currentNodes.length = 0;
-        container.currentNodes.push(container.startMarker, container.endMarker);
-        container.nextNodes.length = 0;
-        return;
-      }
-      const prevCount = prevOrderedBlocks.length;
-      if (prevCount > 0 && newItems.length === prevCount && orderedIndexByKey.size === prevCount) {
-        let stableOrder = true;
-        const seen = /* @__PURE__ */ new Set();
-        for (let i = 0; i < prevCount; i++) {
-          const item = newItems[i];
-          const key = keyFn(item, i);
-          if (seen.has(key) || prevOrderedBlocks[i].key !== key) {
-            stableOrder = false;
-            break;
-          }
-          seen.add(key);
-        }
-        if (stableOrder) {
-          for (let i = 0; i < prevCount; i++) {
-            const item = newItems[i];
-            const block = prevOrderedBlocks[i];
-            if (block.rawItem !== item) {
-              block.rawItem = item;
-              block.item(item);
-            }
-            if (needsIndex && block.rawIndex !== i) {
-              block.rawIndex = i;
-              block.index(i);
-            }
-          }
-          return;
-        }
-      }
-      newBlocks.clear();
-      nextOrderedBlocks.length = 0;
-      orderedIndexByKey.clear();
-      const createdBlocks = [];
-      let appendCandidate = prevCount > 0 && newItems.length >= prevCount;
-      const appendedBlocks = [];
-      let mismatchCount = 0;
-      let mismatchFirst = -1;
-      let mismatchSecond = -1;
-      let hasDuplicateKey = false;
-      newItems.forEach((item, index) => {
-        const key = keyFn(item, index);
-        let block = oldBlocks.get(key);
-        const existed = block !== void 0;
-        if (block) {
-          if (block.rawItem !== item) {
-            block.rawItem = item;
-            block.item(item);
-          }
-          if (needsIndex && block.rawIndex !== index) {
-            block.rawIndex = index;
-            block.index(index);
-          }
-        }
-        if (block) {
-          newBlocks.set(key, block);
-          oldBlocks.delete(key);
-        } else {
-          const existingBlock = newBlocks.get(key);
-          if (existingBlock) {
-            destroyRoot(existingBlock.root);
-            removeNodes(existingBlock.nodes);
-          }
-          block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot);
-          createdBlocks.push(block);
-        }
-        const resolvedBlock = block;
-        newBlocks.set(key, resolvedBlock);
-        const position = orderedIndexByKey.get(key);
-        if (position !== void 0) {
-          appendCandidate = false;
-          hasDuplicateKey = true;
-          const prior = nextOrderedBlocks[position];
-          if (prior && prior !== resolvedBlock) {
-            destroyRoot(prior.root);
-            removeNodes(prior.nodes);
-          }
-          nextOrderedBlocks[position] = resolvedBlock;
-        } else {
-          if (appendCandidate) {
-            if (index < prevCount) {
-              if (!prevOrderedBlocks[index] || prevOrderedBlocks[index].key !== key) {
-                appendCandidate = false;
-              }
-            } else if (existed) {
-              appendCandidate = false;
-            }
-          }
-          const nextIndex = nextOrderedBlocks.length;
-          orderedIndexByKey.set(key, nextIndex);
-          nextOrderedBlocks.push(resolvedBlock);
-          if (mismatchCount < 3 && (nextIndex >= prevCount || prevOrderedBlocks[nextIndex] !== resolvedBlock)) {
-            if (mismatchCount === 0) {
-              mismatchFirst = nextIndex;
-            } else if (mismatchCount === 1) {
-              mismatchSecond = nextIndex;
-            }
-            mismatchCount++;
-          }
-        }
-        if (appendCandidate && index >= prevCount) {
-          appendedBlocks.push(resolvedBlock);
-        }
-      });
-      const canAppend = appendCandidate && prevCount > 0 && newItems.length > prevCount && oldBlocks.size === 0 && appendedBlocks.length > 0;
-      if (canAppend) {
-        const appendedNodes = [];
-        for (const block of appendedBlocks) {
-          for (let i = 0; i < block.nodes.length; i++) {
-            appendedNodes.push(block.nodes[i]);
-          }
-        }
-        if (appendedNodes.length > 0) {
-          insertNodesBefore(parent, appendedNodes, container.endMarker);
-          const currentNodes = container.currentNodes;
-          currentNodes.pop();
-          for (let i = 0; i < appendedNodes.length; i++) {
-            currentNodes.push(appendedNodes[i]);
-          }
-          currentNodes.push(container.endMarker);
-        }
-        container.blocks = newBlocks;
-        container.nextBlocks = oldBlocks;
-        container.orderedBlocks = nextOrderedBlocks;
-        container.nextOrderedBlocks = prevOrderedBlocks;
-        for (const block of createdBlocks) {
-          if (newBlocks.get(block.key) === block) {
-            flushOnMount(block.root);
-          }
-        }
-        return;
-      }
-      if (oldBlocks.size > 0) {
-        for (const block of oldBlocks.values()) {
-          destroyRoot(block.root);
-          removeNodes(block.nodes);
-        }
-        oldBlocks.clear();
-      }
-      const canReorderInPlace = createdBlocks.length === 0 && oldBlocks.size === 0 && nextOrderedBlocks.length === prevOrderedBlocks.length;
-      let skipReconcile = false;
-      let updateNodeBuffer = true;
-      if (canReorderInPlace && nextOrderedBlocks.length > 0 && !hasDuplicateKey) {
-        if (mismatchCount === 0) {
-          skipReconcile = true;
-          updateNodeBuffer = false;
-        } else if (mismatchCount === 2 && prevOrderedBlocks[mismatchFirst] === nextOrderedBlocks[mismatchSecond] && prevOrderedBlocks[mismatchSecond] === nextOrderedBlocks[mismatchFirst]) {
-          if (reorderBySwap(
-            parent,
-            prevOrderedBlocks[mismatchFirst],
-            prevOrderedBlocks[mismatchSecond]
-          )) {
-            skipReconcile = true;
-          }
-        } else if (reorderByLIS(parent, container.endMarker, prevOrderedBlocks, nextOrderedBlocks)) {
-          skipReconcile = true;
-        }
-      }
-      if (!skipReconcile && (newBlocks.size > 0 || container.currentNodes.length > 0)) {
-        const prevNodes = container.currentNodes;
-        const nextNodes = container.nextNodes;
-        nextNodes.length = 0;
-        nextNodes.push(container.startMarker);
-        for (let i = 0; i < nextOrderedBlocks.length; i++) {
-          const nodes = nextOrderedBlocks[i].nodes;
-          for (let j = 0; j < nodes.length; j++) {
-            nextNodes.push(nodes[j]);
-          }
-        }
-        nextNodes.push(container.endMarker);
-        reconcileArrays(parent, prevNodes, nextNodes);
-        container.currentNodes = nextNodes;
-        container.nextNodes = prevNodes;
-      } else if (skipReconcile && updateNodeBuffer) {
-        const prevNodes = container.currentNodes;
-        const nextNodes = container.nextNodes;
-        nextNodes.length = 0;
-        nextNodes.push(container.startMarker);
-        for (let i = 0; i < nextOrderedBlocks.length; i++) {
-          const nodes = nextOrderedBlocks[i].nodes;
-          for (let j = 0; j < nodes.length; j++) {
-            nextNodes.push(nodes[j]);
-          }
-        }
-        nextNodes.push(container.endMarker);
-        container.currentNodes = nextNodes;
-        container.nextNodes = prevNodes;
-      }
-      container.blocks = newBlocks;
-      container.nextBlocks = oldBlocks;
-      container.orderedBlocks = nextOrderedBlocks;
-      container.nextOrderedBlocks = prevOrderedBlocks;
-      for (const block of createdBlocks) {
-        if (newBlocks.get(block.key) === block) {
-          flushOnMount(block.root);
-        }
-      }
-    });
-  };
-  const disconnectObserver = () => {
-    connectObserver?.disconnect();
-    connectObserver = null;
-  };
-  const ensureEffectStarted = () => {
-    if (disposed || effectStarted) return effectStarted;
-    const parent = getConnectedParent();
-    if (!parent) return false;
-    const start = () => {
-      effectDispose = createRenderEffect(performDiff);
-      effectStarted = true;
-    };
-    if (hostRoot) {
-      const prev = pushRoot(hostRoot);
-      try {
-        start();
-      } finally {
-        popRoot(prev);
-      }
-    } else {
-      start();
-    }
-    return true;
-  };
-  const waitForConnection = () => {
-    if (connectObserver || typeof MutationObserver === "undefined") return;
-    connectObserver = new MutationObserver(() => {
-      if (disposed) return;
-      if (getConnectedParent()) {
-        disconnectObserver();
-        if (ensureEffectStarted()) {
-          flush();
-        }
-      }
-    });
-    connectObserver.observe(document, { childList: true, subtree: true });
-  };
-  const scheduleStart = () => {
-    if (startScheduled || disposed || effectStarted) return;
-    startScheduled = true;
-    const run = () => {
-      startScheduled = false;
-      if (!ensureEffectStarted()) {
-        waitForConnection();
-      }
-    };
-    if (typeof queueMicrotask === "function") {
-      queueMicrotask(run);
-    } else {
-      Promise.resolve().then(run).catch(() => void 0);
-    }
-  };
-  scheduleStart();
-  return {
-    get marker() {
-      scheduleStart();
-      return fragment;
-    },
-    startMarker: container.startMarker,
-    endMarker: container.endMarker,
-    // Flush pending items - call after markers are inserted into DOM
-    flush: () => {
-      if (disposed) return;
-      scheduleStart();
-      if (ensureEffectStarted()) {
-        flush();
-      } else {
-        waitForConnection();
-      }
-    },
-    dispose: () => {
-      disposed = true;
-      effectDispose?.();
-      disconnectObserver();
-      container.dispose();
-    }
-  };
-}
-
-// src/binding.ts
-function isReactive(value) {
-  return typeof value === "function" && value.length === 0;
-}
-function unwrap2(value) {
-  return isReactive(value) ? value() : value;
-}
-function callEventHandler(handler, event, node, data) {
-  if (!handler) return;
-  const context = node ?? event.currentTarget ?? void 0;
-  const invoke = (fn) => {
-    if (typeof fn === "function") {
-      const result = data === void 0 ? fn.call(context, event) : fn.call(context, data, event);
-      if (typeof result === "function" && result !== fn) {
-        if (data === void 0) {
-          result.call(context, event);
-        } else {
-          result.call(context, data, event);
-        }
-      } else if (result && typeof result.handleEvent === "function") {
-        result.handleEvent.call(result, event);
-      }
-    } else if (fn && typeof fn.handleEvent === "function") {
-      fn.handleEvent.call(fn, event);
-    }
-  };
-  invoke(handler);
-}
-var PRIMITIVE_PROXY = Symbol("fict:primitive-proxy");
-var PRIMITIVE_PROXY_RAW_VALUE = Symbol("fict:primitive-proxy:raw-value");
-function unwrapPrimitive(value) {
-  if (value && typeof value === "object" && PRIMITIVE_PROXY in value) {
-    const getRawValue = value[PRIMITIVE_PROXY_RAW_VALUE];
-    if (typeof getRawValue === "function") {
-      return getRawValue();
-    }
-  }
-  return value;
-}
-function createTextBinding(value) {
-  const text = document.createTextNode("");
-  if (isReactive(value)) {
-    createRenderEffect(() => {
-      const v = value();
-      const fmt = formatTextValue(v);
-      if (text.data !== fmt) {
-        text.data = fmt;
-      }
-    });
-  } else {
-    text.data = formatTextValue(value);
-  }
-  return text;
-}
-function bindText(textNode, getValue) {
-  return createRenderEffect(() => {
-    const value = formatTextValue(getValue());
-    if (textNode.data !== value) {
-      textNode.data = value;
-    }
-  });
-}
-function formatTextValue(value) {
-  if (value == null || value === false) {
-    return "";
-  }
-  return String(value);
-}
-function createAttributeBinding(el, key, value, setter) {
-  if (isReactive(value)) {
-    createRenderEffect(() => {
-      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) {
-  const target = el;
-  if (isReactive(value)) {
-    let prev;
-    createRenderEffect(() => {
-      const next = value();
-      applyStyle(target, next, prev);
-      prev = next;
-    });
-  } else {
-    applyStyle(target, value, void 0);
-  }
-}
-function bindStyle(el, getValue) {
-  const target = el;
-  let prev;
-  return createRenderEffect(() => {
-    const next = getValue();
-    applyStyle(target, next, prev);
-    prev = next;
-  });
-}
-function applyStyle(el, value, prev) {
-  if (typeof value === "string") {
-    el.style.cssText = value;
-  } 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 = {};
-  let prevString;
-  return createRenderEffect(() => {
-    const next = getValue();
-    if (typeof next === "string") {
-      if (next === prevString) return;
-      prevString = next;
-      el.className = next;
-      prev = {};
-      return;
-    }
-    prevString = void 0;
-    prev = applyClass(el, next, prev);
-  });
-}
-function toggleClassKey(node, key, value) {
-  const classNames = key.trim().split(/\s+/);
-  for (let i = 0, len = classNames.length; i < len; i++) {
-    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) {
-  const hostRoot = getCurrentRoot();
-  let marker;
-  let ownsMarker = false;
-  let createFn = createElementFn;
-  if (markerOrCreateElement instanceof Node) {
-    marker = markerOrCreateElement;
-    createFn = createElementFn;
-  } else {
-    marker = document.createComment("fict:insert");
-    parent.appendChild(marker);
-    createFn = markerOrCreateElement;
-    ownsMarker = true;
-  }
-  let currentNodes = [];
-  let currentText = null;
-  let currentRoot2 = null;
-  const clearCurrentNodes = () => {
-    if (currentNodes.length > 0) {
-      removeNodes(currentNodes);
-      currentNodes = [];
-    }
-  };
-  const setTextNode = (textValue, shouldInsert, parentNode) => {
-    if (!currentText) {
-      currentText = document.createTextNode(textValue);
-    } else if (currentText.data !== textValue) {
-      currentText.data = textValue;
-    }
-    if (!shouldInsert) {
-      clearCurrentNodes();
-      return;
-    }
-    if (currentNodes.length === 1 && currentNodes[0] === currentText) {
-      return;
-    }
-    clearCurrentNodes();
-    insertNodesBefore(parentNode, [currentText], marker);
-    currentNodes = [currentText];
-  };
-  const dispose = createRenderEffect(() => {
-    const value = getValue();
-    const parentNode = marker.parentNode;
-    const isPrimitive = value == null || value === false || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-    if (isPrimitive) {
-      if (currentRoot2) {
-        destroyRoot(currentRoot2);
-        currentRoot2 = null;
-      }
-      if (!parentNode) {
-        clearCurrentNodes();
-        return;
-      }
-      const textValue = value == null || value === false ? "" : String(value);
-      const shouldInsert = value != null && value !== false;
-      setTextNode(textValue, shouldInsert, parentNode);
-      return;
-    }
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-      currentRoot2 = null;
-    }
-    clearCurrentNodes();
-    const root = createRootContext(hostRoot);
-    const prev = pushRoot(root);
-    let nodes = [];
-    try {
-      let newNode;
-      if (value instanceof Node) {
-        newNode = value;
-      } else if (Array.isArray(value)) {
-        if (value.every((v) => v instanceof Node)) {
-          newNode = value;
-        } else {
-          if (createFn) {
-            const mapped = [];
-            for (const item of value) {
-              mapped.push(...toNodeArray(createFn(item)));
-            }
-            newNode = mapped;
-          } else {
-            newNode = document.createTextNode(String(value));
-          }
-        }
-      } else {
-        newNode = createFn ? createFn(value) : document.createTextNode(String(value));
-      }
-      nodes = toNodeArray(newNode);
-      if (parentNode) {
-        insertNodesBefore(parentNode, nodes, marker);
-      }
-    } finally {
-      popRoot(prev);
-      flushOnMount(root);
-    }
-    currentRoot2 = root;
-    currentNodes = nodes;
-  });
-  return () => {
-    dispose();
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-      currentRoot2 = null;
-    }
-    clearCurrentNodes();
-    if (ownsMarker) {
-      marker.parentNode?.removeChild(marker);
-    }
-  };
-}
-function createChildBinding(parent, getValue, createElementFn) {
-  const marker = document.createComment("fict:child");
-  parent.appendChild(marker);
-  const hostRoot = getCurrentRoot();
-  const dispose = createRenderEffect(() => {
-    const root = createRootContext(hostRoot);
-    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) {
-  const asNode = (value) => value && typeof value.nodeType === "number" ? value : null;
-  const asElement = (value) => {
-    const n = asNode(value);
-    if (!n) return null;
-    if (n.nodeType === 1) return n;
-    return n.parentElement;
-  };
-  let node = asElement(e.target);
-  const key = `$$${e.type}`;
-  const dataKey = `${key}Data`;
-  const oriTarget = e.target;
-  const oriCurrentTarget = e.currentTarget;
-  let lastHandled = null;
-  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;
-      batch2(() => {
-        if (typeof handler === "function") {
-          callEventHandler(handler, e, node, hasData ? resolvedNodeData : void 0);
-        } else if (Array.isArray(handler)) {
-          const tupleData = resolveData(handler[1]);
-          callEventHandler(handler[0], e, node, tupleData);
-        }
-      });
-      if (e.cancelBubble) return false;
-    }
-    const shadowHost = node.host;
-    if (shadowHost && typeof shadowHost !== "string" && !shadowHost._$host && (() => {
-      const targetNode = asNode(e.target);
-      return targetNode ? node.contains(targetNode) : false;
-    })()) {
-      retarget(shadowHost);
-    }
-    return true;
-  };
-  const walkUpTree = () => {
-    while (handleNode() && node) {
-      node = asElement(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++) {
-      const nextNode = asElement(path[i]);
-      if (!nextNode || nextNode === lastHandled) continue;
-      node = nextNode;
-      if (!handleNode()) break;
-      lastHandled = node;
-      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 resolveHandler = isReactive(handler) ? handler : () => handler;
-    el[key] = function(...args) {
-      try {
-        const fn = resolveHandler();
-        callEventHandler(fn, args[0], el);
-      } catch (err) {
-        if (!handleError(err, { source: "event", eventName }, rootRef)) {
-          throw err;
-        }
-      }
-    };
-    return () => {
-      el[key] = void 0;
-    };
-  }
-  const getHandler = isReactive(handler) ? handler : () => handler;
-  const wrapped = (event) => {
-    try {
-      const resolved = getHandler();
-      callEventHandler(resolved, event, el);
-    } catch (err) {
-      if (handleError(err, { source: "event", eventName }, rootRef)) {
-        return;
-      }
-      throw err;
-    }
-  };
-  el.addEventListener(eventName, wrapped, 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[toPropertyName2(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 toPropertyName2(name) {
-  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
-}
-function createConditional(condition, renderTrue, createElementFn, renderFalse) {
-  const startMarker = document.createComment("fict:cond:start");
-  const endMarker = document.createComment("fict:cond:end");
-  const fragment = document.createDocumentFragment();
-  fragment.append(startMarker, endMarker);
-  const hostRoot = getCurrentRoot();
-  let currentNodes = [];
-  let currentRoot2 = null;
-  let lastCondition = void 0;
-  let pendingRender = false;
-  const conditionMemo = computed(condition);
-  const runConditional = () => {
-    const cond = conditionMemo();
-    const parent = startMarker.parentNode;
-    if (!parent) {
-      pendingRender = true;
-      return;
-    }
-    pendingRender = false;
-    if (lastCondition === cond && currentNodes.length > 0) {
-      return;
-    }
-    if (lastCondition === cond && lastCondition === false && renderFalse === void 0) {
-      return;
-    }
-    lastCondition = cond;
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-      currentRoot2 = null;
-    }
-    removeNodes(currentNodes);
-    currentNodes = [];
-    const render2 = cond ? renderTrue : renderFalse;
-    if (!render2) {
-      return;
-    }
-    const root = createRootContext(hostRoot);
-    const prev = pushRoot(root);
-    let handledError = false;
-    try {
-      const output = untrack(render2);
-      if (output == null || output === false) {
-        return;
-      }
-      const el = createElementFn(output);
-      const nodes = toNodeArray(el);
-      insertNodesBefore(parent, nodes, endMarker);
-      currentNodes = nodes;
-    } catch (err) {
-      if (handleSuspend(err, root)) {
-        handledError = true;
-        destroyRoot(root);
-        return;
-      }
-      if (handleError(err, { source: "renderChild" }, root)) {
-        handledError = true;
-        destroyRoot(root);
-        return;
-      }
-      throw err;
-    } finally {
-      popRoot(prev);
-      if (!handledError) {
-        flushOnMount(root);
-        currentRoot2 = root;
-      } else {
-        currentRoot2 = null;
-      }
-    }
-  };
-  const dispose = createRenderEffect(runConditional);
-  return {
-    marker: fragment,
-    flush: () => {
-      if (pendingRender) {
-        runConditional();
-      }
-    },
-    dispose: () => {
-      dispose();
-      if (currentRoot2) {
-        destroyRoot(currentRoot2);
-      }
-      removeNodes(currentNodes);
-      currentNodes = [];
-      startMarker.parentNode?.removeChild(startMarker);
-      endMarker.parentNode?.removeChild(endMarker);
-    }
-  };
-}
-function createList(items, renderItem, createElementFn, getKey) {
-  const startMarker = document.createComment("fict:list:start");
-  const endMarker = document.createComment("fict:list:end");
-  const fragment = document.createDocumentFragment();
-  fragment.append(startMarker, endMarker);
-  const hostRoot = getCurrentRoot();
-  const nodeMap = /* @__PURE__ */ new Map();
-  let pendingItems = null;
-  const runListUpdate = () => {
-    const arr = items();
-    const parent = startMarker.parentNode;
-    if (!parent) {
-      pendingItems = arr;
-      return;
-    }
-    pendingItems = null;
-    const newNodeMap = /* @__PURE__ */ new Map();
-    const blocks = [];
-    for (let i = 0; i < arr.length; i++) {
-      const item = arr[i];
-      const key = getKey ? getKey(item, i) : i;
-      const existing = nodeMap.get(key);
-      let block;
-      if (existing) {
-        const previousValue = existing.value();
-        if (!getKey && previousValue !== item) {
-          destroyRoot(existing.root);
-          removeBlockNodes(existing);
-          block = mountBlock(item, i, renderItem, parent, endMarker, createElementFn, hostRoot);
-        } else {
-          const previousIndex = existing.index();
-          existing.value(item);
-          existing.index(i);
-          const needsRerender = getKey ? true : previousValue !== item || previousIndex !== i;
-          block = needsRerender ? rerenderBlock(existing, createElementFn) : existing;
-        }
-      } else {
-        block = mountBlock(item, i, renderItem, parent, endMarker, createElementFn, hostRoot);
-      }
-      newNodeMap.set(key, block);
-      blocks.push(block);
-    }
-    for (const [key, managed] of nodeMap) {
-      if (!newNodeMap.has(key)) {
-        destroyRoot(managed.root);
-        removeBlockNodes(managed);
-      }
-    }
-    let anchor = endMarker;
-    for (let i = blocks.length - 1; i >= 0; i--) {
-      const block = blocks[i];
-      insertNodesBefore(parent, block.nodes, anchor);
-      if (block.nodes.length > 0) {
-        anchor = block.nodes[0];
-      }
-    }
-    nodeMap.clear();
-    for (const [k, v] of newNodeMap) {
-      nodeMap.set(k, v);
-    }
-  };
-  const dispose = createRenderEffect(runListUpdate);
-  return {
-    marker: fragment,
-    flush: () => {
-      if (pendingItems !== null) {
-        runListUpdate();
-      }
-    },
-    dispose: () => {
-      dispose();
-      for (const [, managed] of nodeMap) {
-        destroyRoot(managed.root);
-        removeBlockNodes(managed);
-      }
-      nodeMap.clear();
-      startMarker.parentNode?.removeChild(startMarker);
-      endMarker.parentNode?.removeChild(endMarker);
-    }
-  };
-}
-function 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(parentRoot);
-    const prev = pushRoot(root);
-    let handledError = false;
-    try {
-      const output = render2();
-      if (output != null && output !== false) {
-        const el = createElementFn(output);
-        const nodes = toNodeArray(el);
-        if (marker.parentNode) {
-          insertNodesBefore(marker.parentNode, nodes, marker);
-        }
-        currentNodes = nodes;
-      }
-    } catch (err) {
-      if (handleSuspend(err, root)) {
-        handledError = true;
-        destroyRoot(root);
-        currentNodes = [];
-        return;
-      }
-      if (handleError(err, { source: "renderChild" }, root)) {
-        handledError = true;
-        destroyRoot(root);
-        currentNodes = [];
-        return;
-      }
-      throw err;
-    } finally {
-      popRoot(prev);
-      if (!handledError) {
-        flushOnMount(root);
-        currentRoot2 = root;
-      } else {
-        currentRoot2 = null;
-      }
-    }
-  });
-  const portalDispose = () => {
-    dispose();
-    if (currentRoot2) {
-      destroyRoot(currentRoot2);
-    }
-    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, hostRoot) {
-  const start = document.createComment("fict:block:start");
-  const end = document.createComment("fict:block:end");
-  const valueSig = createVersionedSignalAccessor(initialValue);
-  const indexSig = signal(initialIndex);
-  const renderCurrent = () => renderItem(valueSig, indexSig);
-  const root = createRootContext(hostRoot);
-  const prev = pushRoot(root);
-  const nodes = [start];
-  let handledError = false;
-  try {
-    const output = renderCurrent();
-    if (output != null && output !== false) {
-      const el = createElementFn(output);
-      const rendered = toNodeArray(el);
-      nodes.push(...rendered);
-    }
-    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,
-    start,
-    end,
-    renderCurrent
-  };
-}
-function rerenderBlock(block, createElementFn) {
-  const currentContent = block.nodes.slice(1, Math.max(1, block.nodes.length - 1));
-  const currentNode = currentContent.length === 1 ? currentContent[0] : null;
-  clearRoot(block.root);
-  const prev = pushRoot(block.root);
-  let nextOutput;
-  let handledError = false;
-  try {
-    nextOutput = block.renderCurrent();
-  } catch (err) {
-    if (handleSuspend(err, block.root)) {
-      handledError = true;
-      popRoot(prev);
-      destroyRoot(block.root);
-      block.nodes = [block.start, block.end];
-      return block;
-    }
-    if (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;
-  }
-}
 
-// src/scope.ts
-function createScope() {
-  let dispose = null;
-  const stop = () => {
-    if (dispose) {
-      dispose();
-      dispose = null;
-    }
-  };
-  const run = (fn) => {
-    stop();
-    const { dispose: rootDispose, value } = createRoot(fn);
-    dispose = rootDispose;
-    return value;
-  };
-  registerRootCleanup(stop);
-  return { run, stop };
-}
-function runInScope(flag, fn) {
-  const scope = createScope();
-  const evaluate = () => isReactive(flag) ? flag() : !!flag;
-  createEffect(() => {
-    const enabled = evaluate();
-    if (enabled) {
-      scope.run(fn);
-    } else {
-      scope.stop();
-    }
-  });
-  onCleanup(scope.stop);
-}
 
-// src/versioned-signal.ts
-function createVersionedSignal(initialValue, options2) {
-  const equals = options2?.equals ?? Object.is;
-  const value = signal(initialValue);
-  const version = signal(0);
-  const bumpVersion = () => {
-    const next = version() + 1;
-    version(next);
-  };
-  return {
-    read: () => {
-      version();
-      return value();
-    },
-    write: (next) => {
-      const prev = value();
-      if (!equals(prev, next)) {
-        value(next);
-        return;
-      }
-      bumpVersion();
-    },
-    force: () => {
-      bumpVersion();
-    },
-    peekVersion: () => version(),
-    peekValue: () => value()
-  };
-}
+
+
+
+
+
+
+
+
+var _chunkPMF6MWEVcjs = require('./chunk-PMF6MWEV.cjs');
 
 // src/ref.ts
 function createRef() {
@@ -4309,8 +46,8 @@ function ErrorBoundary(props) {
   const fragment = document.createDocumentFragment();
   const marker = document.createComment("fict:error-boundary");
   fragment.appendChild(marker);
-  const currentView = signal(props.children ?? null);
-  const hostRoot = getCurrentRoot();
+  const currentView = _chunkPMF6MWEVcjs.signal.call(void 0, _nullishCoalesce(props.children, () => ( null)));
+  const hostRoot = _chunkPMF6MWEVcjs.getCurrentRoot.call(void 0, );
   let cleanup;
   let activeNodes = [];
   let renderingFallback = false;
@@ -4318,7 +55,7 @@ function ErrorBoundary(props) {
     if (err != null) {
       return typeof props.fallback === "function" ? props.fallback(err) : props.fallback;
     }
-    return props.children ?? null;
+    return _nullishCoalesce(props.children, () => ( null));
   };
   const renderValue = (value) => {
     if (cleanup) {
@@ -4326,26 +63,26 @@ function ErrorBoundary(props) {
       cleanup = void 0;
     }
     if (activeNodes.length) {
-      removeNodes(activeNodes);
+      _chunkPMF6MWEVcjs.removeNodes.call(void 0, activeNodes);
       activeNodes = [];
     }
     if (value == null || value === false) {
       return;
     }
-    const root = createRootContext(hostRoot);
-    const prev = pushRoot(root);
+    const root = _chunkPMF6MWEVcjs.createRootContext.call(void 0, hostRoot);
+    const prev = _chunkPMF6MWEVcjs.pushRoot.call(void 0, root);
     let nodes = [];
     try {
-      const output = createElement(value);
-      nodes = toNodeArray(output);
+      const output = _chunkPMF6MWEVcjs.createElement.call(void 0, value);
+      nodes = _chunkPMF6MWEVcjs.toNodeArray.call(void 0, output);
       const parentNode = marker.parentNode;
       if (parentNode) {
-        insertNodesBefore(parentNode, nodes, marker);
+        _chunkPMF6MWEVcjs.insertNodesBefore.call(void 0, parentNode, nodes, marker);
       }
     } catch (err) {
-      popRoot(prev);
-      flushOnMount(root);
-      destroyRoot(root);
+      _chunkPMF6MWEVcjs.popRoot.call(void 0, prev);
+      _chunkPMF6MWEVcjs.flushOnMount.call(void 0, root);
+      _chunkPMF6MWEVcjs.destroyRoot.call(void 0, root);
       if (renderingFallback) {
         throw err;
       }
@@ -4353,35 +90,35 @@ function ErrorBoundary(props) {
       try {
         renderValue(toView(err));
         renderingFallback = false;
-        props.onError?.(err);
+        _optionalChain([props, 'access', _ => _.onError, 'optionalCall', _2 => _2(err)]);
       } catch (fallbackErr) {
-        props.onError?.(err);
+        _optionalChain([props, 'access', _3 => _3.onError, 'optionalCall', _4 => _4(err)]);
         throw fallbackErr;
       }
       return;
     }
-    popRoot(prev);
-    flushOnMount(root);
+    _chunkPMF6MWEVcjs.popRoot.call(void 0, prev);
+    _chunkPMF6MWEVcjs.flushOnMount.call(void 0, root);
     cleanup = () => {
-      destroyRoot(root);
-      removeNodes(nodes);
+      _chunkPMF6MWEVcjs.destroyRoot.call(void 0, root);
+      _chunkPMF6MWEVcjs.removeNodes.call(void 0, nodes);
     };
     activeNodes = nodes;
   };
-  createEffect(() => {
+  _chunkPMF6MWEVcjs.createEffect.call(void 0, () => {
     const value = currentView();
     renderValue(value);
   });
-  registerErrorHandler((err) => {
+  _chunkPMF6MWEVcjs.registerErrorHandler.call(void 0, (err) => {
     renderValue(toView(err));
-    props.onError?.(err);
+    _optionalChain([props, 'access', _5 => _5.onError, 'optionalCall', _6 => _6(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(() => {
+    _chunkPMF6MWEVcjs.createEffect.call(void 0, () => {
       const next = getter ? getter() : props.resetKeys;
       if (prev !== next) {
         prev = next;
@@ -4410,11 +147,11 @@ function createSuspenseToken() {
 }
 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);
+  const currentView = _chunkPMF6MWEVcjs.signal.call(void 0, _nullishCoalesce(props.children, () => ( null)));
+  const pending = _chunkPMF6MWEVcjs.signal.call(void 0, 0);
   let resolvedOnce = false;
   let epoch = 0;
-  const hostRoot = getCurrentRoot();
+  const hostRoot = _chunkPMF6MWEVcjs.getCurrentRoot.call(void 0, );
   const toFallback = (err) => typeof props.fallback === "function" ? props.fallback(err) : props.fallback;
   const switchView = (view) => {
     currentView(view);
@@ -4426,42 +163,42 @@ function Suspense(props) {
       cleanup = void 0;
     }
     if (activeNodes.length) {
-      removeNodes(activeNodes);
+      _chunkPMF6MWEVcjs.removeNodes.call(void 0, activeNodes);
       activeNodes = [];
     }
     if (view == null || view === false) {
       return;
     }
-    const root = createRootContext(hostRoot);
-    const prev = pushRoot(root);
+    const root = _chunkPMF6MWEVcjs.createRootContext.call(void 0, hostRoot);
+    const prev = _chunkPMF6MWEVcjs.pushRoot.call(void 0, root);
     let nodes = [];
     try {
-      const output = createElement(view);
-      nodes = toNodeArray(output);
+      const output = _chunkPMF6MWEVcjs.createElement.call(void 0, view);
+      nodes = _chunkPMF6MWEVcjs.toNodeArray.call(void 0, output);
       const suspendedAttempt = nodes.length > 0 && nodes.every((node) => node instanceof Comment && node.data === "fict:suspend");
       if (suspendedAttempt) {
-        popRoot(prev);
-        destroyRoot(root);
+        _chunkPMF6MWEVcjs.popRoot.call(void 0, prev);
+        _chunkPMF6MWEVcjs.destroyRoot.call(void 0, root);
         return;
       }
       const parentNode = marker.parentNode;
       if (parentNode) {
-        insertNodesBefore(parentNode, nodes, marker);
+        _chunkPMF6MWEVcjs.insertNodesBefore.call(void 0, parentNode, nodes, marker);
       }
     } catch (err) {
-      popRoot(prev);
-      flushOnMount(root);
-      destroyRoot(root);
-      if (!handleError(err, { source: "render" }, hostRoot)) {
+      _chunkPMF6MWEVcjs.popRoot.call(void 0, prev);
+      _chunkPMF6MWEVcjs.flushOnMount.call(void 0, root);
+      _chunkPMF6MWEVcjs.destroyRoot.call(void 0, root);
+      if (!_chunkPMF6MWEVcjs.handleError.call(void 0, err, { source: "render" }, hostRoot)) {
         throw err;
       }
       return;
     }
-    popRoot(prev);
-    flushOnMount(root);
+    _chunkPMF6MWEVcjs.popRoot.call(void 0, prev);
+    _chunkPMF6MWEVcjs.flushOnMount.call(void 0, root);
     cleanup = () => {
-      destroyRoot(root);
-      removeNodes(nodes);
+      _chunkPMF6MWEVcjs.destroyRoot.call(void 0, root);
+      _chunkPMF6MWEVcjs.removeNodes.call(void 0, nodes);
     };
     activeNodes = nodes;
   };
@@ -4473,10 +210,10 @@ function Suspense(props) {
   const onResolveMaybe = () => {
     if (!resolvedOnce) {
       resolvedOnce = true;
-      props.onResolve?.();
+      _optionalChain([props, 'access', _7 => _7.onResolve, 'optionalCall', _8 => _8()]);
     }
   };
-  registerSuspenseHandler((token) => {
+  _chunkPMF6MWEVcjs.registerSuspenseHandler.call(void 0, (token) => {
     const tokenEpoch = epoch;
     pending(pending() + 1);
     switchView(toFallback());
@@ -4490,7 +227,7 @@ function Suspense(props) {
           const newPending = Math.max(0, pending() - 1);
           pending(newPending);
           if (newPending === 0) {
-            switchView(props.children ?? null);
+            switchView(_nullishCoalesce(props.children, () => ( null)));
             onResolveMaybe();
           }
         },
@@ -4500,8 +237,8 @@ function Suspense(props) {
           }
           const newPending = Math.max(0, pending() - 1);
           pending(newPending);
-          props.onReject?.(err);
-          if (!handleError(err, { source: "render" }, hostRoot)) {
+          _optionalChain([props, 'access', _9 => _9.onReject, 'optionalCall', _10 => _10(err)]);
+          if (!_chunkPMF6MWEVcjs.handleError.call(void 0, err, { source: "render" }, hostRoot)) {
             throw err;
           }
         }
@@ -4510,119 +247,49 @@ function Suspense(props) {
     }
     return false;
   });
-  createEffect(() => {
+  _chunkPMF6MWEVcjs.createEffect.call(void 0, () => {
     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(() => {
+    _chunkPMF6MWEVcjs.createEffect.call(void 0, () => {
       const next = getter ? getter() : props.resetKeys;
       if (prev !== next) {
         prev = next;
         epoch++;
         pending(0);
-        switchView(props.children ?? null);
+        switchView(_nullishCoalesce(props.children, () => ( null)));
       }
     });
   }
   return fragment;
 }
 
-exports.$effect = $effect;
-exports.$memo = $memo;
-exports.$state = $state;
-exports.Aliases = Aliases;
-exports.BooleanAttributes = BooleanAttributes;
-exports.ChildProperties = ChildProperties;
-exports.DelegatedEvents = DelegatedEvents;
-exports.ErrorBoundary = ErrorBoundary;
-exports.Fragment = Fragment;
-exports.Properties = Properties;
-exports.SVGElements = SVGElements;
-exports.SVGNamespace = SVGNamespace;
-exports.Suspense = Suspense;
-exports.UnitlessStyles = UnitlessStyles;
-exports.__fictPopContext = __fictPopContext;
-exports.__fictProp = __fictProp;
-exports.__fictPropsRest = __fictPropsRest;
-exports.__fictPushContext = __fictPushContext;
-exports.__fictRender = __fictRender;
-exports.__fictResetContext = __fictResetContext;
-exports.__fictUseContext = __fictUseContext;
-exports.__fictUseEffect = __fictUseEffect;
-exports.__fictUseMemo = __fictUseMemo;
-exports.__fictUseSignal = __fictUseSignal;
-exports.addEventListener = addEventListener;
-exports.assign = assign;
-exports.batch = batch2;
-exports.bindAttribute = bindAttribute;
-exports.bindClass = bindClass;
-exports.bindEvent = bindEvent;
-exports.bindProperty = bindProperty;
-exports.bindRef = bindRef;
-exports.bindStyle = bindStyle;
-exports.bindText = bindText;
-exports.callEventHandler = callEventHandler;
-exports.classList = classList;
-exports.clearDelegatedEvents = clearDelegatedEvents;
-exports.createAttributeBinding = createAttributeBinding;
-exports.createChildBinding = createChildBinding;
-exports.createClassBinding = createClassBinding;
-exports.createConditional = createConditional;
-exports.createEffect = createEffect;
-exports.createElement = createElement;
-exports.createKeyedBlock = createKeyedBlock;
-exports.createKeyedList = createKeyedList;
-exports.createKeyedListContainer = createKeyedListContainer;
-exports.createList = createList;
-exports.createMemo = createMemo;
-exports.createPortal = createPortal;
-exports.createPropsProxy = createPropsProxy;
-exports.createRef = createRef;
-exports.createRenderEffect = createRenderEffect;
-exports.createRoot = createRoot;
-exports.createScope = createScope;
-exports.createSelector = createSelector;
-exports.createShow = createShow;
-exports.createSignal = signal;
-exports.createStore = createStore;
-exports.createStyleBinding = createStyleBinding;
-exports.createSuspenseToken = createSuspenseToken;
-exports.createTextBinding = createTextBinding;
-exports.createVersionedSignal = createVersionedSignal;
-exports.delegateEvents = delegateEvents;
-exports.destroyMarkerBlock = destroyMarkerBlock;
-exports.effectScope = effectScope;
-exports.getDevtoolsHook = getDevtoolsHook;
-exports.getFirstNodeAfter = getFirstNodeAfter;
-exports.getPropAlias = getPropAlias;
-exports.insert = insert;
-exports.insertNodesBefore = insertNodesBefore;
-exports.isNodeBetweenMarkers = isNodeBetweenMarkers;
-exports.isReactive = isReactive;
-exports.mergeProps = mergeProps;
-exports.moveMarkerBlock = moveMarkerBlock;
-exports.moveNodesBefore = moveNodesBefore;
-exports.onCleanup = onCleanup;
-exports.onDestroy = onDestroy;
-exports.onMount = onMount;
-exports.prop = __fictProp;
-exports.reconcileArrays = reconcileArrays;
-exports.removeNodes = removeNodes;
-exports.render = render;
-exports.runInScope = runInScope;
-exports.setCycleProtectionOptions = setCycleProtectionOptions;
-exports.spread = spread;
-exports.startTransition = startTransition;
-exports.template = template;
-exports.toNodeArray = toNodeArray;
-exports.untrack = untrack2;
-exports.unwrap = unwrap2;
-exports.unwrapPrimitive = unwrapPrimitive;
-exports.useDeferredValue = useDeferredValue;
-exports.useProp = useProp;
-exports.useTransition = useTransition;
-//# sourceMappingURL=index.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ErrorBoundary = ErrorBoundary; exports.Fragment = _chunkPMF6MWEVcjs.Fragment; exports.Suspense = Suspense; exports.batch = _chunkPMF6MWEVcjs.batch2; exports.createContext = _chunkGJTYOFMOcjs.createContext; exports.createEffect = _chunkPMF6MWEVcjs.createEffect; exports.createElement = _chunkPMF6MWEVcjs.createElement; exports.createMemo = _chunkPMF6MWEVcjs.createMemo; exports.createPortal = _chunkPMF6MWEVcjs.createPortal; exports.createRef = createRef; exports.createRoot = _chunkPMF6MWEVcjs.createRoot; exports.createSuspenseToken = createSuspenseToken; exports.hasContext = _chunkGJTYOFMOcjs.hasContext; exports.mergeProps = _chunkPMF6MWEVcjs.mergeProps; exports.onCleanup = _chunkPMF6MWEVcjs.onCleanup; exports.onDestroy = _chunkPMF6MWEVcjs.onDestroy; exports.onMount = _chunkPMF6MWEVcjs.onMount; exports.prop = _chunkPMF6MWEVcjs.prop; exports.render = _chunkPMF6MWEVcjs.render; exports.startTransition = _chunkPMF6MWEVcjs.startTransition; exports.untrack = _chunkPMF6MWEVcjs.untrack2; exports.useContext = _chunkGJTYOFMOcjs.useContext; exports.useDeferredValue = _chunkPMF6MWEVcjs.useDeferredValue; exports.useTransition = _chunkPMF6MWEVcjs.useTransition;
 //# sourceMappingURL=index.cjs.map