@getforma/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1626 @@
+'use strict';
+
+var chunk27QSSN4E_cjs = require('./chunk-27QSSN4E.cjs');
+var chunkFPSLC62A_cjs = require('./chunk-FPSLC62A.cjs');
+
+// src/dom/text.ts
+function createText(value) {
+  if (typeof value === "function") {
+    const node = new Text("");
+    chunk27QSSN4E_cjs.internalEffect(() => {
+      node.data = value();
+    });
+    return node;
+  }
+  return new Text(value);
+}
+
+// src/dom/mount.ts
+function mount(component, container) {
+  const target = typeof container === "string" ? document.querySelector(container) : container;
+  if (!target) {
+    throw new Error(`mount: container not found \u2014 "${container}"`);
+  }
+  let disposeRoot;
+  if (target.hasAttribute("data-forma-ssr")) {
+    chunk27QSSN4E_cjs.createRoot((dispose) => {
+      disposeRoot = dispose;
+      chunk27QSSN4E_cjs.hydrateIsland(component, target);
+    });
+  } else {
+    const dom = chunk27QSSN4E_cjs.createRoot((dispose) => {
+      disposeRoot = dispose;
+      return component();
+    });
+    target.innerHTML = "";
+    target.appendChild(dom);
+  }
+  let unmounted = false;
+  return () => {
+    if (unmounted) return;
+    unmounted = true;
+    disposeRoot();
+    target.innerHTML = "";
+  };
+}
+
+// src/dom/switch.ts
+function createSwitch(value, cases, fallback) {
+  const startMarker = document.createComment("forma-switch");
+  const endMarker = document.createComment("/forma-switch");
+  const fragment2 = document.createDocumentFragment();
+  fragment2.appendChild(startMarker);
+  fragment2.appendChild(endMarker);
+  const cache = /* @__PURE__ */ new Map();
+  let currentNode = null;
+  let currentMatch = UNSET;
+  const switchDispose = chunk27QSSN4E_cjs.internalEffect(() => {
+    const val = value();
+    if (val === currentMatch) return;
+    const DEBUG = typeof globalThis.__FORMA_DEBUG__ !== "undefined";
+    if (DEBUG) console.log("[forma:switch] transition", String(currentMatch), "\u2192", String(val));
+    currentMatch = val;
+    const parent2 = startMarker.parentNode;
+    if (!parent2) {
+      if (DEBUG) console.warn("[forma:switch] markers not in DOM yet, skipping");
+      return;
+    }
+    if (currentNode) {
+      if (currentNode.parentNode === parent2) {
+        if (DEBUG) console.log("[forma:switch] removing single node");
+        parent2.removeChild(currentNode);
+      } else if (currentNode.nodeType === 11) {
+        if (DEBUG) console.log("[forma:switch] scooping nodes back into fragment");
+        let scooped = 0;
+        while (startMarker.nextSibling && startMarker.nextSibling !== endMarker) {
+          currentNode.appendChild(startMarker.nextSibling);
+          scooped++;
+        }
+        if (DEBUG) console.log("[forma:switch] scooped", scooped, "nodes back into fragment");
+      } else {
+        if (DEBUG) console.log("[forma:switch] clearing detached node between markers");
+        while (startMarker.nextSibling && startMarker.nextSibling !== endMarker) {
+          parent2.removeChild(startMarker.nextSibling);
+        }
+      }
+    }
+    const matchedCase = cases.find((c) => c.match === val);
+    if (matchedCase) {
+      let entry = cache.get(val);
+      if (!entry) {
+        let branchDispose;
+        const node = chunk27QSSN4E_cjs.createRoot((dispose) => {
+          branchDispose = dispose;
+          return chunk27QSSN4E_cjs.untrack(() => matchedCase.render());
+        });
+        entry = { node, dispose: branchDispose };
+        cache.set(val, entry);
+        if (DEBUG) console.log("[forma:switch] rendered new branch for", String(val), "\u2192", node.nodeName, "type", node.nodeType);
+      } else {
+        if (DEBUG) console.log("[forma:switch] reusing cached branch for", String(val), "\u2192", entry.node.nodeName, "type", entry.node.nodeType, "childNodes", entry.node.childNodes?.length);
+      }
+      currentNode = entry.node;
+    } else {
+      currentNode = fallback?.() ?? null;
+      if (DEBUG) console.log("[forma:switch] no match, using fallback");
+    }
+    if (currentNode) {
+      parent2.insertBefore(currentNode, endMarker);
+      if (DEBUG) console.log("[forma:switch] inserted", currentNode.nodeName, "before end marker");
+    }
+  });
+  fragment2.__switchDispose = () => {
+    switchDispose();
+    for (const entry of cache.values()) {
+      entry.dispose();
+    }
+    cache.clear();
+  };
+  return fragment2;
+}
+var UNSET = /* @__PURE__ */ Symbol("unset");
+
+// src/dom/portal.ts
+function createPortal(children2, target) {
+  const placeholder = document.createComment("forma-portal");
+  const resolvedTarget = typeof target === "string" ? document.querySelector(target) : target ?? document.body;
+  if (!resolvedTarget) {
+    throw new Error(`createPortal: target not found: ${target}`);
+  }
+  let mountedNode = null;
+  const removeMountedNode = () => {
+    if (mountedNode && mountedNode.parentNode === resolvedTarget) {
+      resolvedTarget.removeChild(mountedNode);
+    }
+    mountedNode = null;
+  };
+  chunk27QSSN4E_cjs.createEffect(() => {
+    const node = children2();
+    removeMountedNode();
+    mountedNode = node;
+    resolvedTarget.appendChild(node);
+    return () => {
+      removeMountedNode();
+    };
+  });
+  return placeholder;
+}
+
+// src/dom/error-boundary.ts
+function createErrorBoundary(tryFn, catchFn) {
+  const startMarker = document.createComment("forma-error-boundary");
+  const endMarker = document.createComment("/forma-error-boundary");
+  const fragment2 = document.createDocumentFragment();
+  fragment2.appendChild(startMarker);
+  fragment2.appendChild(endMarker);
+  const [retryCount, setRetryCount] = chunkFPSLC62A_cjs.createSignal(0);
+  let currentNode = null;
+  chunk27QSSN4E_cjs.internalEffect(() => {
+    retryCount();
+    const parent2 = startMarker.parentNode;
+    if (!parent2) return;
+    if (currentNode && currentNode.parentNode === parent2) {
+      parent2.removeChild(currentNode);
+    }
+    try {
+      currentNode = tryFn();
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e));
+      const retry = () => setRetryCount((c) => c + 1);
+      currentNode = catchFn(error, retry);
+    }
+    if (currentNode) {
+      parent2.insertBefore(currentNode, endMarker);
+    }
+  });
+  return fragment2;
+}
+
+// src/dom/suspense.ts
+function createSuspense(fallback, children2) {
+  const startMarker = document.createComment("forma-suspense");
+  const endMarker = document.createComment("/forma-suspense");
+  const fragment2 = document.createDocumentFragment();
+  fragment2.appendChild(startMarker);
+  fragment2.appendChild(endMarker);
+  const [pending, setPending] = chunkFPSLC62A_cjs.createSignal(0);
+  let currentNode = null;
+  let resolvedNode = null;
+  let fallbackNode = null;
+  const ctx = {
+    increment() {
+      setPending((p) => p + 1);
+    },
+    decrement() {
+      setPending((p) => Math.max(0, p - 1));
+    }
+  };
+  chunk27QSSN4E_cjs.pushSuspenseContext(ctx);
+  try {
+    resolvedNode = children2();
+  } finally {
+    chunk27QSSN4E_cjs.popSuspenseContext();
+  }
+  chunk27QSSN4E_cjs.internalEffect(() => {
+    const parent2 = startMarker.parentNode;
+    if (!parent2) return;
+    const isPending = pending() > 0;
+    const newNode = isPending ? fallbackNode ??= fallback() : resolvedNode;
+    if (newNode === currentNode) return;
+    if (currentNode && currentNode.parentNode === parent2) {
+      parent2.removeChild(currentNode);
+    }
+    if (newNode) {
+      parent2.insertBefore(newNode, endMarker);
+    }
+    currentNode = newNode;
+  });
+  return fragment2;
+}
+
+// src/dom/activate.ts
+function loadIslandProps(root, id, sharedProps) {
+  const inline = root.getAttribute("data-forma-props");
+  if (inline) {
+    return JSON.parse(inline);
+  }
+  if (sharedProps && String(id) in sharedProps) {
+    return sharedProps[String(id)];
+  }
+  return null;
+}
+function activateIslands(registry2) {
+  const scriptBlock = document.getElementById("__forma_islands");
+  const sharedProps = scriptBlock ? JSON.parse(scriptBlock.textContent) : null;
+  const islands = document.querySelectorAll("[data-forma-island]");
+  for (const root of islands) {
+    const id = parseInt(root.getAttribute("data-forma-island"), 10);
+    const componentName = root.getAttribute("data-forma-component");
+    const hydrateFn = registry2[componentName];
+    if (!hydrateFn) {
+      console.warn(`[forma] No hydrate function for island "${componentName}" (id=${id})`);
+      root.setAttribute("data-forma-status", "error");
+      continue;
+    }
+    const trigger = root.getAttribute("data-forma-hydrate") || "load";
+    if (trigger === "interaction" || trigger === "idle") {
+      console.warn(`[forma] Trigger "${trigger}" not yet implemented for island "${componentName}" (id=${id}), falling back to load`);
+    }
+    if (trigger === "visible") {
+      const observer = new IntersectionObserver(
+        (entries) => {
+          for (const entry of entries) {
+            if (!entry.isIntersecting) continue;
+            observer.disconnect();
+            hydrateIslandRoot(root, id, componentName, hydrateFn, sharedProps);
+          }
+        },
+        { rootMargin: "200px" }
+      );
+      observer.observe(root);
+    } else {
+      hydrateIslandRoot(root, id, componentName, hydrateFn, sharedProps);
+    }
+  }
+}
+function hydrateIslandRoot(root, id, componentName, hydrateFn, sharedProps) {
+  try {
+    const props = loadIslandProps(root, id, sharedProps);
+    root.setAttribute("data-forma-status", "hydrating");
+    let activeRoot = root;
+    chunk27QSSN4E_cjs.createRoot((dispose) => {
+      activeRoot = chunk27QSSN4E_cjs.hydrateIsland(() => hydrateFn(props), root);
+      activeRoot.__formaDispose = dispose;
+    });
+    activeRoot.setAttribute("data-forma-status", "active");
+  } catch (err) {
+    console.error(`[forma] Island "${componentName}" (id=${id}) failed:`, err);
+    root.setAttribute("data-forma-status", "error");
+  }
+}
+
+// src/component/define.ts
+var currentLifecycleContext = null;
+var lifecycleStack = [];
+function pushLifecycleContext(ctx) {
+  lifecycleStack.push(currentLifecycleContext);
+  currentLifecycleContext = ctx;
+}
+function popLifecycleContext() {
+  currentLifecycleContext = lifecycleStack.pop() ?? null;
+}
+function onMount(fn) {
+  if (currentLifecycleContext === null) {
+    throw new Error("onMount() must be called inside a component setup function");
+  }
+  currentLifecycleContext.mountCallbacks.push(fn);
+}
+function onUnmount(fn) {
+  if (currentLifecycleContext === null) {
+    throw new Error("onUnmount() must be called inside a component setup function");
+  }
+  currentLifecycleContext.unmountCallbacks.push(fn);
+}
+var DISPOSE_KEY = /* @__PURE__ */ Symbol("forma:component:dispose");
+function defineComponent(setupOrDef) {
+  const setup = typeof setupOrDef === "function" ? setupOrDef : setupOrDef.setup;
+  typeof setupOrDef === "function" ? void 0 : setupOrDef.name;
+  return function componentFactory() {
+    const ctx = {
+      disposers: [],
+      mountCallbacks: [],
+      unmountCallbacks: []
+    };
+    pushLifecycleContext(ctx);
+    let dom;
+    try {
+      dom = setup();
+    } finally {
+      popLifecycleContext();
+    }
+    const dispose = () => {
+      for (const cb of ctx.unmountCallbacks) {
+        try {
+          cb();
+        } catch {
+        }
+      }
+      for (const d of ctx.disposers) {
+        try {
+          d();
+        } catch {
+        }
+      }
+      ctx.disposers.length = 0;
+      ctx.mountCallbacks.length = 0;
+      ctx.unmountCallbacks.length = 0;
+    };
+    dom[DISPOSE_KEY] = dispose;
+    for (const cb of ctx.mountCallbacks) {
+      try {
+        const cleanup2 = cb();
+        if (typeof cleanup2 === "function") {
+          ctx.unmountCallbacks.push(cleanup2);
+        }
+      } catch {
+      }
+    }
+    return dom;
+  };
+}
+function disposeComponent(dom) {
+  const disposable = dom;
+  if (typeof disposable[DISPOSE_KEY] === "function") {
+    disposable[DISPOSE_KEY]();
+    delete disposable[DISPOSE_KEY];
+  }
+}
+function trackDisposer(dispose) {
+  if (currentLifecycleContext !== null) {
+    currentLifecycleContext.disposers.push(dispose);
+  }
+}
+
+// src/component/context.ts
+var contextStacks = /* @__PURE__ */ new Map();
+function createContext(defaultValue) {
+  return {
+    id: /* @__PURE__ */ Symbol("forma:context"),
+    defaultValue
+  };
+}
+function provide(ctx, value) {
+  let stack = contextStacks.get(ctx.id);
+  if (stack === void 0) {
+    stack = [];
+    contextStacks.set(ctx.id, stack);
+  }
+  stack.push(value);
+}
+function inject(ctx) {
+  const stack = contextStacks.get(ctx.id);
+  if (stack === void 0 || stack.length === 0) {
+    return ctx.defaultValue;
+  }
+  return stack[stack.length - 1];
+}
+function unprovide(ctx) {
+  const stack = contextStacks.get(ctx.id);
+  if (stack !== void 0 && stack.length > 0) {
+    stack.pop();
+    if (stack.length === 0) {
+      contextStacks.delete(ctx.id);
+    }
+  }
+}
+
+// src/state/store.ts
+var RAW = /* @__PURE__ */ Symbol("forma-raw");
+var PROXY = /* @__PURE__ */ Symbol("forma-proxy");
+var ARRAY_MUTATORS = /* @__PURE__ */ new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin"
+]);
+function shouldWrap(v) {
+  if (v == null || typeof v !== "object") return false;
+  if (v instanceof Date || v instanceof RegExp || v instanceof Map || v instanceof Set || v instanceof WeakMap || v instanceof WeakSet || v instanceof Error || v instanceof Promise) {
+    return false;
+  }
+  if (v[PROXY]) return false;
+  return true;
+}
+function deepClone(obj) {
+  if (obj == null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(deepClone);
+  if (obj instanceof Date) return new Date(obj.getTime());
+  const out = {};
+  for (const key of Object.keys(obj)) {
+    out[key] = deepClone(obj[key]);
+  }
+  return out;
+}
+function createStore(initial) {
+  const signals = /* @__PURE__ */ new Map();
+  const children2 = /* @__PURE__ */ new Map();
+  function registerChild(path) {
+    const lastDot = path.lastIndexOf(".");
+    if (lastDot === -1) return;
+    const parentPath = path.substring(0, lastDot);
+    let set = children2.get(parentPath);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      children2.set(parentPath, set);
+    }
+    set.add(path);
+  }
+  function getSignal(path, initialValue) {
+    let pair = signals.get(path);
+    if (!pair) {
+      pair = chunkFPSLC62A_cjs.createSignal(initialValue);
+      signals.set(path, pair);
+      registerChild(path);
+    }
+    return pair;
+  }
+  const proxyCache = /* @__PURE__ */ new WeakMap();
+  function invalidateChildren(parentPath) {
+    const childSet = children2.get(parentPath);
+    if (!childSet) return;
+    for (const childPath of childSet) {
+      invalidateChildren(childPath);
+      signals.delete(childPath);
+      children2.delete(childPath);
+    }
+    childSet.clear();
+  }
+  function wrap(raw, basePath) {
+    if (!shouldWrap(raw)) return raw;
+    const cached = proxyCache.get(raw);
+    if (cached) return cached;
+    const isArr = Array.isArray(raw);
+    const basePrefix = basePath ? basePath + "." : "";
+    let lastKey = "";
+    let lastSignal;
+    const proxy = new Proxy(raw, {
+      // -------------------------------------------------------------------
+      // GET
+      // -------------------------------------------------------------------
+      get(target, prop, receiver) {
+        if (prop === RAW) return target;
+        if (prop === PROXY) return true;
+        if (typeof prop === "symbol") {
+          return Reflect.get(target, prop, receiver);
+        }
+        const key = String(prop);
+        const childPath = basePrefix + key;
+        if (isArr && ARRAY_MUTATORS.has(key)) {
+          return (...args) => {
+            let result;
+            chunk27QSSN4E_cjs.batch(() => {
+              const rawArgs = args.map(
+                (a) => a != null && typeof a === "object" && a[RAW] ? a[RAW] : a
+              );
+              result = target[key].apply(target, rawArgs);
+              invalidateChildren(basePath);
+              const [, setLen] = getSignal(
+                basePrefix + "length",
+                target.length
+              );
+              setLen(target.length);
+            });
+            return result;
+          };
+        }
+        if (isArr && key === "length") {
+          const [getter] = getSignal(childPath, target.length);
+          getter();
+          return target.length;
+        }
+        const value = Reflect.get(target, prop);
+        let pair;
+        if (key === lastKey && lastSignal) {
+          pair = lastSignal;
+        } else {
+          pair = getSignal(childPath, value);
+          lastKey = key;
+          lastSignal = pair;
+        }
+        pair[0]();
+        if (shouldWrap(value)) {
+          return wrap(value, childPath);
+        }
+        return value;
+      },
+      // -------------------------------------------------------------------
+      // SET
+      // -------------------------------------------------------------------
+      set(target, prop, value) {
+        if (typeof prop === "symbol") {
+          return Reflect.set(target, prop, value);
+        }
+        const key = String(prop);
+        const childPath = basePrefix + key;
+        const rawValue = value != null && typeof value === "object" && value[RAW] ? value[RAW] : value;
+        Reflect.set(target, prop, rawValue);
+        if (rawValue != null && typeof rawValue === "object") {
+          invalidateChildren(childPath);
+        }
+        if (isArr && key !== "length") {
+          const lengthPath = basePrefix + "length";
+          const lenPair = signals.get(lengthPath);
+          if (lenPair) {
+            lenPair[1](target.length);
+          }
+        }
+        const [, setter2] = getSignal(childPath, rawValue);
+        setter2(rawValue);
+        return true;
+      },
+      // -------------------------------------------------------------------
+      // HAS — track membership checks
+      // -------------------------------------------------------------------
+      has(target, prop) {
+        if (typeof prop === "symbol") {
+          return Reflect.has(target, prop);
+        }
+        const key = String(prop);
+        const childPath = basePrefix + key;
+        const [getter] = getSignal(childPath, Reflect.get(target, prop));
+        getter();
+        return Reflect.has(target, prop);
+      },
+      // -------------------------------------------------------------------
+      // OWNKEYS — return keys from the raw target
+      // -------------------------------------------------------------------
+      ownKeys(target) {
+        return Reflect.ownKeys(target);
+      },
+      // -------------------------------------------------------------------
+      // GETOWNPROPERTYDESCRIPTOR — needed for Object.keys / spread / ...
+      // -------------------------------------------------------------------
+      getOwnPropertyDescriptor(target, prop) {
+        return Object.getOwnPropertyDescriptor(target, prop);
+      },
+      // -------------------------------------------------------------------
+      // DELETEPROPERTY — clean up signals when a key is removed
+      // -------------------------------------------------------------------
+      deleteProperty(target, prop) {
+        if (typeof prop === "symbol") {
+          return Reflect.deleteProperty(target, prop);
+        }
+        const key = String(prop);
+        const childPath = basePrefix + key;
+        const result = Reflect.deleteProperty(target, prop);
+        invalidateChildren(childPath);
+        signals.delete(childPath);
+        const parentPath = basePath;
+        if (parentPath !== void 0) {
+          const parentSet = children2.get(parentPath);
+          if (parentSet) {
+            parentSet.delete(childPath);
+            if (parentSet.size === 0) children2.delete(parentPath);
+          }
+        }
+        children2.delete(childPath);
+        return result;
+      }
+    });
+    proxyCache.set(raw, proxy);
+    return proxy;
+  }
+  const rootProxy = wrap(initial, "");
+  function getCurrentSnapshot() {
+    return chunk27QSSN4E_cjs.untrack(() => deepClone(initial));
+  }
+  const setter = (partial) => {
+    const updates = typeof partial === "function" ? partial(getCurrentSnapshot()) : partial;
+    chunk27QSSN4E_cjs.batch(() => {
+      for (const key of Object.keys(updates)) {
+        rootProxy[key] = updates[key];
+      }
+    });
+  };
+  return [rootProxy, setter];
+}
+
+// src/state/history.ts
+function createHistory(source, options) {
+  const [sourceGet, sourceSet] = source;
+  const maxLength = options?.maxLength ?? 100;
+  let _stack = [sourceGet()];
+  let _cursor = 0;
+  const [stackSignal, setStackSignal] = chunkFPSLC62A_cjs.createValueSignal([..._stack]);
+  const [cursorSignal, setCursorSignal] = chunkFPSLC62A_cjs.createValueSignal(_cursor);
+  const [stackLenSignal, setStackLenSignal] = chunkFPSLC62A_cjs.createValueSignal(_stack.length);
+  function syncSignals() {
+    chunk27QSSN4E_cjs.batch(() => {
+      setStackSignal([..._stack]);
+      setCursorSignal(_cursor);
+      setStackLenSignal(_stack.length);
+    });
+  }
+  let ignoreNext = false;
+  let isFirstRun = true;
+  chunk27QSSN4E_cjs.internalEffect(() => {
+    const value = sourceGet();
+    if (isFirstRun) {
+      isFirstRun = false;
+      return;
+    }
+    if (ignoreNext) {
+      ignoreNext = false;
+      return;
+    }
+    _stack = _stack.slice(0, _cursor + 1);
+    _stack.push(value);
+    if (_stack.length > maxLength) {
+      _stack.splice(0, _stack.length - maxLength);
+    }
+    _cursor = _stack.length - 1;
+    syncSignals();
+  });
+  const canUndo = () => cursorSignal() > 0;
+  const canRedo = () => cursorSignal() < stackLenSignal() - 1;
+  const undo = () => {
+    if (_cursor <= 0) return;
+    _cursor--;
+    ignoreNext = true;
+    sourceSet(_stack[_cursor]);
+    syncSignals();
+  };
+  const redo = () => {
+    if (_cursor >= _stack.length - 1) return;
+    _cursor++;
+    ignoreNext = true;
+    sourceSet(_stack[_cursor]);
+    syncSignals();
+  };
+  const clear = () => {
+    const currentValue = sourceGet();
+    _stack = [currentValue];
+    _cursor = 0;
+    syncSignals();
+  };
+  return {
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    history: () => stackSignal(),
+    cursor: () => cursorSignal(),
+    clear
+  };
+}
+
+// src/state/persist.ts
+function persist(source, key, options) {
+  const [sourceGet, sourceSet] = source;
+  const storage = options?.storage ?? globalThis.localStorage;
+  const serialize = options?.serialize ?? JSON.stringify;
+  const deserialize = options?.deserialize ?? JSON.parse;
+  try {
+    const stored = storage.getItem(key);
+    if (stored !== null) {
+      const value = deserialize(stored);
+      sourceSet(value);
+    }
+  } catch {
+  }
+  chunk27QSSN4E_cjs.internalEffect(() => {
+    const value = sourceGet();
+    try {
+      const serialized = serialize(value);
+      storage.setItem(key, serialized);
+    } catch {
+    }
+  });
+}
+
+// src/events/bus.ts
+function createBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  function getHandlers(event) {
+    let set = listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+    }
+    return set;
+  }
+  function on2(event, handler) {
+    const set = getHandlers(event);
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  function once(event, handler) {
+    const wrapper = (payload) => {
+      off(event, wrapper);
+      handler(payload);
+    };
+    return on2(event, wrapper);
+  }
+  function emit(event, payload) {
+    const set = listeners.get(event);
+    if (set) {
+      for (const handler of [...set]) {
+        try {
+          handler(payload);
+        } catch (e) {
+          console.error(`[forma] Bus handler error on "${String(event)}":`, e);
+        }
+      }
+    }
+  }
+  function off(event, handler) {
+    const set = listeners.get(event);
+    if (set) {
+      set.delete(handler);
+    }
+  }
+  function clear() {
+    listeners.clear();
+  }
+  return { on: on2, once, emit, off, clear };
+}
+
+// src/events/delegate.ts
+function delegate(container, selector, event, handler, options) {
+  const listener = (e) => {
+    const target = e.target;
+    if (!(target instanceof HTMLElement)) return;
+    const root = container instanceof Document ? container.documentElement : container;
+    const matched = target.closest(selector);
+    if (matched instanceof HTMLElement && root.contains(matched)) {
+      handler(e, matched);
+    }
+  };
+  container.addEventListener(event, listener, options);
+  return () => {
+    container.removeEventListener(event, listener, options);
+  };
+}
+
+// src/events/keyboard.ts
+function parseCombo(combo) {
+  const parts = combo.toLowerCase().split("+").map((p) => p.trim());
+  const modifiers = {
+    ctrl: false,
+    shift: false,
+    alt: false,
+    meta: false,
+    key: ""
+  };
+  for (const part of parts) {
+    switch (part) {
+      case "ctrl":
+      case "control":
+        modifiers.ctrl = true;
+        break;
+      case "shift":
+        modifiers.shift = true;
+        break;
+      case "alt":
+        modifiers.alt = true;
+        break;
+      case "meta":
+      case "cmd":
+      case "command":
+        modifiers.meta = true;
+        break;
+      default:
+        modifiers.key = part;
+    }
+  }
+  return modifiers;
+}
+function matchesCombo(e, parsed) {
+  if (e.ctrlKey !== parsed.ctrl) return false;
+  if (e.shiftKey !== parsed.shift) return false;
+  if (e.altKey !== parsed.alt) return false;
+  if (e.metaKey !== parsed.meta) return false;
+  return e.key.toLowerCase() === parsed.key;
+}
+function onKey(combo, handler, options) {
+  const target = options?.target ?? document;
+  const shouldPreventDefault = options?.preventDefault ?? true;
+  const parsed = parseCombo(combo);
+  const listener = (e) => {
+    if (!(e instanceof KeyboardEvent)) return;
+    if (matchesCombo(e, parsed)) {
+      if (shouldPreventDefault) {
+        e.preventDefault();
+      }
+      handler(e);
+    }
+  };
+  target.addEventListener("keydown", listener);
+  return () => {
+    target.removeEventListener("keydown", listener);
+  };
+}
+
+// src/dom-utils/query.ts
+function $(selector, parent2) {
+  return (parent2 ?? document).querySelector(selector);
+}
+function $$(selector, parent2) {
+  return Array.from((parent2 ?? document).querySelectorAll(selector));
+}
+
+// src/dom-utils/mutate.ts
+function addClass(el, ...classes) {
+  el.classList.add(...classes);
+}
+function removeClass(el, ...classes) {
+  el.classList.remove(...classes);
+}
+function toggleClass(el, className, force) {
+  return el.classList.toggle(className, force);
+}
+function setStyle(el, styles) {
+  for (const [key, value] of Object.entries(styles)) {
+    if (value !== void 0) {
+      el.style[key] = value;
+    }
+  }
+}
+function setAttr(el, attrs) {
+  for (const [name, value] of Object.entries(attrs)) {
+    if (value === false || value === null) {
+      el.removeAttribute(name);
+    } else if (value === true) {
+      el.setAttribute(name, "");
+    } else {
+      el.setAttribute(name, value);
+    }
+  }
+}
+function setText(el, text) {
+  el.textContent = text;
+}
+function setHTML(el, html) {
+  el.innerHTML = html;
+}
+
+// src/dom-utils/traverse.ts
+function closest(el, selector) {
+  return el.closest(selector);
+}
+function children(el, selector) {
+  const all = Array.from(el.children);
+  if (!selector) return all;
+  return all.filter((child) => child.matches(selector));
+}
+function siblings(el, selector) {
+  const parentEl = el.parentElement;
+  if (!parentEl) return [];
+  const all = Array.from(parentEl.children);
+  const sibs = all.filter((child) => child !== el);
+  if (!selector) return sibs;
+  return sibs.filter((child) => child.matches(selector));
+}
+function parent(el) {
+  return el.parentElement;
+}
+function nextSibling(el, selector) {
+  let sib = el.nextElementSibling;
+  while (sib) {
+    if (sib instanceof HTMLElement) {
+      if (!selector || sib.matches(selector)) {
+        return sib;
+      }
+    }
+    sib = sib.nextElementSibling;
+  }
+  return null;
+}
+function prevSibling(el, selector) {
+  let sib = el.previousElementSibling;
+  while (sib) {
+    if (sib instanceof HTMLElement) {
+      if (!selector || sib.matches(selector)) {
+        return sib;
+      }
+    }
+    sib = sib.previousElementSibling;
+  }
+  return null;
+}
+
+// src/dom-utils/observe.ts
+function onResize(el, handler) {
+  const observer = new ResizeObserver((entries) => {
+    for (const entry of entries) {
+      handler(entry);
+    }
+  });
+  observer.observe(el);
+  return () => {
+    observer.disconnect();
+  };
+}
+function onIntersect(el, handler, options) {
+  const observer = new IntersectionObserver((entries) => {
+    for (const entry of entries) {
+      handler(entry);
+    }
+  }, options);
+  observer.observe(el);
+  return () => {
+    observer.disconnect();
+  };
+}
+function onMutation(el, handler, options) {
+  const observer = new MutationObserver((mutations) => {
+    handler(mutations);
+  });
+  observer.observe(el, options ?? { childList: true, subtree: true });
+  return () => {
+    observer.disconnect();
+  };
+}
+
+// src/storage/local.ts
+function createLocalStorage(key, options) {
+  const serialize = options?.serialize ?? JSON.stringify;
+  const deserialize = options?.deserialize ?? JSON.parse;
+  return {
+    key,
+    get() {
+      try {
+        const raw = localStorage.getItem(key);
+        if (raw === null) return null;
+        return deserialize(raw);
+      } catch {
+        return null;
+      }
+    },
+    set(value) {
+      const serialized = serialize(value);
+      localStorage.setItem(key, serialized);
+    },
+    remove() {
+      localStorage.removeItem(key);
+    }
+  };
+}
+
+// src/storage/session.ts
+function createSessionStorage(key, options) {
+  const serialize = options?.serialize ?? JSON.stringify;
+  const deserialize = options?.deserialize ?? JSON.parse;
+  return {
+    key,
+    get() {
+      try {
+        const raw = sessionStorage.getItem(key);
+        if (raw === null) return null;
+        return deserialize(raw);
+      } catch {
+        return null;
+      }
+    },
+    set(value) {
+      const serialized = serialize(value);
+      sessionStorage.setItem(key, serialized);
+    },
+    remove() {
+      sessionStorage.removeItem(key);
+    }
+  };
+}
+
+// src/storage/indexed.ts
+var dbCache = /* @__PURE__ */ new Map();
+function openDB(dbName, storeName) {
+  const cacheKey = `${dbName}::${storeName}`;
+  const cached = dbCache.get(cacheKey);
+  if (cached) return cached;
+  const promise = new Promise((resolve, reject) => {
+    const probe = indexedDB.open(dbName);
+    probe.onerror = () => reject(probe.error);
+    probe.onsuccess = () => {
+      const db = probe.result;
+      if (db.objectStoreNames.contains(storeName)) {
+        resolve(db);
+        return;
+      }
+      const nextVersion = db.version + 1;
+      db.close();
+      const upgrade = indexedDB.open(dbName, nextVersion);
+      upgrade.onerror = () => reject(upgrade.error);
+      upgrade.onupgradeneeded = () => {
+        const upgradedDB = upgrade.result;
+        if (!upgradedDB.objectStoreNames.contains(storeName)) {
+          upgradedDB.createObjectStore(storeName);
+        }
+      };
+      upgrade.onsuccess = () => resolve(upgrade.result);
+    };
+    probe.onupgradeneeded = () => {
+      const db = probe.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+  });
+  dbCache.set(cacheKey, promise);
+  promise.catch(() => {
+    dbCache.delete(cacheKey);
+  });
+  return promise;
+}
+function createIndexedDB(dbName, storeName = "default") {
+  function withStore(mode, fn) {
+    return openDB(dbName, storeName).then(
+      (db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, mode);
+        const store = tx.objectStore(storeName);
+        const request = fn(store);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      })
+    );
+  }
+  return {
+    get(key) {
+      return withStore("readonly", (store) => store.get(key));
+    },
+    set(key, value) {
+      return withStore("readwrite", (store) => store.put(value, key)).then(
+        () => void 0
+      );
+    },
+    delete(key) {
+      return withStore("readwrite", (store) => store.delete(key)).then(
+        () => void 0
+      );
+    },
+    getAll() {
+      return withStore("readonly", (store) => store.getAll());
+    },
+    keys() {
+      return withStore("readonly", (store) => store.getAllKeys()).then(
+        (keys) => keys.map(String)
+      );
+    },
+    clear() {
+      return withStore("readwrite", (store) => store.clear()).then(
+        () => void 0
+      );
+    }
+  };
+}
+
+// src/http/fetch.ts
+function createFetch(url, options) {
+  const [data, setData] = chunkFPSLC62A_cjs.createSignal(null);
+  const [error, setError] = chunkFPSLC62A_cjs.createSignal(null);
+  const [loading, setLoading] = chunkFPSLC62A_cjs.createSignal(false);
+  let currentController = null;
+  function resolveURL() {
+    const raw = typeof url === "function" ? url() : url;
+    const base = options?.base ?? "";
+    const fullURL = new URL(raw, base || void 0);
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        fullURL.searchParams.set(key, value);
+      }
+    }
+    return fullURL.toString();
+  }
+  async function execute() {
+    if (currentController) {
+      currentController.abort();
+    }
+    currentController = new AbortController();
+    const controller = currentController;
+    const timeoutMs = options?.timeout ?? 3e4;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    setLoading(true);
+    setError(null);
+    try {
+      const resolvedURL = resolveURL();
+      const { base: _base, params: _params, timeout: _timeout, transform, ...fetchInit } = options ?? {};
+      const response = await fetch(resolvedURL, {
+        ...fetchInit,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const json = await response.json();
+      const transformed = transform ? transform(json) : json;
+      setData(transformed);
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        return;
+      }
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      clearTimeout(timeoutId);
+      if (currentController === controller) {
+        currentController = null;
+        setLoading(false);
+      }
+    }
+  }
+  if (typeof url === "function") {
+    chunk27QSSN4E_cjs.internalEffect(() => {
+      url();
+      execute();
+    });
+  } else {
+    execute();
+  }
+  return {
+    data,
+    error,
+    loading,
+    refetch: execute,
+    abort() {
+      if (currentController) {
+        currentController.abort();
+      }
+    }
+  };
+}
+async function fetchJSON(url, options) {
+  const response = await fetch(url, options);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  return await response.json();
+}
+
+// src/http/sse.ts
+function createSSE(url, options) {
+  const [data, setData] = chunkFPSLC62A_cjs.createSignal(null);
+  const [error, setError] = chunkFPSLC62A_cjs.createSignal(null);
+  const [connected, setConnected] = chunkFPSLC62A_cjs.createSignal(false);
+  const source = new EventSource(url, {
+    withCredentials: options?.withCredentials ?? false
+  });
+  source.onopen = () => {
+    setConnected(true);
+    setError(null);
+  };
+  source.onmessage = (event) => {
+    try {
+      const parsed = JSON.parse(event.data);
+      setData(parsed);
+    } catch {
+      setData(event.data);
+    }
+  };
+  source.onerror = (event) => {
+    setError(event);
+    setConnected(false);
+  };
+  return {
+    data,
+    error,
+    connected,
+    close() {
+      source.close();
+      setConnected(false);
+    },
+    on(event, handler) {
+      const listener = (e) => {
+        try {
+          handler(JSON.parse(e.data));
+        } catch {
+          handler(e.data);
+        }
+      };
+      source.addEventListener(event, listener);
+      return () => {
+        source.removeEventListener(event, listener);
+      };
+    }
+  };
+}
+
+// src/http/ws.ts
+function createWebSocket(url, options) {
+  const shouldReconnect = options?.reconnect ?? true;
+  const baseInterval = options?.reconnectInterval ?? 1e3;
+  const maxReconnects = options?.maxReconnects ?? 5;
+  const [data, setData] = chunkFPSLC62A_cjs.createSignal(null);
+  const [status, setStatus] = chunkFPSLC62A_cjs.createSignal("connecting");
+  const handlers = /* @__PURE__ */ new Set();
+  let socket = null;
+  let reconnectCount = 0;
+  let reconnectTimer = null;
+  let permanentlyClosed = false;
+  function connect() {
+    if (permanentlyClosed) return;
+    setStatus("connecting");
+    socket = new WebSocket(url, options?.protocols);
+    socket.onopen = () => {
+      setStatus("open");
+      reconnectCount = 0;
+    };
+    socket.onmessage = (event) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(event.data);
+      } catch {
+        parsed = event.data;
+      }
+      setData(parsed);
+      for (const handler of handlers) {
+        handler(parsed);
+      }
+    };
+    socket.onerror = () => {
+      setStatus("error");
+    };
+    socket.onclose = () => {
+      if (permanentlyClosed) {
+        setStatus("closed");
+        return;
+      }
+      setStatus("closed");
+      if (shouldReconnect && reconnectCount < maxReconnects) {
+        const delay = baseInterval * Math.pow(2, reconnectCount);
+        reconnectCount++;
+        reconnectTimer = setTimeout(connect, delay);
+      }
+    };
+  }
+  connect();
+  return {
+    data,
+    status,
+    send(value) {
+      if (socket && socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify(value));
+      }
+    },
+    close() {
+      permanentlyClosed = true;
+      if (reconnectTimer !== null) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      if (socket) {
+        socket.close();
+        socket = null;
+      }
+      setStatus("closed");
+    },
+    on(handler) {
+      handlers.add(handler);
+      return () => {
+        handlers.delete(handler);
+      };
+    }
+  };
+}
+
+// src/server/action.ts
+function createAction(serverFn, options) {
+  const [pending, setPending] = chunkFPSLC62A_cjs.createValueSignal(false);
+  const [error, setError] = chunkFPSLC62A_cjs.createValueSignal(void 0);
+  const action = async (...args) => {
+    setPending(true);
+    setError(void 0);
+    if (options?.optimistic) {
+      try {
+        chunk27QSSN4E_cjs.batch(() => options.optimistic(...args));
+      } catch {
+      }
+    }
+    try {
+      const result = await serverFn(...args);
+      if (options?.onSuccess) {
+        chunk27QSSN4E_cjs.batch(() => options.onSuccess(result, ...args));
+      }
+      if (options?.invalidates) {
+        for (const resource of options.invalidates) {
+          resource.refetch();
+        }
+      }
+      setPending(false);
+      return result;
+    } catch (err) {
+      if (options?.onError) {
+        try {
+          chunk27QSSN4E_cjs.batch(() => options.onError(err, ...args));
+        } catch {
+        }
+      }
+      setError(err);
+      setPending(false);
+      throw err;
+    }
+  };
+  const typedAction = action;
+  typedAction.pending = pending;
+  typedAction.error = error;
+  typedAction.clearError = () => setError(void 0);
+  return typedAction;
+}
+
+// src/server/mutation.ts
+var resourceRegistry = /* @__PURE__ */ new Map();
+function registerResource(key, resource) {
+  resourceRegistry.set(key, resource);
+}
+function unregisterResource(key) {
+  resourceRegistry.delete(key);
+}
+function applyRevalidation(revalidateData) {
+  for (const [key, freshData] of Object.entries(revalidateData)) {
+    const resource = resourceRegistry.get(key);
+    if (resource) {
+      resource.mutate(freshData);
+    }
+  }
+}
+function enableAutoRevalidation() {
+  const handler = (event) => {
+    const detail = event.detail;
+    if (detail && typeof detail === "object") {
+      applyRevalidation(detail);
+    }
+  };
+  window.addEventListener("forma:revalidate", handler);
+  return () => window.removeEventListener("forma:revalidate", handler);
+}
+function withRevalidation(data, revalidate) {
+  return { data, __revalidate: revalidate };
+}
+
+// src/server/rpc-client.ts
+function $$serverFunction(endpoint) {
+  const rpcFn = async (...args) => {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Forma-RPC": "1"
+      },
+      body: JSON.stringify({ args })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Server function failed (${response.status}): ${errorText}`);
+    }
+    const result = await response.json();
+    if (result && typeof result === "object" && "__revalidate" in result) {
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent("forma:revalidate", {
+          detail: result.__revalidate
+        }));
+      }
+      return result.data;
+    }
+    return result;
+  };
+  return rpcFn;
+}
+
+// src/server/rpc-handler.ts
+var registry = /* @__PURE__ */ new Map();
+function registerServerFunction(endpoint, fn) {
+  registry.set(endpoint, fn);
+}
+function getServerFunction(endpoint) {
+  return registry.get(endpoint);
+}
+function getRegisteredEndpoints() {
+  return [...registry.keys()];
+}
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+async function handleRPC(endpoint, body, revalidateData) {
+  const endpointName = endpoint.split("/").pop() ?? "";
+  if (FORBIDDEN_KEYS.has(endpointName)) {
+    return { error: "Forbidden endpoint name" };
+  }
+  const fn = registry.get(endpoint);
+  if (!fn) {
+    return { error: `Unknown server function: ${endpoint}` };
+  }
+  try {
+    const result = await fn(...body.args);
+    if (revalidateData) {
+      return { data: result, __revalidate: revalidateData };
+    }
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: message };
+  }
+}
+function createRPCMiddleware() {
+  return async (req, res) => {
+    if (req.method !== "POST") {
+      res.status(405).json({ error: "Method not allowed" });
+      return;
+    }
+    const body = req.body;
+    if (!body || !Array.isArray(body.args)) {
+      res.status(400).json({ error: "Invalid RPC request: missing args array" });
+      return;
+    }
+    const result = await handleRPC(req.url, body);
+    if (result.error) {
+      res.status(500).json(result);
+    } else {
+      res.json(result);
+    }
+  };
+}
+
+// src/wasm/forma-wasm.ts
+var wasmModule = null;
+var irCache = /* @__PURE__ */ new Map();
+async function ensureWasm() {
+  if (wasmModule) return wasmModule;
+  const config = window.__FORMA_WASM__;
+  if (!config) throw new Error("No __FORMA_WASM__ config");
+  const mod = await import(
+    /* @vite-ignore */
+    config.loader
+  );
+  await mod.default(config.binary);
+  wasmModule = mod;
+  return wasmModule;
+}
+async function getIR() {
+  const config = window.__FORMA_WASM__;
+  if (!config) throw new Error("No __FORMA_WASM__ config");
+  const cached = irCache.get(config.ir);
+  if (cached) return cached;
+  const response = await fetch(config.ir);
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  irCache.set(config.ir, bytes);
+  return bytes;
+}
+async function renderLocal(slotsJson) {
+  const [wasm, ir] = await Promise.all([ensureWasm(), getIR()]);
+  return wasm.render(ir, slotsJson);
+}
+async function renderIsland(slotsJson, islandId) {
+  const [wasm, ir] = await Promise.all([ensureWasm(), getIR()]);
+  return wasm.render_island(ir, slotsJson, islandId);
+}
+
+Object.defineProperty(exports, "batch", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.batch; }
+});
+Object.defineProperty(exports, "cleanup", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.cleanup; }
+});
+Object.defineProperty(exports, "createEffect", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createEffect; }
+});
+Object.defineProperty(exports, "createList", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createList; }
+});
+Object.defineProperty(exports, "createMemo", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createMemo; }
+});
+Object.defineProperty(exports, "createReducer", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createReducer; }
+});
+Object.defineProperty(exports, "createRef", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createRef; }
+});
+Object.defineProperty(exports, "createResource", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createResource; }
+});
+Object.defineProperty(exports, "createRoot", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createRoot; }
+});
+Object.defineProperty(exports, "createShow", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.createShow; }
+});
+Object.defineProperty(exports, "fragment", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.fragment; }
+});
+Object.defineProperty(exports, "h", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.h; }
+});
+Object.defineProperty(exports, "hydrateIsland", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.hydrateIsland; }
+});
+Object.defineProperty(exports, "longestIncreasingSubsequence", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.longestIncreasingSubsequence; }
+});
+Object.defineProperty(exports, "on", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.on; }
+});
+Object.defineProperty(exports, "onCleanup", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.onCleanup; }
+});
+Object.defineProperty(exports, "onError", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.onError; }
+});
+Object.defineProperty(exports, "reconcileList", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.reconcileList; }
+});
+Object.defineProperty(exports, "untrack", {
+  enumerable: true,
+  get: function () { return chunk27QSSN4E_cjs.untrack; }
+});
+Object.defineProperty(exports, "createComputed", {
+  enumerable: true,
+  get: function () { return chunkFPSLC62A_cjs.createComputed; }
+});
+Object.defineProperty(exports, "createSignal", {
+  enumerable: true,
+  get: function () { return chunkFPSLC62A_cjs.createSignal; }
+});
+exports.$ = $;
+exports.$$ = $$;
+exports.$$serverFunction = $$serverFunction;
+exports.activateIslands = activateIslands;
+exports.addClass = addClass;
+exports.applyRevalidation = applyRevalidation;
+exports.children = children;
+exports.closest = closest;
+exports.createAction = createAction;
+exports.createBus = createBus;
+exports.createContext = createContext;
+exports.createErrorBoundary = createErrorBoundary;
+exports.createFetch = createFetch;
+exports.createHistory = createHistory;
+exports.createIndexedDB = createIndexedDB;
+exports.createLocalStorage = createLocalStorage;
+exports.createPortal = createPortal;
+exports.createRPCMiddleware = createRPCMiddleware;
+exports.createSSE = createSSE;
+exports.createSessionStorage = createSessionStorage;
+exports.createStore = createStore;
+exports.createSuspense = createSuspense;
+exports.createSwitch = createSwitch;
+exports.createText = createText;
+exports.createWebSocket = createWebSocket;
+exports.defineComponent = defineComponent;
+exports.delegate = delegate;
+exports.disposeComponent = disposeComponent;
+exports.enableAutoRevalidation = enableAutoRevalidation;
+exports.fetchJSON = fetchJSON;
+exports.getRegisteredEndpoints = getRegisteredEndpoints;
+exports.getServerFunction = getServerFunction;
+exports.handleRPC = handleRPC;
+exports.inject = inject;
+exports.mount = mount;
+exports.nextSibling = nextSibling;
+exports.onIntersect = onIntersect;
+exports.onKey = onKey;
+exports.onMount = onMount;
+exports.onMutation = onMutation;
+exports.onResize = onResize;
+exports.onUnmount = onUnmount;
+exports.parent = parent;
+exports.persist = persist;
+exports.prevSibling = prevSibling;
+exports.provide = provide;
+exports.registerResource = registerResource;
+exports.registerServerFunction = registerServerFunction;
+exports.removeClass = removeClass;
+exports.renderIsland = renderIsland;
+exports.renderLocal = renderLocal;
+exports.setAttr = setAttr;
+exports.setHTML = setHTML;
+exports.setStyle = setStyle;
+exports.setText = setText;
+exports.siblings = siblings;
+exports.toggleClass = toggleClass;
+exports.trackDisposer = trackDisposer;
+exports.unprovide = unprovide;
+exports.unregisterResource = unregisterResource;
+exports.withRevalidation = withRevalidation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map