@fictjs/runtime 0.0.13 → 0.0.15

package/dist/chunk-RY4WDS6R.js

@@ -0,0 +1,3301 @@
+// src/delegated-events.ts
+var DelegatedEventNames = [
+  "beforeinput",
+  "click",
+  "dblclick",
+  "contextmenu",
+  "focusin",
+  "focusout",
+  "input",
+  "keydown",
+  "keyup",
+  "mousedown",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup",
+  "pointerdown",
+  "pointermove",
+  "pointerout",
+  "pointerover",
+  "pointerup",
+  "touchend",
+  "touchmove",
+  "touchstart"
+];
+
+// src/constants.ts
+var isDev = true ? false : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var booleans = isDev ? [
+  "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 = isDev ? [
+  // 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 Properties = new Set(properties);
+var ChildProperties = /* @__PURE__ */ new Set([
+  "innerHTML",
+  "textContent",
+  "innerText",
+  "children"
+]);
+var Aliases = {
+  className: "class",
+  htmlFor: "for"
+};
+var PropAliases = isDev ? {
+  // 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(prop2, tagName) {
+  if (!isDev) return void 0;
+  const a = PropAliases[prop2];
+  if (typeof a === "object") {
+    return a[tagName] ? a["$"] : void 0;
+  }
+  return a;
+}
+var $$EVENTS = "_$FICT_DELEGATE";
+var delegatedEvents = isDev ? DelegatedEventNames : [];
+var DelegatedEvents = new Set(delegatedEvents);
+var svgElements = isDev ? [
+  "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 SVGElements = new Set(svgElements);
+var SVGNamespace = {
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace"
+};
+var unitlessList = isDev ? [
+  "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"
+] : ["opacity", "zIndex"];
+var UnitlessStyles = new Set(unitlessList);
+
+// 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 isDev2 = true ? false : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var setCycleProtectionOptions = () => {
+};
+var resetCycleProtectionStateForTests = () => {
+};
+var beginFlushGuard = () => {
+};
+var beforeEffectRunGuard = () => true;
+var endFlushGuard = () => {
+};
+var enterRootGuard = () => true;
+var exitRootGuard = () => {
+};
+if (isDev2) {
+  const defaultOptions = {
+    maxFlushCyclesPerMicrotask: 1e4,
+    maxEffectRunsPerFlush: 2e4,
+    windowSize: 5,
+    highUsageRatio: 0.8,
+    maxRootReentrantDepth: 10,
+    enableWindowWarning: true,
+    devMode: false
+  };
+  let options = {
+    ...defaultOptions
+  };
+  let effectRunsThisFlush = 0;
+  let windowUsage = [];
+  let rootDepth = /* @__PURE__ */ new WeakMap();
+  let flushWarned = false;
+  let rootWarned = false;
+  let windowWarned = false;
+  setCycleProtectionOptions = (opts) => {
+    options = { ...options, ...opts };
+  };
+  resetCycleProtectionStateForTests = () => {
+    options = { ...defaultOptions };
+    effectRunsThisFlush = 0;
+    windowUsage = [];
+    rootDepth = /* @__PURE__ */ new WeakMap();
+    flushWarned = false;
+    rootWarned = false;
+    windowWarned = false;
+  };
+  beginFlushGuard = () => {
+    effectRunsThisFlush = 0;
+    flushWarned = false;
+    windowWarned = false;
+  };
+  beforeEffectRunGuard = () => {
+    const next = ++effectRunsThisFlush;
+    if (next > options.maxFlushCyclesPerMicrotask || next > options.maxEffectRunsPerFlush) {
+      const message = `[fict] cycle protection triggered: flush-budget-exceeded`;
+      if (options.devMode) {
+        throw new Error(message);
+      }
+      if (!flushWarned) {
+        flushWarned = true;
+        console.warn(message, { effectRuns: next });
+      }
+      return false;
+    }
+    return true;
+  };
+  endFlushGuard = () => {
+    recordWindowUsage(effectRunsThisFlush, options.maxFlushCyclesPerMicrotask);
+    effectRunsThisFlush = 0;
+  };
+  enterRootGuard = (root) => {
+    const depth = (rootDepth.get(root) ?? 0) + 1;
+    if (depth > options.maxRootReentrantDepth) {
+      const message = `[fict] cycle protection triggered: root-reentry`;
+      if (options.devMode) {
+        throw new Error(message);
+      }
+      if (!rootWarned) {
+        rootWarned = true;
+        console.warn(message, { depth });
+      }
+      return false;
+    }
+    rootDepth.set(root, depth);
+    return true;
+  };
+  exitRootGuard = (root) => {
+    const depth = rootDepth.get(root);
+    if (depth === void 0) return;
+    if (depth <= 1) {
+      rootDepth.delete(root);
+    } else {
+      rootDepth.set(root, depth - 1);
+    }
+  };
+  const recordWindowUsage = (used, budget) => {
+    if (!options.enableWindowWarning) return;
+    const entry = { used, budget };
+    windowUsage.push(entry);
+    if (windowUsage.length > options.windowSize) {
+      windowUsage.shift();
+    }
+    if (windowWarned) return;
+    if (windowUsage.length >= options.windowSize && windowUsage.every(
+      (item) => item.budget > 0 && item.used / item.budget >= options.highUsageRatio
+    )) {
+      windowWarned = true;
+      reportCycle("high-usage-window", {
+        windowSize: options.windowSize,
+        ratio: options.highUsageRatio
+      });
+    }
+  };
+  const reportCycle = (reason, detail = void 0) => {
+    const hook = getDevtoolsHook();
+    hook?.cycleDetected?.(detail ? { reason, detail } : { reason });
+    console.warn(`[fict] cycle protection triggered: ${reason}`, detail ?? "");
+  };
+}
+
+// src/lifecycle.ts
+var isDev3 = true ? false : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+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) {
+    const message = isDev3 ? "registerErrorHandler must be called within a root" : "FICT:E_ROOT_HANDLER";
+    throw new Error(message);
+  }
+  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) {
+    const message = isDev3 ? "registerSuspenseHandler must be called within a root" : "FICT:E_ROOT_SUSPENSE";
+    throw new Error(message);
+  }
+  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 isDev4 = true ? false : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var Mutable = 1;
+var Watching = 2;
+var Running = 4;
+var Recursed = 8;
+var Dirty = 16;
+var Pending = 32;
+var MutableDirty = 17;
+var MutablePending = 33;
+var MutableRunning = 5;
+var WatchingRunning = 6;
+var cycle = 0;
+var batchDepth = 0;
+var activeSub;
+var flushScheduled = false;
+var highPriorityQueue = [];
+var lowPriorityQueue = [];
+var isInTransition = false;
+var enqueueMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => {
+  Promise.resolve().then(fn);
+};
+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 & ~Recursed | Pending;
+    } else if (!(flags & 48)) {
+      let vlink = sub.depsTail;
+      let valid = false;
+      while (vlink !== void 0) {
+        if (vlink === link2) {
+          valid = true;
+          break;
+        }
+        vlink = vlink.prevDep;
+      }
+      if (valid) {
+        sub.flags = flags | 40;
+        flags &= Mutable;
+      } else {
+        flags = 0;
+      }
+    } else {
+      flags = 0;
+    }
+    if (flags & Watching) notify(sub);
+    if (flags & Mutable) {
+      const subSubs = sub.subs;
+      if (subSubs !== void 0) {
+        const nextSub = subSubs.nextSub;
+        if (nextSub !== void 0) {
+          stack = { value: next, prev: stack };
+          next = nextSub;
+        }
+        link2 = subSubs;
+        continue;
+      }
+    }
+    if (next !== void 0) {
+      link2 = next;
+      next = link2.nextSub;
+      continue;
+    }
+    while (stack !== void 0) {
+      link2 = stack.value;
+      stack = stack.prev;
+      if (link2 !== void 0) {
+        next = link2.nextSub;
+        continue top;
+      }
+    }
+    break;
+  }
+}
+function checkDirty(firstLink, sub) {
+  let link2 = firstLink;
+  let stack;
+  let checkDepth = 0;
+  let dirty = false;
+  top: for (; ; ) {
+    const dep = link2.dep;
+    const depFlags = dep.flags;
+    if (sub.flags & Dirty) {
+      dirty = true;
+    } else if ((depFlags & MutableDirty) === MutableDirty) {
+      if (update(dep)) {
+        const subs = dep.subs;
+        if (subs !== void 0 && subs.nextSub !== void 0) shallowPropagate(subs);
+        dirty = true;
+      }
+    } else if ((depFlags & MutablePending) === MutablePending) {
+      if (!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 result;
+  let error;
+  try {
+    result = fn();
+  } catch (e) {
+    error = e;
+  } finally {
+    --batchDepth;
+    if (batchDepth === 0) {
+      try {
+        flush();
+      } catch (flushErr) {
+        if (error === void 0) {
+          error = flushErr;
+        }
+      }
+    }
+  }
+  if (error !== void 0) {
+    throw error;
+  }
+  return result;
+}
+function setActiveSub(sub) {
+  const prev = activeSub;
+  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 registerSignalDevtools = () => void 0;
+var updateSignalDevtools = () => {
+};
+var registerEffectDevtools = () => void 0;
+var effectRunDevtools = () => {
+};
+if (isDev4) {
+  let devtoolsSignalId = 0;
+  let devtoolsEffectId = 0;
+  registerSignalDevtools = (value, node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return void 0;
+    const id = ++devtoolsSignalId;
+    hook.registerSignal(id, value);
+    node.__id = id;
+    return id;
+  };
+  updateSignalDevtools = (node, value) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return;
+    const id = node.__id;
+    if (id) hook.updateSignal(id, value);
+  };
+  registerEffectDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return void 0;
+    const id = ++devtoolsEffectId;
+    hook.registerEffect(id);
+    node.__id = id;
+    return id;
+  };
+  effectRunDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return;
+    const id = node.__id;
+    if (id) hook.effectRun(id);
+  };
+}
+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/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;
+}
+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/jsx.ts
+var Fragment = Symbol("Fragment");
+
+// 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/transition.ts
+function startTransition(fn) {
+  const prev = setTransitionContext(true);
+  try {
+    fn();
+  } finally {
+    setTransitionContext(prev);
+    scheduleFlush();
+  }
+}
+function useTransition() {
+  const pending = signal(false);
+  const start = (fn) => {
+    startTransition(() => {
+      pending(true);
+      try {
+        fn();
+      } finally {
+        pending(false);
+      }
+    });
+  };
+  return [() => pending(), start];
+}
+function useDeferredValue(getValue) {
+  const deferredValue = signal(getValue());
+  createEffect(() => {
+    const newValue = getValue();
+    const currentDeferred = untrack(() => deferredValue());
+    if (currentDeferred !== newValue) {
+      startTransition(() => {
+        deferredValue(newValue);
+      });
+    }
+  });
+  return () => deferredValue();
+}
+
+// src/scheduler.ts
+function batch2(fn) {
+  return batch(fn);
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+
+// src/binding.ts
+var isDev5 = true ? false : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+function isReactive(value) {
+  return typeof value === "function" && value.length === 0;
+}
+function unwrap(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);
+}
+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 [prop2, v] of Object.entries(styles)) {
+      if (v != null) {
+        const cssProperty = prop2.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const unitless = isUnitlessStyleProperty(prop2) || isUnitlessStyleProperty(cssProperty);
+        const valueStr = typeof v === "number" && !unitless ? `${v}px` : String(v);
+        el.style.setProperty(cssProperty, valueStr);
+      } else {
+        const cssProperty = prop2.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 = "";
+    }
+  }
+}
+var isUnitlessStyleProperty = isDev5 ? (prop2) => UnitlessStyles.has(prop2) : (prop2) => prop2 === "opacity" || prop2 === "zIndex";
+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, options) {
+  if (handler == null) return () => {
+  };
+  const rootRef = getCurrentRoot();
+  if (isDev5 && DelegatedEvents.has(eventName) && !options) {
+    const key = `$$${eventName}`;
+    delegateEvents([eventName]);
+    const resolveHandler = isReactive(handler) ? handler : () => handler;
+    el[key] = function(...args) {
+      try {
+        const fn = resolveHandler();
+        callEventHandler(fn, args[0], el);
+      } catch (err) {
+        if (!handleError(err, { source: "event", eventName }, rootRef)) {
+          throw err;
+        }
+      }
+    };
+    return () => {
+      el[key] = void 0;
+    };
+  }
+  const getHandler = isReactive(handler) ? handler : () => handler;
+  const wrapped = (event) => {
+    try {
+      const resolved = getHandler();
+      callEventHandler(resolved, event, el);
+    } catch (err) {
+      if (handleError(err, { source: "event", eventName }, rootRef)) {
+        return;
+      }
+      throw err;
+    }
+  };
+  el.addEventListener(eventName, wrapped, options);
+  const cleanup = () => el.removeEventListener(eventName, wrapped, options);
+  registerRootCleanup(cleanup);
+  return cleanup;
+}
+function 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 prop2 in prevProps) {
+    if (!(prop2 in props)) {
+      if (prop2 === "children") continue;
+      prevProps[prop2] = assignProp(node, prop2, null, prevProps[prop2], isSVG, skipRef, props);
+    }
+  }
+  for (const prop2 in props) {
+    if (prop2 === "children") {
+      if (!skipChildren) {
+        prevProps.children = props.children;
+      }
+      continue;
+    }
+    const value = props[prop2];
+    prevProps[prop2] = assignProp(node, prop2, value, prevProps[prop2], isSVG, skipRef, props);
+  }
+}
+function assignProp(node, prop2, value, prev, isSVG, skipRef, props) {
+  if (prop2 === "style") {
+    applyStyle(node, value, prev);
+    return value;
+  }
+  if (prop2 === "classList") {
+    return applyClass(node, value, prev);
+  }
+  if (value === prev) return prev;
+  if (prop2 === "ref") {
+    if (!skipRef && typeof value === "function") {
+      ;
+      value(node);
+    }
+    return value;
+  }
+  if (prop2.slice(0, 3) === "on:") {
+    const eventName = prop2.slice(3);
+    if (prev) node.removeEventListener(eventName, prev);
+    if (value) node.addEventListener(eventName, value);
+    return value;
+  }
+  if (prop2.slice(0, 10) === "oncapture:") {
+    const eventName = prop2.slice(10);
+    if (prev) node.removeEventListener(eventName, prev, true);
+    if (value) node.addEventListener(eventName, value, true);
+    return value;
+  }
+  if (prop2.slice(0, 2) === "on") {
+    const eventName = prop2.slice(2).toLowerCase();
+    const shouldDelegate = isDev5 && DelegatedEvents.has(eventName);
+    if (!shouldDelegate && prev) {
+      const handler = Array.isArray(prev) ? prev[0] : prev;
+      node.removeEventListener(eventName, handler);
+    }
+    if (shouldDelegate || value) {
+      addEventListener(node, eventName, value, shouldDelegate);
+      if (shouldDelegate) delegateEvents([eventName]);
+    }
+    return value;
+  }
+  if (prop2.slice(0, 5) === "attr:") {
+    if (value == null) node.removeAttribute(prop2.slice(5));
+    else node.setAttribute(prop2.slice(5), String(value));
+    return value;
+  }
+  if (prop2.slice(0, 5) === "bool:") {
+    if (value) node.setAttribute(prop2.slice(5), "");
+    else node.removeAttribute(prop2.slice(5));
+    return value;
+  }
+  if (prop2.slice(0, 5) === "prop:") {
+    ;
+    node[prop2.slice(5)] = value;
+    return value;
+  }
+  if (prop2 === "class" || prop2 === "className") {
+    if (value == null) node.removeAttribute("class");
+    else node.className = String(value);
+    return value;
+  }
+  const isCE = node.nodeName.includes("-") || "is" in props;
+  if (!isSVG) {
+    const propAlias = isDev5 ? getPropAlias(prop2, node.tagName) : void 0;
+    const isProperty = isDev5 ? Properties.has(prop2) : prop2 in node;
+    const isChildProp = isDev5 ? ChildProperties.has(prop2) : prop2 === "innerHTML" || prop2 === "textContent" || prop2 === "innerText" || prop2 === "children";
+    if (propAlias || isProperty || isChildProp || isCE) {
+      const propName = propAlias || prop2;
+      if (isCE && !isProperty && !isChildProp && !propAlias) {
+        ;
+        node[toPropertyName(propName)] = value;
+      } else {
+        ;
+        node[propName] = value;
+      }
+      return value;
+    }
+  }
+  if (isSVG && prop2.indexOf(":") > -1) {
+    const [prefix, name] = prop2.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 = prop2 === "htmlFor" ? "for" : prop2;
+  if (value == null) node.removeAttribute(attrName);
+  else node.setAttribute(attrName, String(value));
+  return value;
+}
+function toPropertyName(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+function createConditional(condition, renderTrue, createElementFn, renderFalse) {
+  const startMarker = document.createComment("fict:cond:start");
+  const endMarker = document.createComment("fict:cond:end");
+  const fragment = document.createDocumentFragment();
+  fragment.append(startMarker, endMarker);
+  const hostRoot = getCurrentRoot();
+  let currentNodes = [];
+  let currentRoot2 = null;
+  let lastCondition = void 0;
+  let pendingRender = false;
+  const conditionMemo = computed(condition);
+  const runConditional = () => {
+    const cond = conditionMemo();
+    const parent = startMarker.parentNode;
+    if (!parent) {
+      pendingRender = true;
+      return;
+    }
+    pendingRender = false;
+    if (lastCondition === cond && currentNodes.length > 0) {
+      return;
+    }
+    if (lastCondition === cond && lastCondition === false && renderFalse === void 0) {
+      return;
+    }
+    lastCondition = cond;
+    if (currentRoot2) {
+      destroyRoot(currentRoot2);
+      currentRoot2 = null;
+    }
+    removeNodes(currentNodes);
+    currentNodes = [];
+    const render2 = cond ? renderTrue : renderFalse;
+    if (!render2) {
+      return;
+    }
+    const root = createRootContext(hostRoot);
+    const prev = pushRoot(root);
+    let handledError = false;
+    try {
+      const output = untrack(render2);
+      if (output == null || output === false) {
+        return;
+      }
+      const el = createElementFn(output);
+      const nodes = toNodeArray(el);
+      insertNodesBefore(parent, nodes, endMarker);
+      currentNodes = nodes;
+    } catch (err) {
+      if (handleSuspend(err, root)) {
+        handledError = true;
+        destroyRoot(root);
+        return;
+      }
+      if (handleError(err, { source: "renderChild" }, root)) {
+        handledError = true;
+        destroyRoot(root);
+        return;
+      }
+      throw err;
+    } finally {
+      popRoot(prev);
+      if (!handledError) {
+        flushOnMount(root);
+        currentRoot2 = root;
+      } else {
+        currentRoot2 = null;
+      }
+    }
+  };
+  const dispose = createRenderEffect(runConditional);
+  return {
+    marker: fragment,
+    flush: () => {
+      if (pendingRender) {
+        runConditional();
+      }
+    },
+    dispose: () => {
+      dispose();
+      if (currentRoot2) {
+        destroyRoot(currentRoot2);
+      }
+      removeNodes(currentNodes);
+      currentNodes = [];
+      startMarker.parentNode?.removeChild(startMarker);
+      endMarker.parentNode?.removeChild(endMarker);
+    }
+  };
+}
+function createShow(el, condition, displayValue) {
+  const originalDisplay = displayValue ?? el.style.display;
+  createRenderEffect(() => {
+    el.style.display = condition() ? originalDisplay : "none";
+  });
+}
+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
+  };
+}
+
+// src/memo.ts
+function createMemo(fn) {
+  return computed(fn);
+}
+
+// src/hooks.ts
+var isDev6 = true ? false : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+var ctxStack = [];
+function assertRenderContext(ctx, hookName) {
+  if (!ctx.rendering) {
+    const message = isDev6 ? `${hookName} can only be used during render execution` : "FICT:E_HOOK_RENDER";
+    throw new Error(message);
+  }
+}
+function __fictUseContext() {
+  if (ctxStack.length === 0) {
+    const ctx2 = { slots: [], cursor: 0, rendering: true };
+    ctxStack.push(ctx2);
+    return ctx2;
+  }
+  const ctx = ctxStack[ctxStack.length - 1];
+  ctx.cursor = 0;
+  ctx.rendering = true;
+  return ctx;
+}
+function __fictPushContext() {
+  const ctx = { slots: [], cursor: 0 };
+  ctxStack.push(ctx);
+  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, prop2, receiver) {
+      const value = Reflect.get(target, prop2, receiver);
+      if (isPropGetter(value)) {
+        return value();
+      }
+      return value;
+    },
+    set(target, prop2, value, receiver) {
+      return Reflect.set(target, prop2, value, receiver);
+    },
+    has(target, prop2) {
+      return prop2 in target;
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, prop2) {
+      return Object.getOwnPropertyDescriptor(target, prop2);
+    }
+  });
+  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);
+  };
+  const hasProp = (prop2) => {
+    for (const src of validSources) {
+      const raw = resolveSource(src);
+      if (raw && prop2 in raw) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const readProp = (prop2) => {
+    for (let i = validSources.length - 1; i >= 0; i--) {
+      const src = validSources[i];
+      const raw = resolveSource(src);
+      if (!raw || !(prop2 in raw)) continue;
+      const value = raw[prop2];
+      if (typeof src === "function" && !isPropGetter(value)) {
+        return __fictProp(() => {
+          const latest = resolveSource(src);
+          if (!latest || !(prop2 in latest)) return void 0;
+          return latest[prop2];
+        });
+      }
+      return value;
+    }
+    return void 0;
+  };
+  return new Proxy({}, {
+    get(_, prop2) {
+      return readProp(prop2);
+    },
+    has(_, prop2) {
+      return hasProp(prop2);
+    },
+    ownKeys() {
+      const keys = /* @__PURE__ */ new Set();
+      for (const src of validSources) {
+        const raw = resolveSource(src);
+        if (raw) {
+          for (const key of Reflect.ownKeys(raw)) {
+            keys.add(key);
+          }
+        }
+      }
+      return Array.from(keys);
+    },
+    getOwnPropertyDescriptor(_, prop2) {
+      if (!hasProp(prop2)) return void 0;
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => readProp(prop2)
+      };
+    }
+  });
+}
+function prop(getter) {
+  if (isPropGetter(getter)) {
+    return getter;
+  }
+  return __fictProp(createMemo(getter));
+}
+
+// src/dom.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATHML_NS = "http://www.w3.org/1998/Math/MathML";
+var isDev7 = true ? false : typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+function render(view, container) {
+  const root = createRootContext();
+  const prev = pushRoot(root);
+  let dom;
+  try {
+    const output = view();
+    dom = createElement(output);
+  } finally {
+    popRoot(prev);
+  }
+  container.replaceChildren(dom);
+  container.setAttribute("data-fict-fine-grained", "1");
+  flushOnMount(root);
+  const teardown = () => {
+    destroyRoot(root);
+    container.innerHTML = "";
+  };
+  return teardown;
+}
+function createElement(node) {
+  return createElementWithContext(node, null);
+}
+function resolveNamespace(tagName, namespace) {
+  if (tagName === "svg") return "svg";
+  if (tagName === "math") return "mathml";
+  if (namespace === "mathml") return "mathml";
+  if (namespace === "svg") return "svg";
+  if (isDev7 && SVGElements.has(tagName)) return "svg";
+  return null;
+}
+function createElementWithContext(node, namespace) {
+  if (node instanceof Node) {
+    return node;
+  }
+  if (node === null || node === void 0 || node === false) {
+    return document.createTextNode("");
+  }
+  if (typeof node === "object" && node !== null && !(node instanceof Node)) {
+    if ("marker" in node) {
+      const handle = node;
+      if (typeof handle.dispose === "function") {
+        registerRootCleanup(handle.dispose);
+      }
+      if (typeof handle.flush === "function") {
+        const runFlush = () => handle.flush && handle.flush();
+        if (typeof queueMicrotask === "function") {
+          queueMicrotask(runFlush);
+        } else {
+          Promise.resolve().then(runFlush).catch(() => void 0);
+        }
+      }
+      return createElement(handle.marker);
+    }
+  }
+  if (Array.isArray(node)) {
+    const frag = document.createDocumentFragment();
+    for (const child of node) {
+      appendChildNode(frag, child, namespace);
+    }
+    return frag;
+  }
+  if (typeof node === "string" || typeof node === "number") {
+    return document.createTextNode(String(node));
+  }
+  if (typeof node === "boolean") {
+    return document.createTextNode("");
+  }
+  const vnode = node;
+  if (typeof vnode.type === "function") {
+    const rawProps = unwrapProps(vnode.props ?? {});
+    const baseProps = vnode.key === void 0 ? rawProps : new Proxy(rawProps, {
+      get(target, prop2, receiver) {
+        if (prop2 === "key") return vnode.key;
+        return Reflect.get(target, prop2, receiver);
+      },
+      has(target, prop2) {
+        if (prop2 === "key") return true;
+        return prop2 in target;
+      },
+      ownKeys(target) {
+        const keys = new Set(Reflect.ownKeys(target));
+        keys.add("key");
+        return Array.from(keys);
+      },
+      getOwnPropertyDescriptor(target, prop2) {
+        if (prop2 === "key") {
+          return { enumerable: true, configurable: true, value: vnode.key };
+        }
+        return Object.getOwnPropertyDescriptor(target, prop2);
+      }
+    });
+    const props = createPropsProxy(baseProps);
+    __fictPushContext();
+    try {
+      const rendered = vnode.type(props);
+      return createElementWithContext(rendered, namespace);
+    } catch (err) {
+      if (handleSuspend(err)) {
+        return document.createComment("fict:suspend");
+      }
+      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 (isDev7) {
+      console.warn(
+        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
+      );
+    }
+  } else if (value && typeof value === "object" && "current" in value) {
+    const refObj = value;
+    refObj.current = el;
+    const root = getCurrentRoot();
+    if (root) {
+      registerRootCleanup(() => {
+        refObj.current = null;
+      });
+    } else if (isDev7) {
+      console.warn(
+        "[fict] Ref applied outside of a root context. The ref cleanup (setting to null) will not run automatically. Consider using createRoot() or ensure the element is created within a component."
+      );
+    }
+  }
+}
+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 (isDev7 && ChildProperties.has(key) || key === "innerHTML" || key === "textContent" || key === "innerText" || key === "children") {
+      createAttributeBinding(el, key, value, setProperty);
+      continue;
+    }
+    if (key.slice(0, 5) === "attr:") {
+      createAttributeBinding(el, key.slice(5), value, setAttribute);
+      continue;
+    }
+    if (key.slice(0, 5) === "bool:") {
+      createAttributeBinding(el, key.slice(5), value, setBoolAttribute);
+      continue;
+    }
+    if (key.slice(0, 5) === "prop:") {
+      createAttributeBinding(el, key.slice(5), value, setProperty);
+      continue;
+    }
+    const propAlias = !isSVG && isDev7 ? getPropAlias(key, tagName) : void 0;
+    const isProperty = !isSVG ? isDev7 ? Properties.has(key) : key in el : false;
+    if (propAlias || isProperty || isCE && !isSVG) {
+      const propName = propAlias || key;
+      if (isCE && !isProperty && !propAlias) {
+        createAttributeBinding(
+          el,
+          toPropertyName2(propName),
+          value,
+          setProperty
+        );
+      } else {
+        createAttributeBinding(el, propName, value, setProperty);
+      }
+      continue;
+    }
+    if (isSVG && key.indexOf(":") > -1) {
+      const [prefix, name] = key.split(":");
+      const ns = SVGNamespace[prefix];
+      if (ns) {
+        createAttributeBinding(
+          el,
+          key,
+          value,
+          (el2, _key, val) => setAttributeNS(el2, ns, name, val)
+        );
+        continue;
+      }
+    }
+    const attrName = key === "htmlFor" ? "for" : key;
+    createAttributeBinding(el, attrName, value, setAttribute);
+  }
+}
+function toPropertyName2(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+var setAttribute = (el, key, value) => {
+  if (value === void 0 || value === null || value === false) {
+    el.removeAttribute(key);
+    return;
+  }
+  if (value === true) {
+    el.setAttribute(key, "");
+    return;
+  }
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number") {
+    el.setAttribute(key, String(value));
+    return;
+  }
+  if (key in el) {
+    ;
+    el[key] = value;
+    return;
+  }
+  el.setAttribute(key, String(value));
+};
+var setProperty = (el, key, value) => {
+  if (value === void 0 || value === null) {
+    const fallback = key === "checked" || key === "selected" ? false : "";
+    el[key] = fallback;
+    return;
+  }
+  if (key === "style" && typeof value === "object" && value !== null) {
+    for (const k in value) {
+      const v = value[k];
+      if (v !== void 0) {
+        ;
+        el.style[k] = String(v);
+      }
+    }
+    return;
+  }
+  ;
+  el[key] = value;
+};
+var setInnerHTML = (el, _key, value) => {
+  ;
+  el.innerHTML = value == null ? "" : String(value);
+};
+var setBoolAttribute = (el, key, value) => {
+  if (value) {
+    el.setAttribute(key, "");
+  } else {
+    el.removeAttribute(key);
+  }
+};
+function setAttributeNS(el, namespace, name, value) {
+  if (value == null) {
+    el.removeAttributeNS(namespace, name);
+  } else {
+    el.setAttributeNS(namespace, name, String(value));
+  }
+}
+function isEventKey(key) {
+  return key.startsWith("on") && key.length > 2 && key[2].toUpperCase() === key[2];
+}
+function eventNameFromProp(key) {
+  return key.slice(2).toLowerCase();
+}
+
+export {
+  BooleanAttributes,
+  Properties,
+  ChildProperties,
+  Aliases,
+  getPropAlias,
+  DelegatedEvents,
+  SVGElements,
+  SVGNamespace,
+  UnitlessStyles,
+  getDevtoolsHook,
+  setCycleProtectionOptions,
+  createRootContext,
+  pushRoot,
+  getCurrentRoot,
+  popRoot,
+  onMount,
+  onDestroy,
+  onCleanup,
+  flushOnMount,
+  registerRootCleanup,
+  destroyRoot,
+  createRoot,
+  registerErrorHandler,
+  registerSuspenseHandler,
+  handleError,
+  flush,
+  signal,
+  effectScope,
+  batch,
+  setActiveSub,
+  untrack,
+  createSelector,
+  createEffect,
+  createRenderEffect,
+  Fragment,
+  toNodeArray,
+  insertNodesBefore,
+  removeNodes,
+  startTransition,
+  useTransition,
+  useDeferredValue,
+  batch2,
+  untrack2,
+  isReactive,
+  unwrap,
+  callEventHandler,
+  createTextBinding,
+  bindText,
+  createAttributeBinding,
+  bindAttribute,
+  bindProperty,
+  createStyleBinding,
+  bindStyle,
+  createClassBinding,
+  bindClass,
+  classList,
+  insert,
+  createChildBinding,
+  delegateEvents,
+  clearDelegatedEvents,
+  addEventListener,
+  bindEvent,
+  bindRef,
+  spread,
+  assign,
+  createConditional,
+  createShow,
+  createPortal,
+  createMemo,
+  __fictUseContext,
+  __fictPushContext,
+  __fictPopContext,
+  __fictResetContext,
+  __fictUseSignal,
+  __fictUseMemo,
+  __fictUseEffect,
+  __fictRender,
+  __fictProp,
+  createPropsProxy,
+  __fictPropsRest,
+  mergeProps,
+  prop,
+  render,
+  createElement,
+  template
+};
+//# sourceMappingURL=chunk-RY4WDS6R.js.map