@getforma/core 0.1.0

package/dist/chunk-27QSSN4E.cjs

@@ -0,0 +1,1773 @@
+'use strict';
+
+var chunkFPSLC62A_cjs = require('./chunk-FPSLC62A.cjs');
+var alienSignals = require('alien-signals');
+
+// src/reactive/root.ts
+var currentRoot = null;
+var rootStack = [];
+function createRoot(fn) {
+  const scope = { disposers: [] };
+  rootStack.push(currentRoot);
+  currentRoot = scope;
+  const dispose = () => {
+    for (const d of scope.disposers) {
+      try {
+        d();
+      } catch {
+      }
+    }
+    scope.disposers.length = 0;
+  };
+  try {
+    return fn(dispose);
+  } finally {
+    currentRoot = rootStack.pop() ?? null;
+    if (rootStack.length === 0 && rootStack.length !== rootStack.__capacity) {
+      rootStack.length = 0;
+    }
+  }
+}
+function registerDisposer(dispose) {
+  if (currentRoot) {
+    currentRoot.disposers.push(dispose);
+  }
+}
+function hasActiveRoot() {
+  return currentRoot !== null;
+}
+
+// src/reactive/cleanup.ts
+var currentCleanupCollector = null;
+function onCleanup(fn) {
+  currentCleanupCollector?.(fn);
+}
+function setCleanupCollector(collector) {
+  const prev = currentCleanupCollector;
+  currentCleanupCollector = collector;
+  return prev;
+}
+
+// src/reactive/dev.ts
+var __DEV__ = typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
+var _errorHandler = null;
+function onError(handler) {
+  _errorHandler = handler;
+}
+function reportError(error, source) {
+  if (_errorHandler) {
+    try {
+      _errorHandler(error, source ? { source } : {});
+    } catch {
+    }
+  }
+  if (__DEV__) {
+    console.error(`[forma] ${source ?? "Unknown"} error:`, error);
+  }
+}
+var POOL_SIZE = 32;
+var MAX_REENTRANT_RUNS = 100;
+var pool = [];
+for (let i = 0; i < POOL_SIZE; i++) pool.push([]);
+var poolIdx = POOL_SIZE;
+function acquireArray() {
+  if (poolIdx > 0) {
+    const arr = pool[--poolIdx];
+    arr.length = 0;
+    return arr;
+  }
+  return [];
+}
+function releaseArray(arr) {
+  arr.length = 0;
+  if (poolIdx < POOL_SIZE) {
+    pool[poolIdx++] = arr;
+  }
+}
+function runCleanup(fn) {
+  if (fn === void 0) return;
+  try {
+    fn();
+  } catch (e) {
+    reportError(e, "effect cleanup");
+  }
+}
+function runCleanups(bag) {
+  if (bag === void 0) return;
+  for (let i = 0; i < bag.length; i++) {
+    try {
+      bag[i]();
+    } catch (e) {
+      reportError(e, "effect cleanup");
+    }
+  }
+}
+function internalEffect(fn) {
+  const dispose = alienSignals.effect(fn);
+  if (hasActiveRoot()) {
+    registerDisposer(dispose);
+  }
+  return dispose;
+}
+function createEffect(fn) {
+  const shouldRegister = hasActiveRoot();
+  let cleanup2;
+  let cleanupBag;
+  let nextCleanup;
+  let nextCleanupBag;
+  const addCleanup = (cb) => {
+    if (nextCleanupBag !== void 0) {
+      nextCleanupBag.push(cb);
+      return;
+    }
+    if (nextCleanup !== void 0) {
+      const bag = acquireArray();
+      bag.push(nextCleanup, cb);
+      nextCleanup = void 0;
+      nextCleanupBag = bag;
+      return;
+    }
+    nextCleanup = cb;
+  };
+  let skipCleanupInfra = false;
+  let firstRun = true;
+  let running = false;
+  let rerunRequested = false;
+  const runOnce = () => {
+    if (cleanup2 !== void 0) {
+      runCleanup(cleanup2);
+      cleanup2 = void 0;
+    }
+    if (cleanupBag !== void 0) {
+      runCleanups(cleanupBag);
+      releaseArray(cleanupBag);
+      cleanupBag = void 0;
+    }
+    if (skipCleanupInfra) {
+      try {
+        fn();
+      } catch (e) {
+        reportError(e, "effect");
+      }
+      return;
+    }
+    nextCleanup = void 0;
+    nextCleanupBag = void 0;
+    const prevCollector = setCleanupCollector(addCleanup);
+    try {
+      const result = fn();
+      if (typeof result === "function") {
+        addCleanup(result);
+      }
+      if (nextCleanup === void 0 && nextCleanupBag === void 0) {
+        if (firstRun) skipCleanupInfra = true;
+        return;
+      }
+      if (nextCleanupBag !== void 0) {
+        cleanupBag = nextCleanupBag;
+      } else {
+        cleanup2 = nextCleanup;
+      }
+    } catch (e) {
+      reportError(e, "effect");
+      if (nextCleanupBag !== void 0) {
+        cleanupBag = nextCleanupBag;
+      } else {
+        cleanup2 = nextCleanup;
+      }
+    } finally {
+      setCleanupCollector(prevCollector);
+      firstRun = false;
+    }
+  };
+  const safeFn = () => {
+    if (running) {
+      rerunRequested = true;
+      return;
+    }
+    running = true;
+    try {
+      let reentrantRuns = 0;
+      do {
+        rerunRequested = false;
+        runOnce();
+        if (rerunRequested) {
+          reentrantRuns++;
+          if (reentrantRuns >= MAX_REENTRANT_RUNS) {
+            reportError(
+              new Error(`createEffect exceeded ${MAX_REENTRANT_RUNS} re-entrant runs`),
+              "effect"
+            );
+            rerunRequested = false;
+          }
+        }
+      } while (rerunRequested);
+    } finally {
+      running = false;
+    }
+  };
+  const dispose = alienSignals.effect(safeFn);
+  let disposed = false;
+  const wrappedDispose = () => {
+    if (disposed) return;
+    disposed = true;
+    dispose();
+    if (cleanup2 !== void 0) {
+      runCleanup(cleanup2);
+      cleanup2 = void 0;
+    }
+    if (cleanupBag !== void 0) {
+      runCleanups(cleanupBag);
+      releaseArray(cleanupBag);
+      cleanupBag = void 0;
+    }
+  };
+  if (shouldRegister) {
+    registerDisposer(wrappedDispose);
+  }
+  return wrappedDispose;
+}
+
+// src/reactive/memo.ts
+var createMemo = chunkFPSLC62A_cjs.createComputed;
+function batch(fn) {
+  alienSignals.startBatch();
+  try {
+    fn();
+  } finally {
+    alienSignals.endBatch();
+  }
+}
+function untrack(fn) {
+  alienSignals.pauseTracking();
+  try {
+    return fn();
+  } finally {
+    alienSignals.resumeTracking();
+  }
+}
+
+// src/reactive/on.ts
+function on(deps, fn, options) {
+  let prev;
+  let isFirst = true;
+  return () => {
+    const value2 = deps();
+    if (options?.defer && isFirst) {
+      isFirst = false;
+      prev = value2;
+      return void 0;
+    }
+    const result = untrack(() => fn(value2, prev));
+    prev = value2;
+    return result;
+  };
+}
+
+// src/reactive/ref.ts
+function createRef(initialValue) {
+  return { current: initialValue };
+}
+
+// src/reactive/reducer.ts
+function createReducer(reducer, initialState) {
+  const [state, setState] = chunkFPSLC62A_cjs.createSignal(initialState);
+  const dispatch = (action) => {
+    setState((prev) => reducer(prev, action));
+  };
+  return [state, dispatch];
+}
+
+// src/reactive/suspense-context.ts
+var currentSuspenseContext = null;
+var suspenseStack = [];
+function pushSuspenseContext(ctx) {
+  suspenseStack.push(currentSuspenseContext);
+  currentSuspenseContext = ctx;
+}
+function popSuspenseContext() {
+  currentSuspenseContext = suspenseStack.pop() ?? null;
+}
+function getSuspenseContext() {
+  return currentSuspenseContext;
+}
+
+// src/reactive/resource.ts
+function createResource(source, fetcher, options) {
+  const [data, setData] = chunkFPSLC62A_cjs.createSignal(options?.initialValue);
+  const [loading, setLoading] = chunkFPSLC62A_cjs.createValueSignal(false);
+  const [error, setError] = chunkFPSLC62A_cjs.createValueSignal(void 0);
+  const suspenseCtx = getSuspenseContext();
+  let abortController = null;
+  let fetchVersion = 0;
+  const doFetch = () => {
+    const sourceValue = untrack(source);
+    if (abortController) {
+      abortController.abort();
+    }
+    const controller = new AbortController();
+    abortController = controller;
+    const version = ++fetchVersion;
+    const isLatest = () => version === fetchVersion;
+    let suspensePending = false;
+    if (suspenseCtx) {
+      suspenseCtx.increment();
+      suspensePending = true;
+    }
+    setLoading(true);
+    setError(void 0);
+    Promise.resolve(fetcher(sourceValue)).then((result) => {
+      if (isLatest() && !controller.signal.aborted) {
+        setData(() => result);
+      }
+    }).catch((err) => {
+      if (isLatest() && !controller.signal.aborted) {
+        if (err?.name !== "AbortError") {
+          setError(err);
+        }
+      }
+    }).finally(() => {
+      if (suspensePending) suspenseCtx?.decrement();
+      if (isLatest()) {
+        setLoading(false);
+        if (abortController === controller) {
+          abortController = null;
+        }
+      }
+    });
+  };
+  internalEffect(() => {
+    source();
+    doFetch();
+  });
+  const resource = (() => data());
+  resource.loading = loading;
+  resource.error = error;
+  resource.refetch = doFetch;
+  resource.mutate = (value2) => setData(() => value2);
+  return resource;
+}
+
+// src/dom/element.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var SVG_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "g",
+  "text",
+  "tspan",
+  "textPath",
+  "defs",
+  "use",
+  "symbol",
+  "clipPath",
+  "mask",
+  "pattern",
+  "marker",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "filter",
+  "feGaussianBlur",
+  "feColorMatrix",
+  "feOffset",
+  "feBlend",
+  "feMerge",
+  "feMergeNode",
+  "feComposite",
+  "feFlood",
+  "feMorphology",
+  "feTurbulence",
+  "feDisplacementMap",
+  "feImage",
+  "foreignObject",
+  "animate",
+  "animateTransform",
+  "animateMotion",
+  "set",
+  "image",
+  "switch",
+  "desc",
+  "title",
+  "metadata"
+]);
+var BOOLEAN_ATTRS = /* @__PURE__ */ new Set([
+  "disabled",
+  "checked",
+  "readonly",
+  "required",
+  "autofocus",
+  "autoplay",
+  "controls",
+  "default",
+  "defer",
+  "formnovalidate",
+  "hidden",
+  "ismap",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "reversed",
+  "selected",
+  "async"
+]);
+var ELEMENT_PROTOS = null;
+function getProto(tag) {
+  if (!ELEMENT_PROTOS) {
+    ELEMENT_PROTOS = /* @__PURE__ */ Object.create(null);
+    for (const t of [
+      "div",
+      "span",
+      "p",
+      "a",
+      "li",
+      "ul",
+      "ol",
+      "button",
+      "input",
+      "label",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "section",
+      "header",
+      "footer",
+      "main",
+      "nav",
+      "table",
+      "tr",
+      "td",
+      "th",
+      "tbody",
+      "img",
+      "form",
+      "select",
+      "option",
+      "textarea",
+      "i",
+      "b",
+      "strong",
+      "em",
+      "small",
+      "article",
+      "aside",
+      "details",
+      "summary"
+    ]) {
+      ELEMENT_PROTOS[t] = document.createElement(t);
+    }
+  }
+  return ELEMENT_PROTOS[tag] ?? (ELEMENT_PROTOS[tag] = document.createElement(tag));
+}
+var EVENT_NAMES = /* @__PURE__ */ Object.create(null);
+function eventName(key) {
+  return EVENT_NAMES[key] ?? (EVENT_NAMES[key] = key.slice(2).toLowerCase());
+}
+var ABORT_SYM = /* @__PURE__ */ Symbol.for("forma-abort");
+function getAbortController(el) {
+  let controller = el[ABORT_SYM];
+  if (!controller) {
+    controller = new AbortController();
+    el[ABORT_SYM] = controller;
+  }
+  return controller;
+}
+function cleanup(el) {
+  const controller = el[ABORT_SYM];
+  if (controller) {
+    controller.abort();
+    delete el[ABORT_SYM];
+  }
+}
+var CACHE_SYM = /* @__PURE__ */ Symbol.for("forma-attr-cache");
+var DYNAMIC_CHILD_SYM = /* @__PURE__ */ Symbol.for("forma-dynamic-child");
+function getCache(el) {
+  return el[CACHE_SYM] ?? (el[CACHE_SYM] = /* @__PURE__ */ Object.create(null));
+}
+function handleClass(el, _key, value2) {
+  if (typeof value2 === "function") {
+    internalEffect(() => {
+      const v = value2();
+      const cache = getCache(el);
+      if (cache["class"] === v) return;
+      cache["class"] = v;
+      if (el instanceof HTMLElement) {
+        el.className = v;
+      } else {
+        el.setAttribute("class", v);
+      }
+    });
+  } else {
+    const cache = getCache(el);
+    if (cache["class"] === value2) return;
+    cache["class"] = value2;
+    if (el instanceof HTMLElement) {
+      el.className = value2;
+    } else {
+      el.setAttribute("class", value2);
+    }
+  }
+}
+function handleStyle(el, _key, value2) {
+  if (typeof value2 === "function") {
+    let prevKeys = [];
+    internalEffect(() => {
+      const v = value2();
+      if (typeof v === "string") {
+        const cache = getCache(el);
+        if (cache["style"] === v) return;
+        cache["style"] = v;
+        prevKeys = [];
+        el.style.cssText = v;
+      } else if (v && typeof v === "object") {
+        const style = el.style;
+        const nextKeys = Object.keys(v);
+        for (const k of prevKeys) {
+          if (!(k in v)) {
+            style.removeProperty(k.replace(/[A-Z]/g, (c) => "-" + c.toLowerCase()));
+          }
+        }
+        Object.assign(style, v);
+        prevKeys = nextKeys;
+      }
+    });
+  } else if (typeof value2 === "string") {
+    const cache = getCache(el);
+    if (cache["style"] === value2) return;
+    cache["style"] = value2;
+    el.style.cssText = value2;
+  } else if (value2 && typeof value2 === "object") {
+    Object.assign(el.style, value2);
+  }
+}
+function handleEvent(el, key, value2) {
+  const controller = getAbortController(el);
+  el.addEventListener(
+    eventName(key),
+    value2,
+    { signal: controller.signal }
+  );
+}
+function handleInnerHTML(el, _key, value2) {
+  const v = value2;
+  el.innerHTML = v.__html;
+}
+function handleXLink(el, key, value2) {
+  const localName = key.slice(6);
+  if (typeof value2 === "function") {
+    internalEffect(() => {
+      const v = value2();
+      if (v == null || v === false) {
+        el.removeAttributeNS(XLINK_NS, localName);
+      } else {
+        el.setAttributeNS(XLINK_NS, key, String(v));
+      }
+    });
+  } else {
+    if (value2 == null || value2 === false) {
+      el.removeAttributeNS(XLINK_NS, localName);
+    } else {
+      el.setAttributeNS(XLINK_NS, key, String(value2));
+    }
+  }
+}
+function handleBooleanAttr(el, key, value2) {
+  if (typeof value2 === "function") {
+    internalEffect(() => {
+      const v = value2();
+      const cache = getCache(el);
+      if (cache[key] === v) return;
+      cache[key] = v;
+      if (v) {
+        el.setAttribute(key, "");
+      } else {
+        el.removeAttribute(key);
+      }
+    });
+  } else {
+    const cache = getCache(el);
+    if (cache[key] === value2) return;
+    cache[key] = value2;
+    if (value2) {
+      el.setAttribute(key, "");
+    } else {
+      el.removeAttribute(key);
+    }
+  }
+}
+function handleGenericAttr(el, key, value2) {
+  if (typeof value2 === "function") {
+    internalEffect(() => {
+      const v = value2();
+      if (v == null || v === false) {
+        const cache = getCache(el);
+        if (cache[key] === null) return;
+        cache[key] = null;
+        el.removeAttribute(key);
+      } else {
+        const strVal = String(v);
+        const cache = getCache(el);
+        if (cache[key] === strVal) return;
+        cache[key] = strVal;
+        el.setAttribute(key, strVal);
+      }
+    });
+  } else {
+    if (value2 == null || value2 === false) {
+      const cache = getCache(el);
+      if (cache[key] === null) return;
+      cache[key] = null;
+      el.removeAttribute(key);
+    } else {
+      const strVal = String(value2);
+      const cache = getCache(el);
+      if (cache[key] === strVal) return;
+      cache[key] = strVal;
+      el.setAttribute(key, strVal);
+    }
+  }
+}
+var PROP_HANDLERS = /* @__PURE__ */ new Map();
+PROP_HANDLERS.set("class", handleClass);
+PROP_HANDLERS.set("className", handleClass);
+PROP_HANDLERS.set("style", handleStyle);
+PROP_HANDLERS.set("ref", () => {
+});
+PROP_HANDLERS.set("dangerouslySetInnerHTML", handleInnerHTML);
+for (const attr of BOOLEAN_ATTRS) {
+  PROP_HANDLERS.set(attr, handleBooleanAttr);
+}
+function applyProp(el, key, value2) {
+  if (key === "class") {
+    handleClass(el, key, value2);
+    return;
+  }
+  if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.length > 2) {
+    handleEvent(el, key, value2);
+    return;
+  }
+  const handler = PROP_HANDLERS.get(key);
+  if (handler) {
+    handler(el, key, value2);
+    return;
+  }
+  if (key.charCodeAt(0) === 120 && key.startsWith("xlink:")) {
+    handleXLink(el, key, value2);
+    return;
+  }
+  handleGenericAttr(el, key, value2);
+}
+function applyStaticProp(el, key, value2) {
+  if (value2 == null || value2 === false) return;
+  if (key === "class" || key === "className") {
+    el.className = value2;
+    return;
+  }
+  if (key === "style") {
+    if (typeof value2 === "string") {
+      el.style.cssText = value2;
+    } else if (value2 && typeof value2 === "object") {
+      Object.assign(el.style, value2);
+    }
+    return;
+  }
+  if (key === "dangerouslySetInnerHTML") {
+    el.innerHTML = value2.__html;
+    return;
+  }
+  if (key.charCodeAt(0) === 120 && key.startsWith("xlink:")) {
+    el.setAttributeNS(XLINK_NS, key, String(value2));
+    return;
+  }
+  if (BOOLEAN_ATTRS.has(key)) {
+    if (value2) el.setAttribute(key, "");
+    return;
+  }
+  if (value2 === true) {
+    el.setAttribute(key, "");
+  } else {
+    el.setAttribute(key, String(value2));
+  }
+}
+function appendChild(parent, child) {
+  if (child instanceof Node) {
+    parent.appendChild(child);
+    return;
+  }
+  if (typeof child === "string") {
+    parent.appendChild(new Text(child));
+    return;
+  }
+  if (child == null || child === false || child === true) {
+    return;
+  }
+  if (typeof child === "number") {
+    parent.appendChild(new Text(String(child)));
+    return;
+  }
+  if (typeof child === "function") {
+    if (parent instanceof Element) {
+      parent[DYNAMIC_CHILD_SYM] = true;
+    }
+    let currentNode = null;
+    internalEffect(() => {
+      const v = child();
+      if (v instanceof Node) {
+        if (currentNode) {
+          parent.replaceChild(v, currentNode);
+        } else {
+          parent.appendChild(v);
+        }
+        currentNode = v;
+      } else {
+        const text = typeof v === "symbol" ? String(v) : String(v ?? "");
+        if (!currentNode) {
+          currentNode = new Text(text);
+          parent.appendChild(currentNode);
+        } else if (currentNode.nodeType === 3) {
+          currentNode.data = text;
+        } else {
+          const tn = new Text(text);
+          parent.replaceChild(tn, currentNode);
+          currentNode = tn;
+        }
+      }
+    });
+    return;
+  }
+  if (Array.isArray(child)) {
+    for (const item of child) {
+      appendChild(parent, item);
+    }
+    return;
+  }
+}
+function h(tag, props, ...children) {
+  if (hydrating) {
+    return { type: "element", tag, props: props ?? null, children };
+  }
+  let el;
+  if (ELEMENT_PROTOS && ELEMENT_PROTOS[tag]) {
+    el = ELEMENT_PROTOS[tag].cloneNode(false);
+  } else if (SVG_TAGS.has(tag)) {
+    el = document.createElementNS(SVG_NS, tag);
+  } else {
+    el = getProto(tag).cloneNode(false);
+  }
+  if (props) {
+    let hasDynamic = false;
+    for (const key in props) {
+      if (key === "ref") continue;
+      const value2 = props[key];
+      if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.length > 2) {
+        handleEvent(el, key, value2);
+        continue;
+      }
+      if (typeof value2 === "function") {
+        if (!hasDynamic) {
+          el[CACHE_SYM] = /* @__PURE__ */ Object.create(null);
+          hasDynamic = true;
+        }
+        applyProp(el, key, value2);
+        continue;
+      }
+      applyStaticProp(el, key, value2);
+    }
+  }
+  const childLen = children.length;
+  if (childLen === 1) {
+    const only = children[0];
+    if (typeof only === "string") {
+      el.textContent = only;
+    } else if (typeof only === "number") {
+      el.textContent = String(only);
+    } else {
+      appendChild(el, only);
+    }
+  } else if (childLen > 1) {
+    for (const child of children) {
+      appendChild(el, child);
+    }
+  }
+  if (props && typeof props["ref"] === "function") {
+    props["ref"](el);
+  }
+  return el;
+}
+function fragment(...children) {
+  const frag = document.createDocumentFragment();
+  for (const child of children) {
+    appendChild(frag, child);
+  }
+  return frag;
+}
+
+// src/dom/show.ts
+function createShow(when, thenFn, elseFn) {
+  if (hydrating) {
+    const branch = when() ? thenFn() : elseFn?.() ?? null;
+    return {
+      type: "show",
+      condition: when,
+      whenTrue: thenFn,
+      whenFalse: elseFn,
+      initialBranch: branch
+    };
+  }
+  const startMarker = document.createComment("forma-show");
+  const endMarker = document.createComment("/forma-show");
+  const fragment2 = document.createDocumentFragment();
+  fragment2.appendChild(startMarker);
+  fragment2.appendChild(endMarker);
+  let currentNode = null;
+  let lastTruthy = null;
+  let currentDispose = null;
+  const DEBUG_LABEL = thenFn.toString().slice(0, 60);
+  const showDispose = internalEffect(() => {
+    const truthy = !!when();
+    const DEBUG = typeof globalThis.__FORMA_DEBUG__ !== "undefined";
+    if (truthy === lastTruthy) {
+      if (DEBUG) console.log("[forma:show] skip (same)", truthy, DEBUG_LABEL);
+      return;
+    }
+    if (DEBUG) console.log("[forma:show]", lastTruthy, "\u2192", truthy, DEBUG_LABEL);
+    lastTruthy = truthy;
+    const parent = startMarker.parentNode;
+    if (!parent) {
+      if (DEBUG) console.warn("[forma:show] parentNode is null! skipping.", DEBUG_LABEL);
+      return;
+    }
+    if (DEBUG) console.log("[forma:show] parent:", parent.nodeName, "inDoc:", document.contains(parent));
+    if (currentDispose) {
+      currentDispose();
+      currentDispose = null;
+    }
+    if (currentNode) {
+      if (currentNode.parentNode === parent) {
+        parent.removeChild(currentNode);
+      } else {
+        while (startMarker.nextSibling && startMarker.nextSibling !== endMarker) {
+          parent.removeChild(startMarker.nextSibling);
+        }
+      }
+    }
+    const branchFn = truthy ? thenFn : elseFn;
+    if (branchFn) {
+      let branchDispose;
+      currentNode = createRoot((dispose) => {
+        branchDispose = dispose;
+        return untrack(() => branchFn());
+      });
+      currentDispose = branchDispose;
+    } else {
+      currentNode = null;
+    }
+    if (currentNode) {
+      parent.insertBefore(currentNode, endMarker);
+    }
+  });
+  fragment2.__showDispose = () => {
+    showDispose();
+    if (currentDispose) {
+      currentDispose();
+      currentDispose = null;
+    }
+  };
+  return fragment2;
+}
+
+// src/dom/hydrate.ts
+var hydrating = false;
+function setHydrating(value2) {
+  hydrating = value2;
+}
+function isDescriptor(v) {
+  return v != null && typeof v === "object" && v.type === "element";
+}
+function isShowDescriptor(v) {
+  return v != null && typeof v === "object" && v.type === "show";
+}
+function isListDescriptor(v) {
+  return v != null && typeof v === "object" && v.type === "list";
+}
+function applyDynamicProps(el, props) {
+  if (!props) return;
+  for (const key in props) {
+    const value2 = props[key];
+    if (typeof value2 !== "function") continue;
+    if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.length > 2) {
+      el.addEventListener(key.slice(2).toLowerCase(), value2);
+      continue;
+    }
+    const fn = value2;
+    const attrKey = key;
+    internalEffect(() => {
+      const v = fn();
+      if (v === false || v == null) {
+        el.removeAttribute(attrKey);
+      } else if (v === true) {
+        el.setAttribute(attrKey, "");
+      } else {
+        el.setAttribute(attrKey, String(v));
+      }
+    });
+  }
+}
+function ensureNode(value2) {
+  if (value2 instanceof Node) return value2;
+  if (value2 == null || value2 === false || value2 === true) return null;
+  if (typeof value2 === "string") return new Text(value2);
+  if (typeof value2 === "number") return new Text(String(value2));
+  if (isDescriptor(value2)) return descriptorToElement(value2);
+  if (isShowDescriptor(value2)) {
+    const prevH = hydrating;
+    hydrating = false;
+    try {
+      return createShow(
+        value2.condition,
+        () => ensureNode(value2.whenTrue()) ?? document.createComment("empty"),
+        value2.whenFalse ? () => ensureNode(value2.whenFalse()) ?? document.createComment("empty") : void 0
+      );
+    } finally {
+      hydrating = prevH;
+    }
+  }
+  if (isListDescriptor(value2)) {
+    const prevH = hydrating;
+    hydrating = false;
+    try {
+      return createList(value2.items, value2.keyFn, value2.renderFn, value2.options);
+    } finally {
+      hydrating = prevH;
+    }
+  }
+  return null;
+}
+function descriptorToElement(desc) {
+  const prevHydrating = hydrating;
+  hydrating = false;
+  try {
+    const children = desc.children.map((child) => {
+      if (isDescriptor(child)) return descriptorToElement(child);
+      if (isShowDescriptor(child)) return ensureNode(child);
+      if (isListDescriptor(child)) return ensureNode(child);
+      return child;
+    });
+    return h(desc.tag, desc.props, ...children);
+  } finally {
+    hydrating = prevHydrating;
+  }
+}
+function isIslandStart(data) {
+  return data.length >= 4 && data.charCodeAt(0) === 102 && data.charCodeAt(1) === 58 && data.charCodeAt(2) === 105;
+}
+function isShowStart(data) {
+  return data.length >= 4 && data.charCodeAt(0) === 102 && data.charCodeAt(1) === 58 && data.charCodeAt(2) === 115;
+}
+function isTextStart(data) {
+  return data.length >= 4 && data.charCodeAt(0) === 102 && data.charCodeAt(1) === 58 && data.charCodeAt(2) === 116;
+}
+function isListStart(data) {
+  return data.length >= 4 && data.charCodeAt(0) === 102 && data.charCodeAt(1) === 58 && data.charCodeAt(2) === 108;
+}
+function findClosingMarker(start) {
+  const closing = "/" + start.data;
+  let node = start.nextSibling;
+  while (node) {
+    if (node.nodeType === 8 && node.data === closing) {
+      return node;
+    }
+    node = node.nextSibling;
+  }
+  return null;
+}
+function findTextBetween(start, end) {
+  let node = start.nextSibling;
+  while (node && node !== end) {
+    if (node.nodeType === 3) return node;
+    node = node.nextSibling;
+  }
+  return null;
+}
+function nextElementBetweenMarkers(start, end) {
+  let node = start.nextSibling;
+  while (node && node !== end) {
+    if (node.nodeType === 1) return node;
+    node = node.nextSibling;
+  }
+  return void 0;
+}
+function extractContentBetweenMarkers(start, end) {
+  const frag = document.createDocumentFragment();
+  let node = start.nextSibling;
+  while (node && node !== end) {
+    const next = node.nextSibling;
+    frag.appendChild(node);
+    node = next;
+  }
+  return frag;
+}
+function setupShowEffect(desc, marker) {
+  let currentCondition = !!desc.condition();
+  let thenFragment = null;
+  let elseFragment = null;
+  const hasSSRContent = marker.start.nextSibling !== marker.end;
+  if (!hasSSRContent && currentCondition) {
+    if (__DEV__) console.warn("[forma] Hydration: show condition mismatch \u2014 SSR empty but client condition is true");
+    const trueBranch = desc.whenTrue();
+    if (trueBranch instanceof Node) {
+      marker.start.parentNode.insertBefore(trueBranch, marker.end);
+    }
+  }
+  internalEffect(() => {
+    const next = !!desc.condition();
+    if (next === currentCondition) return;
+    currentCondition = next;
+    const parent = marker.start.parentNode;
+    if (!parent) return;
+    const current = extractContentBetweenMarkers(marker.start, marker.end);
+    if (!next) {
+      thenFragment = current;
+    } else {
+      elseFragment = current;
+    }
+    let branch = next ? thenFragment ?? desc.whenTrue() : desc.whenFalse ? elseFragment ?? desc.whenFalse() : null;
+    if (next && thenFragment) thenFragment = null;
+    if (!next && elseFragment) elseFragment = null;
+    if (branch != null && !(branch instanceof Node)) {
+      branch = ensureNode(branch);
+    }
+    if (branch instanceof Node) {
+      parent.insertBefore(branch, marker.end);
+    }
+  });
+}
+function adoptBranchContent(desc, regionStart, regionEnd) {
+  if (isDescriptor(desc)) {
+    const el = nextElementBetweenMarkers(regionStart, regionEnd);
+    if (el) adoptNode(desc, el);
+  } else if (isShowDescriptor(desc)) {
+    let node = regionStart.nextSibling;
+    while (node && node !== regionEnd) {
+      if (node.nodeType === 8 && isShowStart(node.data)) {
+        const innerStart = node;
+        const innerEnd = findClosingMarker(innerStart);
+        if (innerEnd) {
+          if (desc.initialBranch) {
+            adoptBranchContent(desc.initialBranch, innerStart, innerEnd);
+          }
+          setupShowEffect(desc, { start: innerStart, end: innerEnd});
+        }
+        break;
+      }
+      node = node.nextSibling;
+    }
+  }
+}
+function adoptNode(desc, ssrEl) {
+  if (!ssrEl || ssrEl.tagName !== desc.tag.toUpperCase()) {
+    console.warn(`Hydration mismatch: expected <${desc.tag}>, got <${ssrEl?.tagName?.toLowerCase() ?? "nothing"}>`);
+    const fresh = descriptorToElement(desc);
+    if (ssrEl) ssrEl.replaceWith(fresh);
+    return;
+  }
+  applyDynamicProps(ssrEl, desc.props);
+  let cursor = ssrEl.firstChild;
+  for (const child of desc.children) {
+    if (child === false || child == null) continue;
+    if (isDescriptor(child)) {
+      while (cursor && cursor.nodeType === 3 && !cursor.data.trim()) {
+        cursor = cursor.nextSibling;
+      }
+      while (cursor && cursor.nodeType === 1 && cursor.hasAttribute("data-forma-island")) {
+        cursor = cursor.nextSibling;
+      }
+      if (!cursor) {
+        ssrEl.appendChild(descriptorToElement(child));
+        continue;
+      }
+      if (cursor.nodeType === 1) {
+        const el = cursor;
+        cursor = cursor.nextSibling;
+        adoptNode(child, el);
+      } else if (cursor.nodeType === 8 && isIslandStart(cursor.data)) {
+        const end = findClosingMarker(cursor);
+        const fresh = descriptorToElement(child);
+        if (end) {
+          end.parentNode.insertBefore(fresh, end);
+          cursor = end.nextSibling;
+        } else {
+          ssrEl.appendChild(fresh);
+          cursor = null;
+        }
+      } else {
+        ssrEl.appendChild(descriptorToElement(child));
+      }
+    } else if (isShowDescriptor(child)) {
+      while (cursor && !(cursor.nodeType === 8 && isShowStart(cursor.data))) {
+        cursor = cursor.nextSibling;
+      }
+      if (cursor) {
+        const start = cursor;
+        const end = findClosingMarker(start);
+        if (end) {
+          if (child.initialBranch) {
+            adoptBranchContent(child.initialBranch, start, end);
+          }
+          setupShowEffect(child, { start, end});
+          cursor = end.nextSibling;
+        }
+      }
+    } else if (isListDescriptor(child)) {
+      while (cursor && !(cursor.nodeType === 8 && isListStart(cursor.data))) {
+        cursor = cursor.nextSibling;
+      }
+      if (cursor) {
+        const start = cursor;
+        const end = findClosingMarker(start);
+        if (end) {
+          const ssrKeyMap = /* @__PURE__ */ new Map();
+          const ssrElements = [];
+          let node = start.nextSibling;
+          while (node && node !== end) {
+            if (node.nodeType === 1) {
+              const el = node;
+              ssrElements.push(el);
+              const key = el.getAttribute("data-forma-key");
+              if (key != null) {
+                ssrKeyMap.set(key, el);
+              }
+            }
+            node = node.nextSibling;
+          }
+          const currentItems = untrack(() => child.items());
+          const listKeyFn = child.keyFn;
+          const listRenderFn = child.renderFn;
+          const useIndexFallback = ssrKeyMap.size === 0 && ssrElements.length > 0;
+          const adoptedNodes = [];
+          const adoptedItems = [];
+          const usedIndices = /* @__PURE__ */ new Set();
+          for (let i = 0; i < currentItems.length; i++) {
+            const item = currentItems[i];
+            const key = listKeyFn(item);
+            let ssrNode;
+            if (useIndexFallback) {
+              if (i < ssrElements.length) {
+                ssrNode = ssrElements[i];
+                usedIndices.add(i);
+              }
+            } else {
+              ssrNode = ssrKeyMap.get(String(key));
+              if (ssrNode) ssrKeyMap.delete(String(key));
+            }
+            if (ssrNode) {
+              adoptedNodes.push(ssrNode);
+              adoptedItems.push(item);
+            } else {
+              if (__DEV__) console.warn(`[FormaJS] Hydration: list item key "${key}" not found in SSR \u2014 rendering fresh`);
+              const prevHydrating = hydrating;
+              hydrating = false;
+              try {
+                const [getIndex] = chunkFPSLC62A_cjs.createSignal(i);
+                const fresh = listRenderFn(item, getIndex);
+                end.parentNode.insertBefore(fresh, end);
+                adoptedNodes.push(fresh);
+                adoptedItems.push(item);
+              } finally {
+                hydrating = prevHydrating;
+              }
+            }
+          }
+          if (useIndexFallback) {
+            for (let i = 0; i < ssrElements.length; i++) {
+              if (!usedIndices.has(i) && ssrElements[i].parentNode) {
+                ssrElements[i].parentNode.removeChild(ssrElements[i]);
+              }
+            }
+          } else {
+            for (const [unusedKey, unusedNode] of ssrKeyMap) {
+              if (__DEV__) console.warn(`[FormaJS] Hydration: removing extra SSR list item with key "${unusedKey}"`);
+              if (unusedNode.parentNode) {
+                unusedNode.parentNode.removeChild(unusedNode);
+              }
+            }
+          }
+          const parent = start.parentNode;
+          for (const adoptedNode of adoptedNodes) {
+            parent.insertBefore(adoptedNode, end);
+          }
+          let cache = /* @__PURE__ */ new Map();
+          for (let i = 0; i < adoptedItems.length; i++) {
+            const item = adoptedItems[i];
+            const key = listKeyFn(item);
+            const [getIndex, setIndex] = chunkFPSLC62A_cjs.createSignal(i);
+            cache.set(key, {
+              element: adoptedNodes[i],
+              item,
+              getIndex,
+              setIndex
+            });
+          }
+          let reconcileNodes = adoptedNodes.slice();
+          let reconcileItems = adoptedItems.slice();
+          internalEffect(() => {
+            const newItems = child.items();
+            const parent2 = start.parentNode;
+            if (!parent2) return;
+            const result = reconcileList(
+              parent2,
+              reconcileItems,
+              newItems,
+              reconcileNodes,
+              listKeyFn,
+              (item) => {
+                const prevHydrating = hydrating;
+                hydrating = false;
+                try {
+                  const key = listKeyFn(item);
+                  const [getIndex, setIndex] = chunkFPSLC62A_cjs.createSignal(0);
+                  const element = untrack(() => listRenderFn(item, getIndex));
+                  cache.set(key, { element, item, getIndex, setIndex });
+                  return element;
+                } finally {
+                  hydrating = prevHydrating;
+                }
+              },
+              (_node, item) => {
+                const key = listKeyFn(item);
+                const cached = cache.get(key);
+                if (cached) cached.item = item;
+              },
+              end
+            );
+            const newCache = /* @__PURE__ */ new Map();
+            for (let i = 0; i < newItems.length; i++) {
+              const key = listKeyFn(newItems[i]);
+              const cached = cache.get(key);
+              if (cached) {
+                cached.setIndex(i);
+                newCache.set(key, cached);
+              }
+            }
+            cache = newCache;
+            reconcileNodes = result.nodes;
+            reconcileItems = result.items;
+          });
+          cursor = end.nextSibling;
+        }
+      }
+    } else if (typeof child === "function") {
+      while (cursor && cursor.nodeType === 3 && !cursor.data.trim()) {
+        cursor = cursor.nextSibling;
+      }
+      if (cursor && cursor.nodeType === 1) {
+        const initial = child();
+        if (isDescriptor(initial)) {
+          const el = cursor;
+          cursor = cursor.nextSibling;
+          adoptNode(initial, el);
+          continue;
+        }
+      }
+      if (cursor && cursor.nodeType === 8) {
+        const data = cursor.data;
+        if (isTextStart(data)) {
+          const endMarker = findClosingMarker(cursor);
+          let textNode = cursor.nextSibling;
+          if (!textNode || textNode.nodeType !== 3) {
+            if (__DEV__) console.warn(`[FormaJS] Hydration: created text node for marker ${data} \u2014 SSR walker should emit content between markers`);
+            const created = document.createTextNode("");
+            cursor.parentNode.insertBefore(created, endMarker || cursor.nextSibling);
+            textNode = created;
+          }
+          internalEffect(() => {
+            textNode.data = String(child());
+          });
+          cursor = endMarker ? endMarker.nextSibling : textNode.nextSibling;
+        } else if (isShowStart(data)) {
+          const start = cursor;
+          const end = findClosingMarker(start);
+          if (end) {
+            let textNode = findTextBetween(start, end);
+            if (!textNode) {
+              if (__DEV__) console.warn(`[FormaJS] Hydration: created text node for show marker ${start.data} \u2014 SSR walker should emit content between markers`);
+              textNode = document.createTextNode("");
+              start.parentNode.insertBefore(textNode, end);
+            }
+            internalEffect(() => {
+              textNode.data = String(child());
+            });
+            cursor = end.nextSibling;
+          } else {
+            cursor = cursor.nextSibling;
+          }
+        } else {
+          cursor = cursor.nextSibling;
+        }
+      } else if (cursor && cursor.nodeType === 3) {
+        const textNode = cursor;
+        cursor = cursor.nextSibling;
+        internalEffect(() => {
+          textNode.data = String(child());
+        });
+      } else {
+        if (__DEV__) console.warn(`[FormaJS] Hydration: created text node in empty <${ssrEl.tagName.toLowerCase()}> \u2014 IR may not cover this component`);
+        const textNode = document.createTextNode("");
+        ssrEl.appendChild(textNode);
+        internalEffect(() => {
+          textNode.data = String(child());
+        });
+      }
+    } else if (typeof child === "string" || typeof child === "number") {
+      if (cursor && cursor.nodeType === 3) {
+        cursor = cursor.nextSibling;
+      }
+    }
+  }
+}
+function hydrateIsland(component, target) {
+  const hasSSRContent = target.childElementCount > 0 || target.childNodes.length > 0 && Array.from(target.childNodes).some((n) => n.nodeType === 1 || n.nodeType === 3 && n.data.trim());
+  if (!hasSSRContent) {
+    if (__DEV__) {
+      const name = target.getAttribute("data-forma-component") || "unknown";
+      console.warn(
+        `[forma] Island "${name}" has no SSR content \u2014 falling back to CSR. This means the IR walker did not render content between ISLAND_START and ISLAND_END.`
+      );
+    }
+    const result = component();
+    if (result instanceof Element) {
+      for (const attr of Array.from(target.attributes)) {
+        if (attr.name.startsWith("data-forma-")) {
+          result.setAttribute(attr.name, attr.value);
+        }
+      }
+      target.replaceWith(result);
+      return result;
+    } else if (result instanceof Node) {
+      target.appendChild(result);
+    }
+    return target;
+  }
+  setHydrating(true);
+  let descriptor;
+  try {
+    descriptor = component();
+  } finally {
+    setHydrating(false);
+  }
+  if (!descriptor || !isDescriptor(descriptor)) {
+    target.removeAttribute("data-forma-ssr");
+    return target;
+  }
+  if (target.hasAttribute("data-forma-island")) {
+    adoptNode(descriptor, target);
+  } else {
+    adoptNode(descriptor, target.children[0]);
+  }
+  target.removeAttribute("data-forma-ssr");
+  return target;
+}
+
+// src/dom/list.ts
+function longestIncreasingSubsequence(arr) {
+  const n = arr.length;
+  if (n === 0) return [];
+  const tails = new Int32Array(n);
+  const tailIndices = new Int32Array(n);
+  const predecessor = new Int32Array(n).fill(-1);
+  let tailsLen = 0;
+  for (let i = 0; i < n; i++) {
+    const val = arr[i];
+    let lo = 0, hi = tailsLen;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (tails[mid] < val) lo = mid + 1;
+      else hi = mid;
+    }
+    tails[lo] = val;
+    tailIndices[lo] = i;
+    if (lo > 0) predecessor[i] = tailIndices[lo - 1];
+    if (lo >= tailsLen) tailsLen++;
+  }
+  const result = new Array(tailsLen);
+  let idx = tailIndices[tailsLen - 1];
+  for (let i = tailsLen - 1; i >= 0; i--) {
+    result[i] = idx;
+    idx = predecessor[idx];
+  }
+  return result;
+}
+var SMALL_LIST_THRESHOLD = 32;
+var ABORT_SYM2 = /* @__PURE__ */ Symbol.for("forma-abort");
+var CACHE_SYM2 = /* @__PURE__ */ Symbol.for("forma-attr-cache");
+var DYNAMIC_CHILD_SYM2 = /* @__PURE__ */ Symbol.for("forma-dynamic-child");
+function canPatchStaticElement(target, source) {
+  return target instanceof HTMLElement && source instanceof HTMLElement && target.tagName === source.tagName && !target[ABORT_SYM2] && !target[CACHE_SYM2] && !target[DYNAMIC_CHILD_SYM2] && !source[ABORT_SYM2] && !source[CACHE_SYM2] && !source[DYNAMIC_CHILD_SYM2];
+}
+function patchStaticElement(target, source) {
+  const sourceAttrNames = /* @__PURE__ */ new Set();
+  for (const attr of Array.from(source.attributes)) {
+    sourceAttrNames.add(attr.name);
+    if (target.getAttribute(attr.name) !== attr.value) {
+      target.setAttribute(attr.name, attr.value);
+    }
+  }
+  for (const attr of Array.from(target.attributes)) {
+    if (!sourceAttrNames.has(attr.name)) {
+      target.removeAttribute(attr.name);
+    }
+  }
+  target.replaceChildren(...Array.from(source.childNodes));
+}
+function reconcileSmall(parent, oldItems, newItems, oldNodes, keyFn, createFn, updateFn, beforeNode, hooks) {
+  const oldLen = oldItems.length;
+  const newLen = newItems.length;
+  const oldKeys = new Array(oldLen);
+  for (let i = 0; i < oldLen; i++) {
+    oldKeys[i] = keyFn(oldItems[i]);
+  }
+  const oldIndices = new Array(newLen);
+  const oldUsed = new Uint8Array(oldLen);
+  for (let i = 0; i < newLen; i++) {
+    const key = keyFn(newItems[i]);
+    let found = -1;
+    for (let j = 0; j < oldLen; j++) {
+      if (!oldUsed[j] && oldKeys[j] === key) {
+        found = j;
+        oldUsed[j] = 1;
+        break;
+      }
+    }
+    oldIndices[i] = found;
+  }
+  for (let i = 0; i < oldLen; i++) {
+    if (!oldUsed[i]) {
+      if (hooks?.onBeforeRemove) {
+        const node = oldNodes[i];
+        hooks.onBeforeRemove(node, () => {
+          if (node.parentNode) node.parentNode.removeChild(node);
+        });
+      } else {
+        parent.removeChild(oldNodes[i]);
+      }
+    }
+  }
+  if (oldLen === newLen) {
+    let allSameOrder = true;
+    for (let i = 0; i < newLen; i++) {
+      if (oldIndices[i] !== i) {
+        allSameOrder = false;
+        break;
+      }
+    }
+    if (allSameOrder) {
+      const nodes = new Array(newLen);
+      for (let i = 0; i < newLen; i++) {
+        const node = oldNodes[i];
+        updateFn(node, newItems[i]);
+        nodes[i] = node;
+      }
+      return { nodes, items: newItems };
+    }
+  }
+  const reusedIndices = [];
+  const reusedPositions = [];
+  for (let i = 0; i < newLen; i++) {
+    if (oldIndices[i] !== -1) {
+      reusedIndices.push(oldIndices[i]);
+      reusedPositions.push(i);
+    }
+  }
+  const lisOfReused = longestIncreasingSubsequence(reusedIndices);
+  const lisFlags = new Uint8Array(newLen);
+  for (const li of lisOfReused) {
+    lisFlags[reusedPositions[li]] = 1;
+  }
+  const newNodes = new Array(newLen);
+  let nextSibling = beforeNode ?? null;
+  for (let i = newLen - 1; i >= 0; i--) {
+    let node;
+    let isNew = false;
+    if (oldIndices[i] === -1) {
+      node = createFn(newItems[i]);
+      isNew = true;
+    } else {
+      node = oldNodes[oldIndices[i]];
+      updateFn(node, newItems[i]);
+      if (lisFlags[i]) {
+        newNodes[i] = node;
+        nextSibling = node;
+        continue;
+      }
+    }
+    if (nextSibling) {
+      parent.insertBefore(node, nextSibling);
+    } else {
+      parent.appendChild(node);
+    }
+    if (isNew) hooks?.onInsert?.(node);
+    newNodes[i] = node;
+    nextSibling = node;
+  }
+  return { nodes: newNodes, items: newItems };
+}
+function reconcileList(parent, oldItems, newItems, oldNodes, keyFn, createFn, updateFn, beforeNode, hooks) {
+  const oldLen = oldItems.length;
+  const newLen = newItems.length;
+  if (newLen === 0) {
+    for (let i = 0; i < oldLen; i++) {
+      if (hooks?.onBeforeRemove) {
+        const node = oldNodes[i];
+        hooks.onBeforeRemove(node, () => {
+          if (node.parentNode) node.parentNode.removeChild(node);
+        });
+      } else {
+        parent.removeChild(oldNodes[i]);
+      }
+    }
+    return { nodes: [], items: [] };
+  }
+  if (oldLen === 0) {
+    const nodes = new Array(newLen);
+    for (let i = 0; i < newLen; i++) {
+      const node = createFn(newItems[i]);
+      if (beforeNode) {
+        parent.insertBefore(node, beforeNode);
+      } else {
+        parent.appendChild(node);
+      }
+      hooks?.onInsert?.(node);
+      nodes[i] = node;
+    }
+    return { nodes, items: newItems };
+  }
+  if (oldLen < SMALL_LIST_THRESHOLD) {
+    return reconcileSmall(parent, oldItems, newItems, oldNodes, keyFn, createFn, updateFn, beforeNode, hooks);
+  }
+  const oldKeyMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < oldLen; i++) {
+    oldKeyMap.set(keyFn(oldItems[i]), i);
+  }
+  const oldIndices = new Array(newLen);
+  const oldUsed = new Uint8Array(oldLen);
+  for (let i = 0; i < newLen; i++) {
+    const key = keyFn(newItems[i]);
+    const oldIdx = oldKeyMap.get(key);
+    if (oldIdx !== void 0) {
+      oldIndices[i] = oldIdx;
+      oldUsed[oldIdx] = 1;
+    } else {
+      oldIndices[i] = -1;
+    }
+  }
+  for (let i = 0; i < oldLen; i++) {
+    if (!oldUsed[i]) {
+      if (hooks?.onBeforeRemove) {
+        const node = oldNodes[i];
+        hooks.onBeforeRemove(node, () => {
+          if (node.parentNode) node.parentNode.removeChild(node);
+        });
+      } else {
+        parent.removeChild(oldNodes[i]);
+      }
+    }
+  }
+  if (oldLen === newLen) {
+    let allSameOrder = true;
+    for (let i = 0; i < newLen; i++) {
+      if (oldIndices[i] !== i) {
+        allSameOrder = false;
+        break;
+      }
+    }
+    if (allSameOrder) {
+      const nodes = new Array(newLen);
+      for (let i = 0; i < newLen; i++) {
+        const node = oldNodes[i];
+        updateFn(node, newItems[i]);
+        nodes[i] = node;
+      }
+      return { nodes, items: newItems };
+    }
+  }
+  const reusedIndices = [];
+  const reusedPositions = [];
+  for (let i = 0; i < newLen; i++) {
+    if (oldIndices[i] !== -1) {
+      reusedIndices.push(oldIndices[i]);
+      reusedPositions.push(i);
+    }
+  }
+  const lisOfReused = longestIncreasingSubsequence(reusedIndices);
+  const lisFlags = new Uint8Array(newLen);
+  for (const li of lisOfReused) {
+    lisFlags[reusedPositions[li]] = 1;
+  }
+  const newNodes = new Array(newLen);
+  let nextSibling = beforeNode ?? null;
+  for (let i = newLen - 1; i >= 0; i--) {
+    let node;
+    let isNew = false;
+    if (oldIndices[i] === -1) {
+      node = createFn(newItems[i]);
+      isNew = true;
+    } else {
+      node = oldNodes[oldIndices[i]];
+      updateFn(node, newItems[i]);
+      if (lisFlags[i]) {
+        newNodes[i] = node;
+        nextSibling = node;
+        continue;
+      }
+    }
+    if (nextSibling) {
+      parent.insertBefore(node, nextSibling);
+    } else {
+      parent.appendChild(node);
+    }
+    if (isNew) hooks?.onInsert?.(node);
+    newNodes[i] = node;
+    nextSibling = node;
+  }
+  return { nodes: newNodes, items: newItems };
+}
+function createList(items, keyFn, renderFn, options) {
+  if (hydrating) {
+    return { type: "list", items, keyFn, renderFn, options };
+  }
+  const startMarker = document.createComment("forma-list-start");
+  const endMarker = document.createComment("forma-list-end");
+  const fragment2 = document.createDocumentFragment();
+  fragment2.appendChild(startMarker);
+  fragment2.appendChild(endMarker);
+  let cache = /* @__PURE__ */ new Map();
+  let currentNodes = [];
+  let currentItems = [];
+  const updateOnItemChange = options?.updateOnItemChange ?? "none";
+  internalEffect(() => {
+    const newItems = items();
+    const parent = startMarker.parentNode;
+    if (!parent) {
+      return;
+    }
+    if (!Array.isArray(newItems)) {
+      if (__DEV__) {
+        console.warn("[forma] createList: value is not an array, treating as empty");
+      }
+      for (const node of currentNodes) {
+        if (node.parentNode === parent) parent.removeChild(node);
+      }
+      cache = /* @__PURE__ */ new Map();
+      currentNodes = [];
+      currentItems = [];
+      return;
+    }
+    let cleanItems = newItems;
+    for (let i = 0; i < newItems.length; i++) {
+      if (newItems[i] == null) {
+        cleanItems = newItems.filter((item) => item != null);
+        break;
+      }
+    }
+    if (__DEV__) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of cleanItems) {
+        const key = keyFn(item);
+        if (seen.has(key)) {
+          console.warn("[forma] createList: duplicate key detected:", key);
+        }
+        seen.add(key);
+      }
+    }
+    const updateRow = updateOnItemChange === "rerender" ? (node, item) => {
+      const key = keyFn(item);
+      const cached = cache.get(key);
+      if (!cached) return;
+      if (cached.item === item) return;
+      cached.item = item;
+      if (!(node instanceof HTMLElement)) return;
+      if (node[ABORT_SYM2] || node[CACHE_SYM2] || node[DYNAMIC_CHILD_SYM2]) {
+        return;
+      }
+      const next = untrack(() => renderFn(item, cached.getIndex));
+      if (canPatchStaticElement(node, next)) {
+        patchStaticElement(node, next);
+        cached.element = node;
+      }
+    } : (_node, item) => {
+      const key = keyFn(item);
+      const cached = cache.get(key);
+      if (cached) cached.item = item;
+    };
+    const result = reconcileList(
+      parent,
+      currentItems,
+      cleanItems,
+      currentNodes,
+      keyFn,
+      // createFn: create element + cache entry
+      (item) => {
+        const key = keyFn(item);
+        const [getIndex, setIndex] = chunkFPSLC62A_cjs.createSignal(0);
+        const element = untrack(() => renderFn(item, getIndex));
+        cache.set(key, { element, item, getIndex, setIndex });
+        return element;
+      },
+      updateRow,
+      // beforeNode: insert items before the end marker
+      endMarker
+    );
+    const newCache = /* @__PURE__ */ new Map();
+    for (let i = 0; i < cleanItems.length; i++) {
+      const key = keyFn(cleanItems[i]);
+      const cached = cache.get(key);
+      if (cached) {
+        cached.setIndex(i);
+        newCache.set(key, cached);
+      }
+    }
+    cache = newCache;
+    currentNodes = result.nodes;
+    currentItems = result.items;
+  });
+  return fragment2;
+}
+
+exports.batch = batch;
+exports.cleanup = cleanup;
+exports.createEffect = createEffect;
+exports.createList = createList;
+exports.createMemo = createMemo;
+exports.createReducer = createReducer;
+exports.createRef = createRef;
+exports.createResource = createResource;
+exports.createRoot = createRoot;
+exports.createShow = createShow;
+exports.fragment = fragment;
+exports.h = h;
+exports.hydrateIsland = hydrateIsland;
+exports.internalEffect = internalEffect;
+exports.longestIncreasingSubsequence = longestIncreasingSubsequence;
+exports.on = on;
+exports.onCleanup = onCleanup;
+exports.onError = onError;
+exports.popSuspenseContext = popSuspenseContext;
+exports.pushSuspenseContext = pushSuspenseContext;
+exports.reconcileList = reconcileList;
+exports.untrack = untrack;
+//# sourceMappingURL=chunk-27QSSN4E.cjs.map
+//# sourceMappingURL=chunk-27QSSN4E.cjs.map