@fictjs/runtime 0.4.0 → 0.5.0

package/dist/chunk-6SOPF5LZ.cjs

@@ -0,0 +1,2363 @@
+"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; }// 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 = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || _optionalChain([process, 'access', _ => _.env, 'optionalAccess', _2 => _2.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(prop, tagName) {
+  if (!isDev) return void 0;
+  const a = PropAliases[prop];
+  if (typeof a === "object") {
+    return a[tagName] ? a["$"] : void 0;
+  }
+  return a;
+}
+var $$EVENTS = "_$FICT_DELEGATE";
+var DelegatedEvents = new Set(DelegatedEventNames);
+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 = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || _optionalChain([process, 'access', _3 => _3.env, 'optionalAccess', _4 => _4.NODE_ENV]) !== "production";
+var setCycleProtectionOptions = () => {
+};
+var resetCycleProtectionStateForTests = () => {
+};
+var beginFlushGuard = () => {
+};
+var beforeEffectRunGuard = () => true;
+var endFlushGuard = () => {
+};
+var enterRootGuard = () => true;
+var exitRootGuard = () => {
+};
+var defaultOptions = {
+  enabled: true,
+  maxFlushCyclesPerMicrotask: 1e4,
+  maxEffectRunsPerFlush: 2e4,
+  windowSize: 5,
+  highUsageRatio: 0.8,
+  maxRootReentrantDepth: 10,
+  enableWindowWarning: true,
+  devMode: isDev2,
+  // Backoff warning options
+  enableBackoffWarning: isDev2,
+  backoffWarningRatio: 0.5
+};
+var enabled = defaultOptions.enabled;
+var options = {
+  ...defaultOptions
+};
+var effectRunsThisFlush = 0;
+var windowUsage = [];
+var rootDepth = /* @__PURE__ */ new WeakMap();
+var flushWarned = false;
+var rootWarned = false;
+var windowWarned = false;
+var backoffWarned50 = false;
+var backoffWarned75 = false;
+setCycleProtectionOptions = exports.setCycleProtectionOptions = (opts) => {
+  if (typeof opts.enabled === "boolean") {
+    enabled = opts.enabled;
+  }
+  options = { ...options, ...opts };
+};
+resetCycleProtectionStateForTests = () => {
+  options = { ...defaultOptions };
+  enabled = defaultOptions.enabled;
+  effectRunsThisFlush = 0;
+  windowUsage = [];
+  rootDepth = /* @__PURE__ */ new WeakMap();
+  flushWarned = false;
+  rootWarned = false;
+  windowWarned = false;
+  backoffWarned50 = false;
+  backoffWarned75 = false;
+};
+beginFlushGuard = () => {
+  if (!enabled) return;
+  effectRunsThisFlush = 0;
+  flushWarned = false;
+  windowWarned = false;
+  backoffWarned50 = false;
+  backoffWarned75 = false;
+};
+beforeEffectRunGuard = () => {
+  if (!enabled) return true;
+  const next = ++effectRunsThisFlush;
+  const limit = Math.min(options.maxFlushCyclesPerMicrotask, options.maxEffectRunsPerFlush);
+  if (options.enableBackoffWarning && isDev2) {
+    const ratio = next / limit;
+    const backoffRatio = _nullishCoalesce(options.backoffWarningRatio, () => ( 0.5));
+    if (!backoffWarned50 && ratio >= backoffRatio && ratio < backoffRatio + 0.25) {
+      backoffWarned50 = true;
+      console.warn(
+        `[fict] cycle guard: approaching effect limit (${Math.round(ratio * 100)}% of budget used)
+  - Current: ${next} effects, Limit: ${limit}
+  - Tip: Check for effects that trigger other effects in a loop.
+  - Common causes: signal updates inside effects that read and write the same signal.`
+      );
+    } else if (!backoffWarned75 && ratio >= backoffRatio + 0.25 && ratio < 1) {
+      backoffWarned75 = true;
+      console.warn(
+        `[fict] cycle guard: nearing effect limit (${Math.round(ratio * 100)}% of budget used)
+  - Current: ${next} effects, Limit: ${limit}
+  - Warning: Consider breaking the reactive dependency cycle.
+  - Debug: Use browser devtools to identify the recursive effect chain.`
+      );
+    }
+  }
+  if (next > limit) {
+    const message = `[fict] cycle protection triggered: flush-budget-exceeded`;
+    if (options.devMode) {
+      throw new Error(
+        message + `
+  - Effect runs: ${next}, Limit: ${limit}
+  - This indicates a reactive cycle where effects keep triggering each other.
+  - Check for patterns like: createEffect(() => { signal(); signal(newValue); })`
+      );
+    }
+    if (!flushWarned) {
+      flushWarned = true;
+      console.warn(message, { effectRuns: next, limit });
+    }
+    return false;
+  }
+  return true;
+};
+endFlushGuard = () => {
+  if (!enabled) return;
+  recordWindowUsage(effectRunsThisFlush, options.maxFlushCyclesPerMicrotask);
+  effectRunsThisFlush = 0;
+};
+enterRootGuard = (root) => {
+  if (!enabled) return true;
+  const depth = (_nullishCoalesce(rootDepth.get(root), () => ( 0))) + 1;
+  if (depth > options.maxRootReentrantDepth) {
+    const message = `[fict] cycle protection triggered: root-reentry`;
+    if (options.devMode) {
+      throw new Error(
+        message + `
+  - Re-entry depth: ${depth}, Max allowed: ${options.maxRootReentrantDepth}
+  - This indicates recursive render() or component initialization.
+  - Check for components that trigger re-renders during their own render phase.`
+      );
+    }
+    if (!rootWarned) {
+      rootWarned = true;
+      console.warn(message, { depth, maxAllowed: options.maxRootReentrantDepth });
+    }
+    return false;
+  }
+  rootDepth.set(root, depth);
+  return true;
+};
+exitRootGuard = (root) => {
+  if (!enabled) return;
+  const depth = rootDepth.get(root);
+  if (depth === void 0) return;
+  if (depth <= 1) {
+    rootDepth.delete(root);
+  } else {
+    rootDepth.set(root, depth - 1);
+  }
+};
+var 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
+    });
+  }
+};
+var reportCycle = (reason, detail = void 0) => {
+  const hook = getDevtoolsHook();
+  _optionalChain([hook, 'optionalAccess', _5 => _5.cycleDetected, 'optionalCall', _6 => _6(detail ? { reason, detail } : { reason })]);
+  console.warn(`[fict] cycle protection triggered: ${reason}`, _nullishCoalesce(detail, () => ( "")));
+};
+
+// src/lifecycle.ts
+var isDev3 = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || _optionalChain([process, 'access', _7 => _7.env, 'optionalAccess', _8 => _8.NODE_ENV]) !== "production";
+var currentRoot;
+var currentEffectCleanups;
+var globalErrorHandlers = /* @__PURE__ */ new WeakMap();
+var globalSuspenseHandlers = /* @__PURE__ */ new WeakMap();
+function createRootContext(parent) {
+  return { parent, cleanups: [], destroyCallbacks: [], suspended: false };
+}
+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;
+  const prevRoot = currentRoot;
+  currentRoot = root;
+  try {
+    for (let i = 0; i < cbs.length; i++) {
+      const cleanup = cbs[i]();
+      if (typeof cleanup === "function") {
+        root.cleanups.push(cleanup);
+      }
+    }
+  } finally {
+    currentRoot = prevRoot;
+    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, options2) {
+  const parent = _optionalChain([options2, 'optionalAccess', _9 => _9.inherit]) ? currentRoot : void 0;
+  const root = createRootContext(parent);
+  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 = _nullishCoalesce(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 = _nullishCoalesce(startRoot, () => ( currentRoot));
+  const originRoot = root;
+  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) {
+          if (originRoot) originRoot.suspended = true;
+          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) {
+        if (originRoot) originRoot.suspended = true;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// 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 (handleSuspend(err, rootForError)) {
+          return;
+        }
+        if (handleError(err, { source: "effect" }, rootForError)) {
+          return;
+        }
+        throw err;
+      }
+    });
+    cleanups = bucket;
+  };
+  const disposeEffect = effectWithCleanup(run, doCleanup, rootForError);
+  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) {
+      if (handleSuspend(err, rootForError)) {
+        return;
+      }
+      const handled = handleError(err, { source: "effect" }, rootForError);
+      if (handled) {
+        return;
+      }
+      throw err;
+    }
+  };
+  const disposeEffect = effectWithCleanup(run, doCleanup, rootForError);
+  const teardown = () => {
+    if (cleanup) {
+      cleanup();
+      cleanup = void 0;
+    }
+    disposeEffect();
+  };
+  registerRootCleanup(teardown);
+  return teardown;
+}
+
+// src/hooks.ts
+var isDev4 = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || _optionalChain([process, 'access', _10 => _10.env, 'optionalAccess', _11 => _11.NODE_ENV]) !== "production";
+var ctxStack = [];
+var preparedContext = null;
+function assertRenderContext(ctx, hookName) {
+  if (!ctx.rendering) {
+    const message = isDev4 ? `${hookName} can only be used during render execution` : "FICT:E_HOOK_RENDER";
+    throw new Error(message);
+  }
+}
+function __fictUseContext() {
+  if (ctxStack.length === 0) {
+    const message = isDev4 ? "Invalid hook call: hooks can only be used while rendering a component. Make sure you are not calling hooks in event handlers or outside of components." : "FICT:E_HOOK_OUTSIDE_RENDER";
+    throw new Error(message);
+  }
+  const ctx = ctxStack[ctxStack.length - 1];
+  if (!ctx.rendering) {
+    ctx.cursor = 0;
+    ctx.rendering = true;
+  }
+  return ctx;
+}
+function __fictPushContext() {
+  const ctx = _nullishCoalesce(preparedContext, () => ( { slots: [], cursor: 0 }));
+  preparedContext = null;
+  ctxStack.push(ctx);
+  return ctx;
+}
+function __fictPrepareContext(ctx) {
+  preparedContext = ctx;
+}
+function __fictGetCurrentComponentId() {
+  return _optionalChain([ctxStack, 'access', _12 => _12[ctxStack.length - 1], 'optionalAccess', _13 => _13.componentId]);
+}
+function __fictPopContext() {
+  const ctx = ctxStack.pop();
+  if (ctx) ctx.rendering = false;
+}
+function __fictResetContext() {
+  ctxStack.length = 0;
+}
+function __fictUseSignal(ctx, initial, optionsOrSlot, slot) {
+  assertRenderContext(ctx, "__fictUseSignal");
+  const options2 = typeof optionsOrSlot === "number" ? void 0 : optionsOrSlot;
+  const resolvedSlot = typeof optionsOrSlot === "number" ? optionsOrSlot : slot;
+  const index = _nullishCoalesce(resolvedSlot, () => ( ctx.cursor++));
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = signal(initial, options2);
+  }
+  if (_optionalChain([options2, 'optionalAccess', _14 => _14.name])) {
+    if (!ctx.slotMap) ctx.slotMap = {};
+    ctx.slotMap[options2.name] = index;
+  }
+  return ctx.slots[index];
+}
+function __fictUseMemo(ctx, fn, optionsOrSlot, slot) {
+  assertRenderContext(ctx, "__fictUseMemo");
+  const options2 = typeof optionsOrSlot === "number" ? void 0 : optionsOrSlot;
+  const resolvedSlot = typeof optionsOrSlot === "number" ? optionsOrSlot : slot;
+  const index = _nullishCoalesce(resolvedSlot, () => ( ctx.cursor++));
+  if (!ctx.slots[index]) {
+    ctx.slots[index] = createMemo(fn, options2);
+  }
+  return ctx.slots[index];
+}
+function __fictUseEffect(ctx, fn, slot) {
+  if (slot !== void 0) {
+    if (ctx.slots[slot]) {
+      return;
+    }
+    ctx.slots[slot] = createEffect(fn);
+    return;
+  }
+  assertRenderContext(ctx, "__fictUseEffect");
+  const index = 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/signal.ts
+var isDev5 = typeof __DEV__ !== "undefined" ? __DEV__ : typeof process === "undefined" || _optionalChain([process, 'access', _15 => _15.env, 'optionalAccess', _16 => _16.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;
+  if (isDev5) trackDependencyDevtools(dep, sub);
+}
+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);
+  if (isDev5) untrackDependencyDevtools(dep, sub);
+  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 valuesDiffer(node, prev, next) {
+  if (node.equals === false) return true;
+  if (typeof node.equals === "function") return !node.equals(prev, next);
+  return prev !== next;
+}
+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 (valuesDiffer(s, 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 (valuesDiffer(c, oldValue, newValue)) {
+      c.value = newValue;
+      if (isDev5) updateComputedDevtools(c, 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;
+    if (isDev5) 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;
+      }
+    }
+    let isDirty = false;
+    try {
+      isDirty = checkDirty(e.deps, e);
+    } catch (err) {
+      if (handleSuspend(err, e.root)) {
+        if (e.flags !== 0) {
+          e.flags = Watching;
+        }
+        return;
+      }
+      if (handleError(err, { source: "effect" }, e.root)) {
+        if (e.flags !== 0) {
+          e.flags = Watching;
+        }
+        return;
+      }
+      throw err;
+    }
+    if (isDirty) {
+      ++cycle;
+      if (isDev5) 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()) {
+      for (let i = 0; i < highPriorityQueue.length; i++) {
+        const queued = highPriorityQueue[i];
+        if (queued && queued.flags !== 0) {
+          queued.flags = Watching;
+        }
+      }
+      for (let i = 0; i < lowPriorityQueue.length; i++) {
+        const queued = lowPriorityQueue[i];
+        if (queued && queued.flags !== 0) {
+          queued.flags = Watching;
+        }
+      }
+      highPriorityQueue.length = 0;
+      lowPriorityQueue.length = 0;
+      flushScheduled = false;
+      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()) {
+      for (let i = 0; i < highPriorityQueue.length; i++) {
+        const queued = highPriorityQueue[i];
+        if (queued && queued.flags !== 0) {
+          queued.flags = Watching;
+        }
+      }
+      for (let i = 0; i < lowPriorityQueue.length; i++) {
+        const queued = lowPriorityQueue[i];
+        if (queued && queued.flags !== 0) {
+          queued.flags = Watching;
+        }
+      }
+      highPriorityQueue.length = 0;
+      lowPriorityQueue.length = 0;
+      flushScheduled = false;
+      endFlushGuard();
+      return;
+    }
+    lowIndex++;
+    runEffect(e);
+  }
+  lowPriorityQueue.length = 0;
+  endFlushGuard();
+}
+function signal(initialValue, options2) {
+  const s = {
+    currentValue: initialValue,
+    pendingValue: initialValue,
+    subs: void 0,
+    subsTail: void 0,
+    flags: Mutable,
+    __id: void 0,
+    ..._optionalChain([options2, 'optionalAccess', _17 => _17.equals]) !== void 0 ? { equals: options2.equals } : {},
+    ..._optionalChain([options2, 'optionalAccess', _18 => _18.name]) !== void 0 ? { name: options2.name } : {},
+    ..._optionalChain([options2, 'optionalAccess', _19 => _19.devToolsSource]) !== void 0 ? { devToolsSource: options2.devToolsSource } : {}
+  };
+  if (isDev5) registerSignalDevtools(s);
+  const accessor = signalOper.bind(s);
+  accessor[SIGNAL_MARKER] = true;
+  return accessor;
+}
+function signalOper(value) {
+  if (arguments.length > 0) {
+    const next = value;
+    const prev = this.pendingValue;
+    if (valuesDiffer(this, prev, next)) {
+      this.pendingValue = next;
+      this.flags = MutableDirty;
+      if (isDev5) updateSignalDevtools(this, next);
+      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, options2) {
+  const c = {
+    value: void 0,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: 0,
+    getter,
+    __id: void 0,
+    ..._optionalChain([options2, 'optionalAccess', _20 => _20.equals]) !== void 0 ? { equals: options2.equals } : {},
+    ..._optionalChain([options2, 'optionalAccess', _21 => _21.name]) !== void 0 ? { name: options2.name } : {},
+    ..._optionalChain([options2, 'optionalAccess', _22 => _22.devToolsSource]) !== void 0 ? { devToolsSource: options2.devToolsSource } : {}
+  };
+  if (isDev5) registerComputedDevtools(c);
+  const bound = computedOper.bind(
+    c
+  );
+  bound[COMPUTED_MARKER] = true;
+  return bound;
+}
+function computedOper() {
+  if (inCleanup) return this.value;
+  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);
+      if (isDev5) updateComputedDevtools(this, this.value);
+    } 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
+  };
+  const root = getCurrentRoot();
+  if (root) {
+    e.root = root;
+  }
+  if (isDev5) registerEffectDevtools(e);
+  const prevSub = activeSub;
+  if (prevSub !== void 0) link(e, prevSub, 0);
+  activeSub = e;
+  try {
+    if (isDev5) effectRunDevtools(e);
+    fn();
+  } finally {
+    activeSub = prevSub;
+    e.flags &= ~Running;
+  }
+  const disposer = effectOper.bind(e);
+  disposer[EFFECT_MARKER] = true;
+  return disposer;
+}
+function effectWithCleanup(fn, cleanupRunner, root) {
+  const e = {
+    fn,
+    subs: void 0,
+    subsTail: void 0,
+    deps: void 0,
+    depsTail: void 0,
+    flags: WatchingRunning,
+    runCleanup: cleanupRunner,
+    __id: void 0
+  };
+  const resolvedRoot = _nullishCoalesce(root, () => ( getCurrentRoot()));
+  if (resolvedRoot) {
+    e.root = resolvedRoot;
+  }
+  if (isDev5) registerEffectDevtools(e);
+  const prevSub = activeSub;
+  if (prevSub !== void 0) link(e, prevSub, 0);
+  activeSub = e;
+  try {
+    if (isDev5) 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 __resetReactiveState() {
+  highPriorityQueue.length = 0;
+  lowPriorityQueue.length = 0;
+  batchDepth = 0;
+  activeSub = void 0;
+  flushScheduled = false;
+  isInTransition = false;
+  inCleanup = false;
+  cycle = 0;
+}
+function untrack(fn) {
+  const prev = activeSub;
+  activeSub = void 0;
+  try {
+    return fn();
+  } finally {
+    activeSub = prev;
+  }
+}
+function isSignal(fn) {
+  return typeof fn === "function" && fn[SIGNAL_MARKER] === true;
+}
+function isComputed(fn) {
+  return typeof fn === "function" && fn[COMPUTED_MARKER] === true;
+}
+function isEffect(fn) {
+  return typeof fn === "function" && fn[EFFECT_MARKER] === true;
+}
+function isEffectScope(fn) {
+  return typeof fn === "function" && fn[EFFECT_SCOPE_MARKER] === true;
+}
+function setTransitionContext(value) {
+  const prev = isInTransition;
+  isInTransition = value;
+  return prev;
+}
+var registerSignalDevtools = () => void 0;
+var updateSignalDevtools = () => {
+};
+var registerComputedDevtools = () => void 0;
+var updateComputedDevtools = () => {
+};
+var registerEffectDevtools = () => void 0;
+var effectRunDevtools = () => {
+};
+var trackDependencyDevtools = () => {
+};
+var untrackDependencyDevtools = () => {
+};
+if (isDev5) {
+  let nextDevtoolsId = 0;
+  registerSignalDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return void 0;
+    const id = ++nextDevtoolsId;
+    const options2 = {};
+    if (node.name !== void 0) options2.name = node.name;
+    if (node.devToolsSource !== void 0) options2.source = node.devToolsSource;
+    const ownerId = __fictGetCurrentComponentId();
+    if (ownerId !== void 0) options2.ownerId = ownerId;
+    hook.registerSignal(id, node.currentValue, options2);
+    node.__id = id;
+    return id;
+  };
+  updateSignalDevtools = (node, value) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return;
+    const id = node.__id;
+    if (id) hook.updateSignal(id, value);
+  };
+  registerComputedDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return void 0;
+    const id = ++nextDevtoolsId;
+    const options2 = {};
+    if (node.name !== void 0) options2.name = node.name;
+    if (node.devToolsSource !== void 0) options2.source = node.devToolsSource;
+    const ownerId = __fictGetCurrentComponentId();
+    if (ownerId !== void 0) options2.ownerId = ownerId;
+    options2.hasValue = false;
+    hook.registerComputed(id, node.value, options2);
+    node.__id = id;
+    return id;
+  };
+  updateComputedDevtools = (node, value) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return;
+    const id = node.__id;
+    if (id) hook.updateComputed(id, value);
+  };
+  registerEffectDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return void 0;
+    const id = ++nextDevtoolsId;
+    const ownerId = __fictGetCurrentComponentId();
+    hook.registerEffect(id, ownerId !== void 0 ? { ownerId } : void 0);
+    node.__id = id;
+    return id;
+  };
+  effectRunDevtools = (node) => {
+    const hook = getDevtoolsHook();
+    if (!hook) return;
+    const id = node.__id;
+    if (id) hook.effectRun(id);
+  };
+  trackDependencyDevtools = (dep, sub) => {
+    const hook = getDevtoolsHook();
+    if (!_optionalChain([hook, 'optionalAccess', _23 => _23.trackDependency])) return;
+    const depId = dep.__id;
+    const subId = sub.__id;
+    if (depId && subId) hook.trackDependency(subId, depId);
+  };
+  untrackDependencyDevtools = (dep, sub) => {
+    const hook = getDevtoolsHook();
+    if (!_optionalChain([hook, 'optionalAccess', _24 => _24.untrackDependency])) return;
+    const depId = dep.__id;
+    const subId = sub.__id;
+    if (depId && subId) hook.untrackDependency(subId, depId);
+  };
+}
+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/memo.ts
+function createMemo(fn, options2) {
+  return computed(fn, options2);
+}
+
+// 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 (Reflect.get(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 isArrayLength = Array.isArray(target) && prop === "length";
+      const oldLength = isArrayLength ? target.length : void 0;
+      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);
+        }
+        if (isArrayLength) {
+          const nextLength = target.length;
+          if (typeof oldLength === "number" && nextLength < oldLength) {
+            const signals = signalCache.get(target);
+            if (signals) {
+              for (const key of signals.keys()) {
+                if (typeof key !== "string") continue;
+                const index = Number(key);
+                if (!Number.isInteger(index) || String(index) !== key) continue;
+                if (index >= nextLength && index < oldLength) {
+                  trigger(target, key);
+                }
+              }
+            }
+          }
+          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" && Reflect.get(value, PROXY)) {
+    return Reflect.get(value, TARGET);
+  }
+  return value;
+}
+function isStoreProxy(value) {
+  return !!(value && typeof value === "object" && Reflect.get(value, PROXY));
+}
+function unwrapStore(value) {
+  return unwrap(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 Reflect.get(target, prop);
+}
+function reconcile(target, value) {
+  if (target === value) return;
+  if (value === null || typeof value !== "object") {
+    throw new Error(
+      `[Fict] Cannot replace store with primitive value: ${String(
+        value
+      )}. setStore should return an object/array to merge.`
+    );
+  }
+  const realTarget = unwrap(target);
+  const realValue = unwrap(value);
+  const keys = /* @__PURE__ */ new Set([...Object.keys(realTarget), ...Object.keys(realValue)]);
+  for (const key of keys) {
+    const rTarget = realTarget;
+    const rValue = realValue;
+    if (rValue[key] === void 0 && rTarget[key] !== void 0) {
+      delete target[key];
+    } else if (rTarget[key] !== rValue[key]) {
+      ;
+      target[key] = rValue[key];
+    }
+  }
+  if (Array.isArray(target) && Array.isArray(realValue) && target.length !== realValue.length) {
+    target.length = realValue.length;
+  }
+}
+
+// src/resume.ts
+var ssrEnabled = false;
+var resumableEnabled = false;
+var hydrating = false;
+var scopeCounter = 0;
+var scopeRegistry = /* @__PURE__ */ new Map();
+var snapshotState = null;
+var resumedScopes = /* @__PURE__ */ new Map();
+function __fictEnableSSR() {
+  ssrEnabled = true;
+  scopeCounter = 0;
+  scopeRegistry = /* @__PURE__ */ new Map();
+  resumedScopes.clear();
+  snapshotState = null;
+}
+function __fictDisableSSR() {
+  ssrEnabled = false;
+}
+function __fictEnableResumable() {
+  resumableEnabled = true;
+}
+function __fictDisableResumable() {
+  resumableEnabled = false;
+  resumedScopes.clear();
+}
+function __fictIsResumable() {
+  return ssrEnabled || resumableEnabled;
+}
+function __fictIsSSR() {
+  return ssrEnabled;
+}
+function __fictEnterHydration() {
+  hydrating = true;
+}
+function __fictExitHydration() {
+  hydrating = false;
+}
+function __fictIsHydrating() {
+  return hydrating;
+}
+function __fictRegisterScope(ctx, host, type, props) {
+  if (!__fictIsResumable()) return "";
+  const id = `s${++scopeCounter}`;
+  ctx.scopeId = id;
+  if (type !== void 0) {
+    ctx.scopeType = type;
+  }
+  host.setAttribute("data-fict-s", id);
+  if (type) {
+    host.setAttribute("data-fict-t", type);
+  }
+  const record = { id, ctx, host };
+  if (type !== void 0) {
+    record.type = type;
+  }
+  if (props !== void 0) {
+    record.props = props;
+  }
+  scopeRegistry.set(id, record);
+  return id;
+}
+function __fictGetScopeRegistry() {
+  return scopeRegistry;
+}
+function __fictSerializeSSRState() {
+  const scopes = {};
+  for (const [id, record] of scopeRegistry.entries()) {
+    const snapshot = {
+      id,
+      slots: serializeSlots(record.ctx)
+    };
+    if (record.type !== void 0) {
+      snapshot.t = record.type;
+    }
+    if (record.props !== void 0) {
+      snapshot.props = record.props;
+    }
+    if (record.ctx.slotMap !== void 0) {
+      snapshot.vars = record.ctx.slotMap;
+    }
+    scopes[id] = snapshot;
+  }
+  return { scopes };
+}
+function __fictSetSSRState(state) {
+  snapshotState = state;
+  if (!state) {
+    resumedScopes.clear();
+  }
+}
+function __fictGetSSRScope(id) {
+  return _optionalChain([snapshotState, 'optionalAccess', _25 => _25.scopes, 'access', _26 => _26[id]]);
+}
+function __fictEnsureScope(scopeId, host, snapshot) {
+  const existing = resumedScopes.get(scopeId);
+  if (existing) return existing.ctx;
+  const ctx = createContextFromSnapshot(snapshot);
+  ctx.scopeId = scopeId;
+  if (_optionalChain([snapshot, 'optionalAccess', _27 => _27.t]) !== void 0) {
+    ctx.scopeType = snapshot.t;
+  }
+  const entry = { ctx, host };
+  if (_optionalChain([snapshot, 'optionalAccess', _28 => _28.props]) !== void 0) {
+    entry.props = snapshot.props;
+  }
+  resumedScopes.set(scopeId, entry);
+  return ctx;
+}
+function __fictUseLexicalScope(scopeId, names) {
+  const record = resumedScopes.get(scopeId);
+  if (!record) {
+    throw new Error(`[fict] Missing resumed scope for ${scopeId}`);
+  }
+  const ctx = record.ctx;
+  const map = _nullishCoalesce(ctx.slotMap, () => ( {}));
+  return names.map((name) => ctx.slots[_nullishCoalesce(map[name], () => ( -1))]);
+}
+function __fictGetScopeProps(scopeId) {
+  return _optionalChain([resumedScopes, 'access', _29 => _29.get, 'call', _30 => _30(scopeId), 'optionalAccess', _31 => _31.props]);
+}
+function __fictQrl(moduleId, exportName) {
+  const manifest = globalThis.__FICT_MANIFEST__;
+  if (_optionalChain([manifest, 'optionalAccess', _32 => _32[moduleId]])) {
+    return `${manifest[moduleId]}#${exportName}`;
+  }
+  if (moduleId.startsWith("file://")) {
+    const filePath = moduleId.slice(7);
+    const ssrBase = globalThis.__FICT_SSR_BASE__;
+    if (ssrBase) {
+      if (filePath.startsWith(ssrBase)) {
+        const relativePath = filePath.slice(ssrBase.length);
+        return `${relativePath}#${exportName}`;
+      }
+    }
+    return `/@fs${filePath}#${exportName}`;
+  }
+  return `${moduleId}#${exportName}`;
+}
+var resumeFunctionRegistry = /* @__PURE__ */ new Map();
+function __fictRegisterResume(name, fn) {
+  resumeFunctionRegistry.set(name, fn);
+}
+function __fictGetResume(name) {
+  return resumeFunctionRegistry.get(name);
+}
+function serializeSlots(ctx) {
+  const slots = [];
+  const values = _nullishCoalesce(ctx.slots, () => ( []));
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    if (value === void 0) {
+      slots.push([i, "raw", serializeValue(void 0, seen, `$[${i}]`)]);
+      continue;
+    }
+    if (isSignal(value)) {
+      try {
+        const raw = value();
+        slots.push([i, "sig", serializeValue(raw, seen, `$[${i}]`)]);
+      } catch (e2) {
+      }
+      continue;
+    }
+    if (isStoreProxy(value)) {
+      const raw = unwrapStore(value);
+      slots.push([i, "store", serializeValue(raw, seen, `$[${i}]`)]);
+      continue;
+    }
+    slots.push([i, "raw", serializeValue(value, seen, `$[${i}]`)]);
+  }
+  return slots;
+}
+function createContextFromSnapshot(snapshot) {
+  const ctx = { slots: [], cursor: 0 };
+  if (!snapshot) return ctx;
+  for (const slot of snapshot.slots) {
+    const [index, type, value] = slot;
+    if (type === "sig") {
+      ctx.slots[index] = signal(deserializeValue(value));
+    } else if (type === "store") {
+      ctx.slots[index] = createStore(deserializeValue(value))[0];
+    } else {
+      ctx.slots[index] = deserializeValue(value);
+    }
+  }
+  if (snapshot.vars) {
+    ctx.slotMap = { ...snapshot.vars };
+  }
+  return ctx;
+}
+function isSerializedMarker(value) {
+  return typeof value === "object" && value !== null && "__t" in value && typeof value.__t === "string";
+}
+function serializeValue(value, seen = /* @__PURE__ */ new Map(), path = "$") {
+  if (value === void 0) {
+    return { __t: "u" };
+  }
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) {
+      return { __t: "n" };
+    }
+    if (value === Infinity) {
+      return { __t: "+i" };
+    }
+    if (value === -Infinity) {
+      return { __t: "-i" };
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return { __t: "b", v: value.toString() };
+  }
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "function") {
+    return void 0;
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return { __t: "ref", v: seen.get(value) };
+    }
+    if (value instanceof Date) {
+      return { __t: "d", v: value.getTime() };
+    }
+    if (value instanceof RegExp) {
+      return { __t: "r", v: { s: value.source, f: value.flags } };
+    }
+    if (value instanceof Map) {
+      seen.set(value, path);
+      const entries = [];
+      let i = 0;
+      for (const [k, v] of value) {
+        entries.push([
+          serializeValue(k, seen, `${path}.k${i}`),
+          serializeValue(v, seen, `${path}.v${i}`)
+        ]);
+        i++;
+      }
+      return { __t: "m", v: entries };
+    }
+    if (value instanceof Set) {
+      seen.set(value, path);
+      const items = [];
+      let i = 0;
+      for (const item of value) {
+        items.push(serializeValue(item, seen, `${path}[${i}]`));
+        i++;
+      }
+      return { __t: "s", v: items };
+    }
+    if (Array.isArray(value)) {
+      seen.set(value, path);
+      return value.map((item, i) => serializeValue(item, seen, `${path}[${i}]`));
+    }
+    seen.set(value, path);
+    const result = {};
+    for (const key of Object.keys(value)) {
+      const serialized = serializeValue(
+        value[key],
+        seen,
+        `${path}.${key}`
+      );
+      if (serialized !== void 0) {
+        result[key] = serialized;
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function deserializeValue(value, refs = /* @__PURE__ */ new Map(), path = "$") {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (isSerializedMarker(value)) {
+    switch (value.__t) {
+      case "u":
+        return void 0;
+      case "n":
+        return NaN;
+      case "+i":
+        return Infinity;
+      case "-i":
+        return -Infinity;
+      case "b":
+        return BigInt(value.v);
+      case "d":
+        return new Date(value.v);
+      case "r":
+        return new RegExp(value.v.s, value.v.f);
+      case "m": {
+        const map = /* @__PURE__ */ new Map();
+        refs.set(path, map);
+        for (let i = 0; i < value.v.length; i++) {
+          const entry = value.v[i];
+          if (!entry) continue;
+          const [k, v] = entry;
+          map.set(
+            deserializeValue(k, refs, `${path}.k${i}`),
+            deserializeValue(v, refs, `${path}.v${i}`)
+          );
+        }
+        return map;
+      }
+      case "s": {
+        const set = /* @__PURE__ */ new Set();
+        refs.set(path, set);
+        for (let i = 0; i < value.v.length; i++) {
+          set.add(deserializeValue(value.v[i], refs, `${path}[${i}]`));
+        }
+        return set;
+      }
+      case "ref":
+        return refs.get(value.v);
+    }
+  }
+  if (Array.isArray(value)) {
+    const arr = [];
+    refs.set(path, arr);
+    for (let i = 0; i < value.length; i++) {
+      arr.push(deserializeValue(value[i], refs, `${path}[${i}]`));
+    }
+    return arr;
+  }
+  const obj = {};
+  refs.set(path, obj);
+  for (const key of Object.keys(value)) {
+    obj[key] = deserializeValue(value[key], refs, `${path}.${key}`);
+  }
+  return obj;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BooleanAttributes = BooleanAttributes; exports.Properties = Properties; exports.ChildProperties = ChildProperties; exports.Aliases = Aliases; exports.getPropAlias = getPropAlias; exports.$$EVENTS = $$EVENTS; exports.DelegatedEvents = DelegatedEvents; exports.SVGElements = SVGElements; exports.SVGNamespace = SVGNamespace; exports.UnitlessStyles = UnitlessStyles; exports.getDevtoolsHook = getDevtoolsHook; exports.setCycleProtectionOptions = setCycleProtectionOptions; exports.createRootContext = createRootContext; exports.pushRoot = pushRoot; exports.getCurrentRoot = getCurrentRoot; exports.popRoot = popRoot; exports.onMount = onMount; exports.onDestroy = onDestroy; exports.onCleanup = onCleanup; exports.flushOnMount = flushOnMount; exports.registerRootCleanup = registerRootCleanup; exports.destroyRoot = destroyRoot; exports.createRoot = createRoot; exports.registerErrorHandler = registerErrorHandler; exports.registerSuspenseHandler = registerSuspenseHandler; exports.handleError = handleError; exports.handleSuspend = handleSuspend; exports.createMemo = createMemo; exports.__fictUseContext = __fictUseContext; exports.__fictPushContext = __fictPushContext; exports.__fictPrepareContext = __fictPrepareContext; exports.__fictGetCurrentComponentId = __fictGetCurrentComponentId; exports.__fictPopContext = __fictPopContext; exports.__fictResetContext = __fictResetContext; exports.__fictUseSignal = __fictUseSignal; exports.__fictUseMemo = __fictUseMemo; exports.__fictUseEffect = __fictUseEffect; exports.__fictRender = __fictRender; exports.scheduleFlush = scheduleFlush; exports.flush = flush; exports.signal = signal; exports.computed = computed; exports.effectScope = effectScope; exports.batch = batch; exports.setActiveSub = setActiveSub; exports.__resetReactiveState = __resetReactiveState; exports.untrack = untrack; exports.isSignal = isSignal; exports.isComputed = isComputed; exports.isEffect = isEffect; exports.isEffectScope = isEffectScope; exports.setTransitionContext = setTransitionContext; exports.createSelector = createSelector; exports.createEffect = createEffect; exports.createRenderEffect = createRenderEffect; exports.createStore = createStore; exports.isStoreProxy = isStoreProxy; exports.unwrapStore = unwrapStore; exports.__fictEnableSSR = __fictEnableSSR; exports.__fictDisableSSR = __fictDisableSSR; exports.__fictEnableResumable = __fictEnableResumable; exports.__fictDisableResumable = __fictDisableResumable; exports.__fictIsResumable = __fictIsResumable; exports.__fictIsSSR = __fictIsSSR; exports.__fictEnterHydration = __fictEnterHydration; exports.__fictExitHydration = __fictExitHydration; exports.__fictIsHydrating = __fictIsHydrating; exports.__fictRegisterScope = __fictRegisterScope; exports.__fictGetScopeRegistry = __fictGetScopeRegistry; exports.__fictSerializeSSRState = __fictSerializeSSRState; exports.__fictSetSSRState = __fictSetSSRState; exports.__fictGetSSRScope = __fictGetSSRScope; exports.__fictEnsureScope = __fictEnsureScope; exports.__fictUseLexicalScope = __fictUseLexicalScope; exports.__fictGetScopeProps = __fictGetScopeProps; exports.__fictQrl = __fictQrl; exports.__fictRegisterResume = __fictRegisterResume; exports.__fictGetResume = __fictGetResume; exports.serializeValue = serializeValue; exports.deserializeValue = deserializeValue;
+//# sourceMappingURL=chunk-6SOPF5LZ.cjs.map