@solidjs/signals 0.8.2 → 0.8.4

package/dist/prod.js

@@ -1,716 +1,641 @@
-// src/core/error.ts
-var NotReadyError = class extends Error {
-  constructor(cause) {
+class NotReadyError extends Error {
+  cause;
+  constructor(e) {
     super();
-    this.cause = cause;
+    this.cause = e;
   }
-};
-var NoOwnerError = class extends Error {
+}
+class NoOwnerError extends Error {
   constructor() {
     super("");
   }
-};
-var ContextNotFoundError = class extends Error {
-  constructor() {
-    super(
-      ""
-    );
-  }
-};
-
-// src/core/constants.ts
-var NOT_PENDING = {};
-var SUPPORTS_PROXY = typeof Proxy === "function";
-
-// src/core/heap.ts
-function actualInsertIntoHeap(n, heap) {
-  const parentHeight = (n.w?._ ? n.w.$?.c : n.w?.c) ?? -1;
-  if (parentHeight >= n.c)
-    n.c = parentHeight + 1;
-  const height = n.c;
-  const heapAtHeight = heap.r[height];
-  if (heapAtHeight === void 0) {
-    heap.r[height] = n;
-  } else {
-    const tail = heapAtHeight.z;
-    tail.Q = n;
-    n.z = tail;
-    heapAtHeight.z = n;
-  }
-  if (height > heap.L) {
-    heap.L = height;
-  }
-}
-function insertIntoHeap(n, heap) {
-  let flags = n.b;
-  if (flags & (8 /* InHeap */ | 4 /* RecomputingDeps */))
-    return;
-  if (flags & 1 /* Check */) {
-    n.b = flags & ~(1 /* Check */ | 2 /* Dirty */) | 2 /* Dirty */ | 8 /* InHeap */;
-  } else
-    n.b = flags | 8 /* InHeap */;
-  if (!(flags & 16 /* InHeapHeight */)) {
-    actualInsertIntoHeap(n, heap);
-  }
-}
-function insertIntoHeapHeight(n, heap) {
-  let flags = n.b;
-  if (flags & (8 /* InHeap */ | 4 /* RecomputingDeps */ | 16 /* InHeapHeight */))
-    return;
-  n.b = flags | 16 /* InHeapHeight */;
-  actualInsertIntoHeap(n, heap);
-}
-function deleteFromHeap(n, heap) {
-  const flags = n.b;
-  if (!(flags & (8 /* InHeap */ | 16 /* InHeapHeight */)))
-    return;
-  n.b = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
-  const height = n.c;
-  if (n.z === n) {
-    heap.r[height] = void 0;
-  } else {
-    const next = n.Q;
-    const dhh = heap.r[height];
-    const end = next ?? dhh;
-    if (n === dhh) {
-      heap.r[height] = next;
-    } else {
-      n.z.Q = next;
-    }
-    end.z = n.z;
-  }
-  n.z = n;
-  n.Q = void 0;
 }
-function markHeap(heap) {
-  if (heap.aa)
-    return;
-  heap.aa = true;
-  for (let i = 0; i <= heap.L; i++) {
-    for (let el = heap.r[i]; el !== void 0; el = el.Q) {
-      if (el.b & 8 /* InHeap */)
-        markNode(el);
-    }
+class ContextNotFoundError extends Error {
+  constructor() {
+    super("");
   }
 }
-function markNode(el, newState = 2 /* Dirty */) {
-  const flags = el.b;
-  if ((flags & (1 /* Check */ | 2 /* Dirty */)) >= newState)
-    return;
-  el.b = flags & ~(1 /* Check */ | 2 /* Dirty */) | newState;
-  for (let link2 = el.s; link2 !== null; link2 = link2.A) {
-    markNode(link2.j, 1 /* Check */);
-  }
-  if (el.ba !== null) {
-    for (let child = el.ba; child !== null; child = child.ra) {
-      for (let link2 = child.s; link2 !== null; link2 = link2.A) {
-        markNode(link2.j, 1 /* Check */);
+const REACTIVE_NONE = 0;
+const REACTIVE_CHECK = 1 << 0;
+const REACTIVE_DIRTY = 1 << 1;
+const REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+const REACTIVE_IN_HEAP = 1 << 3;
+const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+const REACTIVE_ZOMBIE = 1 << 5;
+const REACTIVE_DISPOSED = 1 << 6;
+const STATUS_NONE = 0;
+const STATUS_PENDING = 1 << 0;
+const STATUS_ERROR = 1 << 1;
+const STATUS_UNINITIALIZED = 1 << 2;
+const EFFECT_RENDER = 1;
+const EFFECT_USER = 2;
+const NOT_PENDING = {};
+const SUPPORTS_PROXY = typeof Proxy === "function";
+const defaultContext = {};
+function actualInsertIntoHeap(e, t) {
+  const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
+  if (n >= e.o) e.o = n + 1;
+  const i = e.o;
+  const r = t.l[i];
+  if (r === undefined) t.l[i] = e;
+  else {
+    const t = r.T;
+    t.R = e;
+    e.T = t;
+    r.T = e;
+  }
+  if (i > t.h) t.h = i;
+}
+function insertIntoHeap(e, t) {
+  let n = e._;
+  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  if (n & REACTIVE_CHECK) {
+    e._ = (n & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else e._ = n | REACTIVE_IN_HEAP;
+  if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
+}
+function insertIntoHeapHeight(e, t) {
+  let n = e._;
+  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  e._ = n | REACTIVE_IN_HEAP_HEIGHT;
+  actualInsertIntoHeap(e, t);
+}
+function deleteFromHeap(e, t) {
+  const n = e._;
+  if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+  e._ = n & -25;
+  const i = e.o;
+  if (e.T === e) t.l[i] = undefined;
+  else {
+    const n = e.R;
+    const r = t.l[i];
+    const s = n ?? r;
+    if (e === r) t.l[i] = n;
+    else e.T.R = n;
+    s.T = e.T;
+  }
+  e.T = e;
+  e.R = undefined;
+}
+function markHeap(e) {
+  if (e.S) return;
+  e.S = true;
+  for (let t = 0; t <= e.h; t++) {
+    for (let n = e.l[t]; n !== undefined; n = n.R) {
+      if (n._ & REACTIVE_IN_HEAP) markNode(n);
+    }
+  }
+}
+function markNode(e, t = REACTIVE_DIRTY) {
+  const n = e._;
+  if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
+  e._ = (n & -4) | t;
+  for (let t = e.O; t !== null; t = t.p) {
+    markNode(t.A, REACTIVE_CHECK);
+  }
+  if (e.N !== null) {
+    for (let t = e.N; t !== null; t = t.I) {
+      for (let e = t.O; e !== null; e = e.p) {
+        markNode(e.A, REACTIVE_CHECK);
       }
     }
   }
 }
-function runHeap(heap, recompute2) {
-  heap.aa = false;
-  for (heap.p = 0; heap.p <= heap.L; heap.p++) {
-    let el = heap.r[heap.p];
-    while (el !== void 0) {
-      if (el.b & 8 /* InHeap */)
-        recompute2(el);
-      else {
-        adjustHeight(el, heap);
-      }
-      el = heap.r[heap.p];
+function runHeap(e, t) {
+  e.S = false;
+  for (e.C = 0; e.C <= e.h; e.C++) {
+    let n = e.l[e.C];
+    while (n !== undefined) {
+      if (n._ & REACTIVE_IN_HEAP) t(n);
+      else adjustHeight(n, e);
+      n = e.l[e.C];
     }
   }
-  heap.L = 0;
+  e.h = 0;
 }
-function adjustHeight(el, heap) {
-  deleteFromHeap(el, heap);
-  let newHeight = el.c;
-  for (let d = el.x; d; d = d.F) {
-    const dep1 = d.R;
-    const dep = "_owner" in dep1 ? dep1.B : dep1;
-    if ("_fn" in dep) {
-      if (dep.c >= newHeight) {
-        newHeight = dep.c + 1;
-      }
-    }
+function adjustHeight(e, t) {
+  deleteFromHeap(e, t);
+  let n = e.o;
+  for (let t = e.D; t; t = t.P) {
+    const e = t.V;
+    const i = e.U || e;
+    if (i.m && i.o >= n) n = i.o + 1;
   }
-  if (el.c !== newHeight) {
-    el.c = newHeight;
-    for (let s = el.s; s !== null; s = s.A) {
-      insertIntoHeapHeight(s.j, heap);
+  if (e.o !== n) {
+    e.o = n;
+    for (let n = e.O; n !== null; n = n.p) {
+      insertIntoHeapHeight(n.A, t);
     }
   }
 }
-
-// src/core/scheduler.ts
-var clock = 0;
-var activeTransition = null;
-var unobserved = [];
-var transitions = /* @__PURE__ */ new Set();
-var scheduled = false;
+const transitions = new Set();
+const dirtyQueue = { l: new Array(2e3).fill(undefined), S: false, C: 0, h: 0 };
+const zombieQueue = { l: new Array(2e3).fill(undefined), S: false, C: 0, h: 0 };
+let clock = 0;
+let activeTransition = null;
+let scheduled = false;
 function schedule() {
-  if (scheduled)
-    return;
+  if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.ca)
-    queueMicrotask(flush);
-}
-var dirtyQueue = {
-  r: new Array(2e3).fill(void 0),
-  aa: false,
-  p: 0,
-  L: 0
-};
-var zombieQueue = {
-  r: new Array(2e3).fill(void 0),
-  aa: false,
-  p: 0,
-  L: 0
-};
-var Queue = class {
-  w = null;
-  k = [[], []];
-  l = [];
+  if (!globalQueue.k) queueMicrotask(flush);
+}
+class Queue {
+  i = null;
+  G = [[], []];
+  H = [];
   created = clock;
-  addChild(child) {
-    this.l.push(child);
-    child.w = this;
+  addChild(e) {
+    this.H.push(e);
+    e.i = this;
   }
-  removeChild(child) {
-    const index = this.l.indexOf(child);
-    if (index >= 0) {
-      this.l.splice(index, 1);
-      child.w = null;
+  removeChild(e) {
+    const t = this.H.indexOf(e);
+    if (t >= 0) {
+      this.H.splice(t, 1);
+      e.i = null;
     }
   }
-  notify(node, mask, flags) {
-    if (this.w)
-      return this.w.notify(node, mask, flags);
+  notify(e, t, n) {
+    if (this.i) return this.i.notify(e, t, n);
     return false;
   }
-  run(type) {
-    if (this.k[type - 1].length) {
-      const effects = this.k[type - 1];
-      this.k[type - 1] = [];
-      runQueue(effects, type);
+  run(e) {
+    if (this.G[e - 1].length) {
+      const t = this.G[e - 1];
+      this.G[e - 1] = [];
+      runQueue(t, e);
     }
-    for (let i = 0; i < this.l.length; i++) {
-      this.l[i].run(type);
+    for (let t = 0; t < this.H.length; t++) {
+      this.H[t].run(e);
     }
   }
-  enqueue(type, fn) {
-    if (type)
-      this.k[type - 1].push(fn);
+  enqueue(e, t) {
+    if (e) this.G[e - 1].push(t);
     schedule();
   }
-  stashQueues(stub) {
-    stub.k[0].push(...this.k[0]);
-    stub.k[1].push(...this.k[1]);
-    this.k = [[], []];
-    for (let i = 0; i < this.l.length; i++) {
-      let child = this.l[i];
-      let childStub = stub.l[i];
-      if (!childStub) {
-        childStub = { k: [[], []], l: [] };
-        stub.l[i] = childStub;
+  stashQueues(e) {
+    e.G[0].push(...this.G[0]);
+    e.G[1].push(...this.G[1]);
+    this.G = [[], []];
+    for (let t = 0; t < this.H.length; t++) {
+      let n = this.H[t];
+      let i = e.H[t];
+      if (!i) {
+        i = { G: [[], []], H: [] };
+        e.H[t] = i;
       }
-      child.stashQueues(childStub);
+      n.stashQueues(i);
     }
   }
-  restoreQueues(stub) {
-    this.k[0].push(...stub.k[0]);
-    this.k[1].push(...stub.k[1]);
-    for (let i = 0; i < stub.l.length; i++) {
-      const childStub = stub.l[i];
-      let child = this.l[i];
-      if (child)
-        child.restoreQueues(childStub);
+  restoreQueues(e) {
+    this.G[0].push(...e.G[0]);
+    this.G[1].push(...e.G[1]);
+    for (let t = 0; t < e.H.length; t++) {
+      const n = e.H[t];
+      let i = this.H[t];
+      if (i) i.restoreQueues(n);
     }
   }
-};
-var GlobalQueue = class _GlobalQueue extends Queue {
-  ca = false;
-  h = [];
-  static S;
-  static ka;
+}
+class GlobalQueue extends Queue {
+  k = false;
+  $ = [];
+  static L;
+  static F;
   flush() {
-    if (this.ca)
-      return;
-    this.ca = true;
+    if (this.k) return;
+    this.k = true;
     try {
-      runHeap(dirtyQueue, _GlobalQueue.S);
+      runHeap(dirtyQueue, GlobalQueue.L);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
-          runHeap(zombieQueue, _GlobalQueue.S);
-          globalQueue.h = [];
-          globalQueue.stashQueues(activeTransition.queueStash);
+          runHeap(zombieQueue, GlobalQueue.L);
+          this.$ = [];
+          this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
           runPending(activeTransition.pendingNodes, true);
           activeTransition = null;
           return;
         }
-        globalQueue.h.push(...activeTransition.pendingNodes);
-        globalQueue.restoreQueues(activeTransition.queueStash);
+        this.$.push(...activeTransition.pendingNodes);
+        this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
-        if (runPending(globalQueue.h, false))
-          runHeap(dirtyQueue, _GlobalQueue.S);
-      } else if (transitions.size)
-        runHeap(zombieQueue, _GlobalQueue.S);
-      for (let i = 0; i < globalQueue.h.length; i++) {
-        const n = globalQueue.h[i];
-        if (n.e !== NOT_PENDING) {
-          n.g = n.e;
-          n.e = NOT_PENDING;
+        if (runPending(this.$, false)) runHeap(dirtyQueue, GlobalQueue.L);
+      } else if (transitions.size) runHeap(zombieQueue, GlobalQueue.L);
+      for (let e = 0; e < this.$.length; e++) {
+        const t = this.$[e];
+        if (t.W !== NOT_PENDING) {
+          t.j = t.W;
+          t.W = NOT_PENDING;
+          if (t.K) t.M = true;
         }
-        if (n.ha)
-          _GlobalQueue.ka(n, false, true);
+        if (t.m) GlobalQueue.F(t, false, true);
       }
-      globalQueue.h.length = 0;
+      this.$.length = 0;
       clock++;
       scheduled = false;
-      this.run(1 /* Render */);
-      this.run(2 /* User */);
+      this.run(EFFECT_RENDER);
+      this.run(EFFECT_USER);
     } finally {
-      this.ca = false;
-      unobserved.length && notifyUnobserved();
+      this.k = false;
     }
   }
-  notify(node, mask, flags) {
-    if (mask & 1 /* Pending */) {
-      if (flags & 1 /* Pending */) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(node.C.cause))
-          activeTransition.asyncNodes.push(node.C.cause);
+  notify(e, t, n) {
+    if (t & STATUS_PENDING) {
+      if (n & STATUS_PENDING) {
+        if (activeTransition && !activeTransition.asyncNodes.includes(e.Y.cause))
+          activeTransition.asyncNodes.push(e.Y.cause);
       }
       return true;
     }
     return false;
   }
-  initTransition(node) {
-    if (activeTransition && activeTransition.time === clock)
-      return;
+  initTransition(e) {
+    if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = node.T ?? {
+      activeTransition = e.B ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queueStash: { k: [[], []], l: [] }
+        queueStash: { G: [[], []], H: [] }
       };
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
-    for (let i = 0; i < globalQueue.h.length; i++) {
-      const n = globalQueue.h[i];
-      n.T = activeTransition;
-      activeTransition.pendingNodes.push(n);
+    for (let e = 0; e < this.$.length; e++) {
+      const t = this.$[e];
+      t.B = activeTransition;
+      activeTransition.pendingNodes.push(t);
     }
-    globalQueue.h = activeTransition.pendingNodes;
+    this.$ = activeTransition.pendingNodes;
   }
-};
-function runPending(pendingNodes, value) {
-  let needsReset = false;
-  const p = pendingNodes.slice();
-  for (let i = 0; i < p.length; i++) {
-    const n = p[i];
-    n.T = activeTransition;
-    if (n.H) {
-      n.H.da(value);
-      needsReset = true;
+}
+function runPending(e, t) {
+  let n = false;
+  const i = e.slice();
+  for (let e = 0; e < i.length; e++) {
+    const r = i[e];
+    r.B = activeTransition;
+    if (r.X) {
+      r.X.q(t);
+      n = true;
+    }
+    if (r.Z && r.Z.W !== NOT_PENDING) {
+      r.Z.q(r.Z.W);
+      r.Z.W = NOT_PENDING;
+      n = true;
     }
   }
-  return needsReset;
+  return n;
 }
-var globalQueue = new GlobalQueue();
+const globalQueue = new GlobalQueue();
 function flush() {
   while (scheduled) {
     globalQueue.flush();
   }
 }
-function runQueue(queue, type) {
-  for (let i = 0; i < queue.length; i++)
-    queue[i](type);
+function runQueue(e, t) {
+  for (let n = 0; n < e.length; n++) e[n](t);
 }
-function transitionComplete(transition) {
-  let done = true;
-  for (let i = 0; i < transition.asyncNodes.length; i++) {
-    if (transition.asyncNodes[i].f & 1 /* Pending */) {
-      done = false;
+function transitionComplete(e) {
+  let t = true;
+  for (let n = 0; n < e.asyncNodes.length; n++) {
+    if (e.asyncNodes[n].J & STATUS_PENDING) {
+      t = false;
       break;
     }
   }
-  return done;
-}
-function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source.s)
-      unobserved[i].sa?.();
-  }
-  unobserved = [];
-}
-
-// src/core/core.ts
-GlobalQueue.S = recompute;
-GlobalQueue.ka = disposeChildren;
-var tracking = false;
-var stale = false;
-var pendingValueCheck = false;
-var pendingCheck = null;
-var context = null;
-var defaultContext = {};
-function notifySubs(node) {
-  for (let s = node.s; s !== null; s = s.A) {
-    const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-    if (queue.p > s.j.c)
-      queue.p = s.j.c;
-    insertIntoHeap(s.j, queue);
-  }
-}
-function recompute(el, create = false) {
-  deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-  if (el.e !== NOT_PENDING || el.U || el.V)
-    disposeChildren(el);
+  return t;
+}
+function runInTransition(e, t) {
+  const n = activeTransition;
+  activeTransition = e.B;
+  t(e);
+  activeTransition = n;
+}
+GlobalQueue.L = recompute;
+GlobalQueue.F = disposeChildren;
+let tracking = false;
+let stale = false;
+let pendingValueCheck = false;
+let pendingCheck = null;
+let context = null;
+function notifySubs(e) {
+  for (let t = e.O; t !== null; t = t.p) {
+    const e = t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (e.C > t.A.o) e.C = t.A.o;
+    insertIntoHeap(t.A, e);
+  }
+}
+function recompute(e, t = false) {
+  deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  if (e.W !== NOT_PENDING || e.ee || e.te) disposeChildren(e);
   else {
-    markDisposal(el);
-    globalQueue.h.push(el);
-    el.V = el.t;
-    el.U = el.q;
-    el.t = null;
-    el.q = null;
-  }
-  const oldcontext = context;
-  context = el;
-  el.I = null;
-  el.b = 4 /* RecomputingDeps */;
-  el.J = clock;
-  let value = el.e === NOT_PENDING ? el.g : el.e;
-  let oldHeight = el.c;
-  let prevStatusFlags = el.f;
-  let prevError = el.C;
-  let prevTracking = tracking;
-  clearStatusFlags(el);
+    markDisposal(e);
+    globalQueue.$.push(e);
+    e.te = e.ne;
+    e.ee = e.ie;
+    e.ne = null;
+    e.ie = null;
+  }
+  const n = context;
+  context = e;
+  e.re = null;
+  e._ = REACTIVE_RECOMPUTING_DEPS;
+  e.se = clock;
+  let i = e.W === NOT_PENDING ? e.j : e.W;
+  let r = e.o;
+  let s = e.J;
+  let o = e.Y;
+  let u = tracking;
+  setStatusFlags(e, STATUS_NONE | (s & STATUS_UNINITIALIZED));
   tracking = true;
   try {
-    value = el.ha(value);
-  } catch (e) {
-    if (e instanceof NotReadyError) {
-      if (e.cause !== el)
-        link(e.cause, el);
-      setStatusFlags(el, prevStatusFlags & ~2 /* Error */ | 1 /* Pending */, e);
-    } else {
-      setError(el, e);
-    }
+    i = e.m(i);
+    e.J &= ~STATUS_UNINITIALIZED;
+  } catch (t) {
+    if (t instanceof NotReadyError) {
+      if (t.cause !== e) link(t.cause, e);
+      setStatusFlags(e, (s & ~STATUS_ERROR) | STATUS_PENDING, t);
+    } else setStatusFlags(e, STATUS_ERROR, t);
   } finally {
-    tracking = prevTracking;
+    tracking = u;
   }
-  el.b = 0 /* None */;
-  context = oldcontext;
-  const depsTail = el.I;
-  let toRemove = depsTail !== null ? depsTail.F : el.x;
-  if (toRemove !== null) {
+  e._ = REACTIVE_NONE;
+  context = n;
+  const l = e.re;
+  let c = l !== null ? l.P : e.D;
+  if (c !== null) {
     do {
-      toRemove = unlinkSubs(toRemove);
-    } while (toRemove !== null);
-    if (depsTail !== null) {
-      depsTail.F = null;
-    } else {
-      el.x = null;
-    }
-  }
-  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, value);
-  const statusFlagsChanged = el.f !== prevStatusFlags || el.C !== prevError;
-  el.la?.(statusFlagsChanged, prevStatusFlags);
-  if (valueChanged || statusFlagsChanged) {
-    if (valueChanged) {
-      if (create || el.ia || el.K)
-        el.g = value;
+      c = unlinkSubs(c);
+    } while (c !== null);
+    if (l !== null) l.P = null;
+    else e.D = null;
+  }
+  const a = !e.oe || !e.oe(e.W === NOT_PENDING || e.ue ? e.j : e.W, i);
+  const f = e.J !== s || e.Y !== o;
+  e.le?.(f, s);
+  if (a || f) {
+    if (a) {
+      if (t || e.ue || (e.K && e.B != activeTransition)) e.j = i;
       else {
-        if (el.e === NOT_PENDING)
-          globalQueue.h.push(el);
-        el.e = value;
+        if (e.W === NOT_PENDING) globalQueue.$.push(e);
+        e.W = i;
       }
-      if (el.D)
-        el.D.da(value);
+      if (e.Z) e.Z.q(i);
     }
-    for (let s = el.s; s !== null; s = s.A) {
-      const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-      if (s.j.c < el.c && queue.p > s.j.c)
-        queue.p = s.j.c;
-      insertIntoHeap(s.j, queue);
+    for (let t = e.O; t !== null; t = t.p) {
+      const n = t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+      if (t.A.o < e.o && n.C > t.A.o) n.C = t.A.o;
+      insertIntoHeap(t.A, n);
     }
-  } else if (el.c != oldHeight) {
-    for (let s = el.s; s !== null; s = s.A) {
-      insertIntoHeapHeight(s.j, s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  } else if (e.o != r) {
+    for (let t = e.O; t !== null; t = t.p) {
+      insertIntoHeapHeight(t.A, t.A._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
+  if (e.K && e.B && activeTransition !== e.B) runInTransition(e, recompute);
 }
-function updateIfNecessary(el) {
-  if (el.b & 1 /* Check */) {
-    for (let d = el.x; d; d = d.F) {
-      const dep1 = d.R;
-      const dep = "_owner" in dep1 ? dep1.B : dep1;
-      if ("_fn" in dep) {
-        updateIfNecessary(dep);
+function updateIfNecessary(e) {
+  if (e._ & REACTIVE_CHECK) {
+    for (let t = e.D; t; t = t.P) {
+      const n = t.V;
+      const i = n.U || n;
+      if (i.m) {
+        updateIfNecessary(i);
       }
-      if (el.b & 2 /* Dirty */) {
+      if (e._ & REACTIVE_DIRTY) {
         break;
       }
     }
   }
-  if (el.b & 2 /* Dirty */) {
-    recompute(el);
-  }
-  el.b = 0 /* None */;
-}
-function unlinkSubs(link2) {
-  const dep = link2.R;
-  const nextDep = link2.F;
-  const nextSub = link2.A;
-  const prevSub = link2.ma;
-  if (nextSub !== null) {
-    nextSub.ma = prevSub;
-  } else {
-    dep.W = prevSub;
-  }
-  if (prevSub !== null) {
-    prevSub.A = nextSub;
-  } else {
-    dep.s = nextSub;
+  if (e._ & REACTIVE_DIRTY) {
+    recompute(e);
   }
-  return nextDep;
+  e._ = REACTIVE_NONE;
 }
-function link(dep, sub) {
-  const prevDep = sub.I;
-  if (prevDep !== null && prevDep.R === dep) {
-    return;
-  }
-  let nextDep = null;
-  const isRecomputing = sub.b & 4 /* RecomputingDeps */;
-  if (isRecomputing) {
-    nextDep = prevDep !== null ? prevDep.F : sub.x;
-    if (nextDep !== null && nextDep.R === dep) {
-      sub.I = nextDep;
+function unlinkSubs(e) {
+  const t = e.V;
+  const n = e.P;
+  const i = e.p;
+  const r = e.ce;
+  if (i !== null) i.ce = r;
+  else t.ae = r;
+  if (r !== null) r.p = i;
+  else {
+    t.O = i;
+    if (i === null) {
+      t.fe?.();
+      t.m && unobserved(t);
+    }
+  }
+  return n;
+}
+function unobserved(e) {
+  deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let t = e.D;
+  while (t !== null) {
+    t = unlinkSubs(t);
+  }
+  e.D = null;
+  runDisposal(e);
+}
+function link(e, t) {
+  const n = t.re;
+  if (n !== null && n.V === e) return;
+  let i = null;
+  const r = t._ & REACTIVE_RECOMPUTING_DEPS;
+  if (r) {
+    i = n !== null ? n.P : t.D;
+    if (i !== null && i.V === e) {
+      t.re = i;
       return;
     }
   }
-  const prevSub = dep.W;
-  if (prevSub !== null && prevSub.j === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
-    return;
-  }
-  const newLink = sub.I = dep.W = {
-    R: dep,
-    j: sub,
-    F: nextDep,
-    ma: prevSub,
-    A: null
-  };
-  if (prevDep !== null) {
-    prevDep.F = newLink;
-  } else {
-    sub.x = newLink;
-  }
-  if (prevSub !== null) {
-    prevSub.A = newLink;
-  } else {
-    dep.s = newLink;
-  }
+  const s = e.ae;
+  if (s !== null && s.A === t && (!r || isValidLink(s, t))) return;
+  const o = (t.re = e.ae = { V: e, A: t, P: i, ce: s, p: null });
+  if (n !== null) n.P = o;
+  else t.D = o;
+  if (s !== null) s.p = o;
+  else e.O = o;
 }
-function isValidLink(checkLink, sub) {
-  const depsTail = sub.I;
-  if (depsTail !== null) {
-    let link2 = sub.x;
+function isValidLink(e, t) {
+  const n = t.re;
+  if (n !== null) {
+    let i = t.D;
     do {
-      if (link2 === checkLink) {
-        return true;
-      }
-      if (link2 === depsTail) {
-        break;
-      }
-      link2 = link2.F;
-    } while (link2 !== null);
+      if (i === e) return true;
+      if (i === n) break;
+      i = i.P;
+    } while (i !== null);
   }
   return false;
 }
-function setStatusFlags(signal2, flags, error = null) {
-  signal2.f = flags;
-  signal2.C = error;
-}
-function setError(signal2, error) {
-  setStatusFlags(signal2, 2 /* Error */, error);
-}
-function clearStatusFlags(signal2) {
-  setStatusFlags(signal2, 0 /* None */);
-}
-function markDisposal(el) {
-  let child = el.q;
-  while (child) {
-    child.b |= 32 /* Zombie */;
-    const inHeap = child.b & 8 /* InHeap */;
-    if (inHeap) {
-      deleteFromHeap(child, dirtyQueue);
-      insertIntoHeap(child, zombieQueue);
-    }
-    markDisposal(child);
-    child = child.M;
-  }
-}
-function disposeChildren(node, self = false, zombie) {
-  if (node.b & 64 /* Disposed */)
-    return;
-  if (self)
-    node.b = 64 /* Disposed */;
-  let child = zombie ? node.U : node.q;
-  while (child) {
-    const nextChild = child.M;
-    if (child.x) {
-      const n = child;
-      deleteFromHeap(n, n.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-      let toRemove = n.x;
+function setStatusFlags(e, t, n = null) {
+  e.J = t;
+  e.Y = n;
+}
+function markDisposal(e) {
+  let t = e.ie;
+  while (t) {
+    t._ |= REACTIVE_ZOMBIE;
+    if (t._ & REACTIVE_IN_HEAP) {
+      deleteFromHeap(t, dirtyQueue);
+      insertIntoHeap(t, zombieQueue);
+    }
+    markDisposal(t);
+    t = t.Ee;
+  }
+}
+function dispose(e) {
+  let t = e.D || null;
+  do {
+    t = unlinkSubs(t);
+  } while (t !== null);
+  e.D = null;
+  e.re = null;
+  disposeChildren(e, true);
+}
+function disposeChildren(e, t = false, n) {
+  if (e._ & REACTIVE_DISPOSED) return;
+  if (t) e._ = REACTIVE_DISPOSED;
+  let i = n ? e.ee : e.ie;
+  while (i) {
+    const e = i.Ee;
+    if (i.D) {
+      const e = i;
+      deleteFromHeap(e, e._ & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.D;
       do {
-        toRemove = unlinkSubs(toRemove);
-      } while (toRemove !== null);
-      n.x = null;
-      n.I = null;
+        t = unlinkSubs(t);
+      } while (t !== null);
+      e.D = null;
+      e.re = null;
     }
-    disposeChildren(child, true);
-    child = nextChild;
+    disposeChildren(i, true);
+    i = e;
   }
-  if (zombie) {
-    node.U = null;
+  if (n) {
+    e.ee = null;
   } else {
-    node.q = null;
-    node.M = null;
+    e.ie = null;
+    e.Ee = null;
   }
-  runDisposal(node, zombie);
+  runDisposal(e, n);
 }
-function runDisposal(node, zombie) {
-  let disposal = zombie ? node.V : node.t;
-  if (!disposal)
-    return;
-  if (Array.isArray(disposal)) {
-    for (let i = 0; i < disposal.length; i++) {
-      const callable = disposal[i];
-      callable.call(callable);
+function runDisposal(e, t) {
+  let n = t ? e.te : e.ne;
+  if (!n) return;
+  if (Array.isArray(n)) {
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      t.call(t);
     }
   } else {
-    disposal.call(disposal);
-  }
-  zombie ? node.V = null : node.t = null;
-}
-function withOptions(obj, options) {
-  obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
-  obj.ea = options?.equals != null ? options.equals : isEqual;
-  obj.ya = !!options?.pureWrite;
-  obj.sa = options?.unobserved;
-  if (options?.ja)
-    Object.assign(obj, options.ja);
-  return obj;
-}
-function getNextChildId(owner) {
-  if (owner.id != null)
-    return formatId(owner.id, owner.na++);
-  throw new Error("Cannot get child id from owner without an id");
+    n.call(n);
+  }
+  t ? (e.te = null) : (e.ne = null);
 }
-function formatId(prefix, id) {
-  const num = id.toString(36), len = num.length - 1;
-  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+function getNextChildId(e) {
+  if (e.id != null) return formatId(e.id, e.de++);
+  throw new Error("Cannot get child id from owner without an id");
 }
-function computed(fn, initialValue, options) {
-  const self = withOptions(
-    {
-      t: null,
-      i: globalQueue,
-      E: defaultContext,
-      na: 0,
-      ha: fn,
-      g: initialValue,
-      c: 0,
-      ba: null,
-      Q: void 0,
-      z: null,
-      x: null,
-      I: null,
-      s: null,
-      W: null,
-      w: context,
-      M: null,
-      q: null,
-      b: 0 /* None */,
-      f: 4 /* Uninitialized */,
-      J: clock,
-      e: NOT_PENDING,
-      V: null,
-      U: null
-    },
-    options
-  );
-  self.z = self;
-  const parent = context?._ ? context.$ : context;
+function formatId(e, t) {
+  const n = t.toString(36),
+    i = n.length - 1;
+  return e + (i ? String.fromCharCode(64 + i) : "") + n;
+}
+function computed(e, t, n) {
+  const i = {
+    id: n?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
+    oe: n?.equals != null ? n.equals : isEqual,
+    Te: !!n?.pureWrite,
+    fe: n?.unobserved,
+    ne: null,
+    Re: context?.Re ?? globalQueue,
+    he: context?.he ?? defaultContext,
+    de: 0,
+    m: e,
+    j: t,
+    o: 0,
+    N: null,
+    R: undefined,
+    T: null,
+    D: null,
+    re: null,
+    O: null,
+    ae: null,
+    i: context,
+    Ee: null,
+    ie: null,
+    _: REACTIVE_NONE,
+    J: STATUS_UNINITIALIZED,
+    se: clock,
+    W: NOT_PENDING,
+    te: null,
+    ee: null
+  };
+  if (n?._e) Object.assign(i, n._e);
+  i.T = i;
+  const r = context?.t ? context.u : context;
   if (context) {
-    context.i && (self.i = context.i);
-    context.E && (self.E = context.E);
-    const lastChild = context.q;
-    if (lastChild === null) {
-      context.q = self;
+    const e = context.ie;
+    if (e === null) {
+      context.ie = i;
     } else {
-      self.M = lastChild;
-      context.q = self;
-    }
-  }
-  if (parent)
-    self.c = parent.c + 1;
-  recompute(self, true);
-  return self;
-}
-function asyncComputed(asyncFn, initialValue, options) {
-  let lastResult = void 0;
-  let refreshing = false;
-  const fn = (prev) => {
-    const result = asyncFn(prev, refreshing);
-    refreshing = false;
-    lastResult = result;
-    const isPromise = result instanceof Promise;
-    const iterator = result[Symbol.asyncIterator];
-    if (!isPromise && !iterator) {
-      return result;
-    }
-    if (isPromise) {
-      result.then((v) => {
-        if (lastResult !== result)
-          return;
-        globalQueue.initTransition(self);
-        setSignal(self, () => v);
+      i.Ee = e;
+      context.ie = i;
+    }
+  }
+  if (r) i.o = r.o + 1;
+  recompute(i, true);
+  return i;
+}
+function asyncComputed(e, t, n) {
+  let i = undefined;
+  let r = false;
+  const fn = t => {
+    const n = e(t, r);
+    r = false;
+    i = n;
+    const o = n instanceof Promise;
+    const u = n[Symbol.asyncIterator];
+    if (!o && !u) {
+      return n;
+    }
+    if (o) {
+      n.then(e => {
+        if (i !== n) return;
+        globalQueue.initTransition(s);
+        setSignal(s, () => e);
         flush();
-      }).catch((e) => {
-        if (lastResult !== result)
-          return;
-        globalQueue.initTransition(self);
-        setError(self, e);
-        self.J = clock;
-        notifySubs(self);
+      }).catch(e => {
+        if (i !== n) return;
+        globalQueue.initTransition(s);
+        setStatusFlags(s, STATUS_ERROR, e);
+        s.se = clock;
+        notifySubs(s);
         schedule();
         flush();
       });
     } else {
       (async () => {
         try {
-          for await (let value of result) {
-            if (lastResult !== result)
-              return;
-            globalQueue.initTransition(self);
-            setSignal(self, () => value);
+          for await (let e of n) {
+            if (i !== n) return;
+            globalQueue.initTransition(s);
+            setSignal(s, () => e);
             flush();
           }
-        } catch (error) {
-          if (lastResult !== result)
-            return;
-          globalQueue.initTransition(self);
-          setError(self, error);
-          self.J = clock;
-          notifySubs(self);
+        } catch (e) {
+          if (i !== n) return;
+          globalQueue.initTransition(s);
+          setStatusFlags(s, STATUS_ERROR, e);
+          s.se = clock;
+          notifySubs(s);
           schedule();
           flush();
         }
@@ -719,150 +644,128 @@ function asyncComputed(asyncFn, initialValue, options) {
     globalQueue.initTransition(context);
     throw new NotReadyError(context);
   };
-  const self = computed(fn, initialValue, options);
-  self.ta = () => {
-    refreshing = true;
-    recompute(self);
+  const s = computed(fn, t, n);
+  s.Se = () => {
+    r = true;
+    recompute(s);
+    schedule();
     flush();
   };
-  return self;
-}
-function signal(v, options, firewall = null) {
-  if (firewall !== null) {
-    return firewall.ba = withOptions(
-      {
-        g: v,
-        s: null,
-        W: null,
-        B: firewall,
-        ra: firewall.ba,
-        f: 0 /* None */,
-        J: clock,
-        e: NOT_PENDING
-      },
-      options
-    );
-  } else {
-    return withOptions(
-      {
-        g: v,
-        s: null,
-        W: null,
-        f: 0 /* None */,
-        J: clock,
-        e: NOT_PENDING
-      },
-      options
-    );
-  }
+  return s;
+}
+function signal(e, t, n = null) {
+  const i = {
+    id: t?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
+    oe: t?.equals != null ? t.equals : isEqual,
+    Te: !!t?.pureWrite,
+    fe: t?.unobserved,
+    j: e,
+    O: null,
+    ae: null,
+    J: STATUS_NONE,
+    se: clock,
+    U: n,
+    I: n?.N || null,
+    W: NOT_PENDING
+  };
+  n && (n.N = i);
+  return i;
 }
-function isEqual(a, b) {
-  return a === b;
+function isEqual(e, t) {
+  return e === t;
 }
-function untrack(fn) {
-  if (!tracking)
-    return fn();
+function untrack(e) {
+  if (!tracking) return e();
   tracking = false;
   try {
-    return fn();
+    return e();
   } finally {
     tracking = true;
   }
 }
-function read(el) {
-  let c = context;
-  if (c?._)
-    c = c.$;
-  if (c && tracking) {
-    link(el, c);
-    const owner = "_owner" in el ? el.B : el;
-    if ("_fn" in owner) {
-      const isZombie = el.b & 32 /* Zombie */;
-      if (owner.c >= (isZombie ? zombieQueue.p : dirtyQueue.p)) {
-        markNode(c);
-        markHeap(isZombie ? zombieQueue : dirtyQueue);
-        updateIfNecessary(owner);
+function read(e) {
+  let t = context;
+  if (t?.t) t = t.u;
+  if (t && tracking && !pendingCheck && !pendingValueCheck) {
+    link(e, t);
+    const n = e.U || e;
+    if (n.m) {
+      const i = e._ & REACTIVE_ZOMBIE;
+      if (n.o >= (i ? zombieQueue.C : dirtyQueue.C)) {
+        markNode(t);
+        markHeap(i ? zombieQueue : dirtyQueue);
+        updateIfNecessary(n);
       }
-      const height = owner.c;
-      if (height >= c.c && el.w !== c) {
-        c.c = height + 1;
+      const r = n.o;
+      if (r >= t.o && e.i !== t) {
+        t.o = r + 1;
       }
     }
   }
   if (pendingCheck) {
-    const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.T || false;
-    if (!el.H) {
-      el.H = signal(pendingResult);
-      el.H.ia = true;
-      el.H.da = (v) => setSignal(el.H, v);
+    if (!e.X) {
+      e.X = signal(false);
+      e.X.ue = true;
+      e.X.q = t => setSignal(e.X, t);
     }
-    const prev = pendingCheck;
+    const t = pendingCheck;
     pendingCheck = null;
-    read(el.H);
-    pendingCheck = prev;
-    prev.g = pendingResult || prev.g;
+    t.j = read(e.X) || t.j;
+    pendingCheck = t;
   }
   if (pendingValueCheck) {
-    if (!el.D) {
-      el.D = signal(
-        el.e === NOT_PENDING ? el.g : el.e
-      );
-      el.D.ia = true;
-      el.D.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.D, v)));
+    if (!e.Z) {
+      e.Z = signal(e.j);
+      e.Z.ue = true;
+      e.Z.q = t => setSignal(e.Z, t);
     }
     pendingValueCheck = false;
     try {
-      return read(el.D);
+      return read(e.Z);
     } finally {
       pendingValueCheck = true;
     }
   }
-  if (el.f & 1 /* Pending */) {
-    if (c && !stale || el.f & 4 /* Uninitialized */)
-      throw el.C;
-    else if (c && stale && !pendingCheck) {
-      setStatusFlags(
-        c,
-        c.f | 1,
-        el.C
-      );
+  if (e.J & STATUS_PENDING) {
+    if ((t && !stale) || e.J & STATUS_UNINITIALIZED) throw e.Y;
+    else if (t && stale && !pendingCheck) {
+      setStatusFlags(t, t.J | 1, e.Y);
     }
   }
-  if (el.f & 2 /* Error */) {
-    if (el.J < clock) {
-      recompute(el, true);
-      return read(el);
+  if (e.J & STATUS_ERROR) {
+    if (e.se < clock) {
+      recompute(e, true);
+      return read(e);
     } else {
-      throw el.C;
+      throw e.Y;
     }
   }
-  return !c || el.e === NOT_PENDING || stale && !pendingCheck && el.T && activeTransition !== el.T ? el.g : el.e;
+  return !t ||
+    e.ue ||
+    e.W === NOT_PENDING ||
+    (stale && !pendingCheck && e.B && activeTransition !== e.B)
+    ? e.j
+    : e.W;
 }
-function setSignal(el, v) {
-  if (typeof v === "function") {
-    v = v(
-      el.e === NOT_PENDING ? el.g : el.e
-    );
+function setSignal(e, t) {
+  if (typeof t === "function") {
+    t = t(e.W === NOT_PENDING ? e.j : e.W);
   }
-  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, v);
-  if (!valueChanged && !el.f)
-    return v;
-  if (valueChanged) {
-    if (el.ia)
-      el.g = v;
+  const n = !e.oe || !e.oe(e.W === NOT_PENDING || e.ue ? e.j : e.W, t);
+  if (!n && !e.J) return t;
+  if (n) {
+    if (e.ue) e.j = t;
     else {
-      if (el.e === NOT_PENDING)
-        globalQueue.h.push(el);
-      el.e = v;
+      if (e.W === NOT_PENDING) globalQueue.$.push(e);
+      e.W = t;
     }
-    if (el.D)
-      el.D.da(v);
+    if (e.Z) e.Z.W = t;
   }
-  clearStatusFlags(el);
-  el.J = clock;
-  notifySubs(el);
+  setStatusFlags(e, STATUS_NONE);
+  e.se = clock;
+  notifySubs(e);
   schedule();
-  return v;
+  return t;
 }
 function getObserver() {
   return tracking ? context : null;
@@ -870,1317 +773,1302 @@ function getObserver() {
 function getOwner() {
   return context;
 }
-function onCleanup(fn) {
-  if (!context)
-    return fn;
-  const node = context;
-  if (!node.t) {
-    node.t = fn;
-  } else if (Array.isArray(node.t)) {
-    node.t.push(fn);
+function onCleanup(e) {
+  if (!context) return e;
+  const t = context;
+  if (!t.ne) {
+    t.ne = e;
+  } else if (Array.isArray(t.ne)) {
+    t.ne.push(e);
   } else {
-    node.t = [node.t, fn];
-  }
-  return fn;
-}
-function createOwner(options) {
-  const parent = context;
-  const owner = {
-    _: true,
-    $: parent?._ ? parent.$ : parent,
-    q: null,
-    M: null,
-    t: null,
-    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
-    i: parent?.i ?? globalQueue,
-    E: parent?.E || defaultContext,
-    na: 0,
-    V: null,
-    U: null,
-    w: parent,
-    dispose(self = true) {
-      disposeChildren(owner, self);
+    t.ne = [t.ne, e];
+  }
+  return e;
+}
+function createOwner(e) {
+  const t = context;
+  const n = {
+    t: true,
+    u: t?.t ? t.u : t,
+    ie: null,
+    Ee: null,
+    ne: null,
+    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
+    Re: t?.Re ?? globalQueue,
+    he: t?.he || defaultContext,
+    de: 0,
+    te: null,
+    ee: null,
+    i: t,
+    dispose(e = true) {
+      disposeChildren(n, e);
     }
   };
-  if (parent) {
-    const lastChild = parent.q;
-    if (lastChild === null) {
-      parent.q = owner;
+  if (t) {
+    const e = t.ie;
+    if (e === null) {
+      t.ie = n;
     } else {
-      owner.M = lastChild;
-      parent.q = owner;
+      n.Ee = e;
+      t.ie = n;
     }
   }
-  return owner;
+  return n;
 }
-function createRoot(init, options) {
-  const owner = createOwner(options);
-  return runWithOwner(owner, () => init(owner.dispose));
+function createRoot(e, t) {
+  const n = createOwner(t);
+  return runWithOwner(n, () => e(n.dispose));
 }
-function runWithOwner(owner, fn) {
-  const oldContext = context;
-  context = owner;
+function runWithOwner(e, t) {
+  const n = context;
+  context = e;
   try {
-    return fn();
+    return t();
   } finally {
-    context = oldContext;
+    context = n;
   }
 }
-function staleValues(fn, set = true) {
-  const prevStale = stale;
-  stale = set;
+function staleValues(e, t = true) {
+  const n = stale;
+  stale = t;
   try {
-    return fn();
+    return e();
   } finally {
-    stale = prevStale;
+    stale = n;
   }
 }
-function pending(fn) {
-  const prevLatest = pendingValueCheck;
+function pending(e) {
+  const t = pendingValueCheck;
   pendingValueCheck = true;
   try {
-    return staleValues(fn, false);
+    return staleValues(e, false);
   } finally {
-    pendingValueCheck = prevLatest;
+    pendingValueCheck = t;
   }
 }
-function isPending(fn, loadingValue) {
-  const current = pendingCheck;
-  pendingCheck = { g: false };
+function isPending(e, t) {
+  const n = pendingCheck;
+  pendingCheck = { j: false };
   try {
-    staleValues(fn);
-    return pendingCheck.g;
-  } catch (err) {
-    if (!(err instanceof NotReadyError))
-      return false;
-    if (loadingValue !== void 0)
-      return loadingValue;
-    throw err;
+    staleValues(e);
+    return pendingCheck.j;
+  } catch (e) {
+    if (!(e instanceof NotReadyError)) return false;
+    if (t !== undefined) return t;
+    throw e;
   } finally {
-    pendingCheck = current;
+    pendingCheck = n;
   }
 }
-
-// src/core/context.ts
-function createContext(defaultValue, description) {
-  return { id: Symbol(description), defaultValue };
+function createContext(e, t) {
+  return { id: Symbol(t), defaultValue: e };
 }
-function getContext(context2, owner = getOwner()) {
-  if (!owner) {
+function getContext(e, t = getOwner()) {
+  if (!t) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context2, owner) ? owner.E[context2.id] : context2.defaultValue;
-  if (isUndefined(value)) {
+  const n = hasContext(e, t) ? t.he[e.id] : e.defaultValue;
+  if (isUndefined(n)) {
     throw new ContextNotFoundError();
   }
-  return value;
+  return n;
 }
-function setContext(context2, value, owner = getOwner()) {
-  if (!owner) {
+function setContext(e, t, n = getOwner()) {
+  if (!n) {
     throw new NoOwnerError();
   }
-  owner.E = {
-    ...owner.E,
-    [context2.id]: isUndefined(value) ? context2.defaultValue : value
-  };
-}
-function hasContext(context2, owner) {
-  return !isUndefined(owner?.E[context2.id]);
-}
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-
-// src/core/effect.ts
-function effect(compute, effect2, error, initialValue, options) {
-  let initialized = false;
-  const node = computed(compute, initialValue, {
-    ...options,
-    ja: {
-      fa: true,
-      oa: initialValue,
-      ua: effect2,
-      pa: error,
-      N: void 0,
-      i: getOwner()?.i ?? globalQueue,
-      K: options?.render ? 1 /* Render */ : 2 /* User */,
-      la(statusFlagsChanged, prevStatusFlags) {
-        if (initialized) {
-          const errorChanged = this.f && this.f === prevStatusFlags && statusFlagsChanged;
-          this.fa = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
-          if (this.fa)
-            this.i.enqueue(this.K, runEffect.bind(this));
+  n.he = { ...n.he, [e.id]: isUndefined(t) ? e.defaultValue : t };
+}
+function hasContext(e, t) {
+  return !isUndefined(t?.he[e.id]);
+}
+function isUndefined(e) {
+  return typeof e === "undefined";
+}
+function effect(e, t, n, i, r) {
+  let s = false;
+  const o = computed(e, i, {
+    ...r,
+    _e: {
+      M: true,
+      Oe: i,
+      pe: t,
+      Ae: n,
+      Ne: undefined,
+      K: r?.render ? EFFECT_RENDER : EFFECT_USER,
+      le(e, t) {
+        if (s) {
+          const n = this.J && this.J === t && e;
+          this.M = !(this.J & STATUS_ERROR) && !(this.J & STATUS_PENDING & ~t) && !n;
+          if (this.M) this.Re.enqueue(this.K, runEffect.bind(this));
         }
-        if (this.f & 2 /* Error */) {
-          let error2 = this.C;
-          this.i.notify(this, 1 /* Pending */, 0);
-          if (this.K === 2 /* User */) {
+        if (this.J & STATUS_ERROR) {
+          let e = this.Y;
+          this.Re.notify(this, STATUS_PENDING, 0);
+          if (this.K === EFFECT_USER) {
             try {
-              return this.pa ? this.pa(error2, () => {
-                this.N?.();
-                this.N = void 0;
-              }) : console.error(error2);
-            } catch (e) {
-              error2 = e;
+              return this.Ae
+                ? this.Ae(e, () => {
+                    this.Ne?.();
+                    this.Ne = undefined;
+                  })
+                : console.error(e);
+            } catch (t) {
+              e = t;
             }
           }
-          if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
-            throw error2;
-        } else if (this.K === 1 /* Render */) {
-          this.i.notify(
-            this,
-            1 /* Pending */ | 2 /* Error */,
-            this.f
-          );
+          if (!this.Re.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
+        } else if (this.K === EFFECT_RENDER) {
+          this.Re.notify(this, STATUS_PENDING | STATUS_ERROR, this.J);
         }
       }
     }
   });
-  initialized = true;
-  if (node.K === 1 /* Render */)
-    node.ha = (p) => staleValues(() => compute(p));
-  !options?.defer && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.K === 2 /* User */ ? node.i.enqueue(node.K, runEffect.bind(node)) : runEffect.call(node));
-  onCleanup(() => node.N?.());
+  s = true;
+  if (o.K === EFFECT_RENDER) o.m = t => staleValues(() => e(t));
+  !r?.defer &&
+    !(o.J & (STATUS_ERROR | STATUS_PENDING)) &&
+    (o.K === EFFECT_USER ? o.Re.enqueue(o.K, runEffect.bind(o)) : runEffect.call(o));
+  onCleanup(() => o.Ne?.());
 }
 function runEffect() {
-  if (!this.fa || this.b & 64 /* Disposed */)
-    return;
-  this.N?.();
-  this.N = void 0;
+  if (!this.M || this._ & REACTIVE_DISPOSED) return;
+  this.Ne?.();
+  this.Ne = undefined;
   try {
-    this.N = this.ua(this.g, this.oa);
-  } catch (error) {
-    if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
-      throw error;
+    this.Ne = this.pe(this.j, this.Oe);
+  } catch (e) {
+    if (!this.Re.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
   } finally {
-    this.oa = this.g;
-    this.fa = false;
-  }
-}
-
-// src/signals.ts
-function createSignal(first, second, third) {
-  if (typeof first === "function") {
-    const node2 = computed(first, second, third);
-    return [
-      read.bind(null, node2),
-      setSignal.bind(null, node2)
-    ];
-  }
-  const o = getOwner();
-  const needsId = o?.id != null;
-  const node = signal(
-    first,
-    needsId ? { id: getNextChildId(o), ...second } : second
-  );
-  return [
-    read.bind(null, node),
-    setSignal.bind(null, node)
-  ];
-}
-function createMemo(compute, value, options) {
-  let node = computed(compute, value, options);
-  return read.bind(null, node);
-}
-function createAsync(compute, value, options) {
-  const node = asyncComputed(compute, value, options);
-  const ret = read.bind(null, node);
-  ret.refresh = node.ta;
-  return ret;
-}
-function createEffect(compute, effectFn, value, options) {
-  void effect(
-    compute,
-    effectFn.effect || effectFn,
-    effectFn.error,
-    value,
-    options
-  );
-}
-function createRenderEffect(compute, effectFn, value, options) {
-  void effect(compute, effectFn, void 0, value, {
-    render: true,
-    ...options
-  });
-}
-function createTrackedEffect(compute, options) {
-}
-function createReaction(effect2, options) {
+    this.Oe = this.j;
+    this.M = false;
+  }
+}
+function createSignal(e, t, n) {
+  if (typeof e === "function") {
+    const i = computed(e, t, n);
+    return [read.bind(null, i), setSignal.bind(null, i)];
+  }
+  const i = getOwner();
+  const r = i?.id != null;
+  const s = signal(e, r ? { id: getNextChildId(i), ...t } : t);
+  return [read.bind(null, s), setSignal.bind(null, s)];
+}
+function createMemo(e, t, n) {
+  let i = computed(e, t, n);
+  return read.bind(null, i);
+}
+function createAsync(e, t, n) {
+  const i = asyncComputed(e, t, n);
+  const r = read.bind(null, i);
+  r.refresh = i.Se;
+  return r;
+}
+function createEffect(e, t, n, i) {
+  void effect(e, t.effect || t, t.error, n, i);
+}
+function createRenderEffect(e, t, n, i) {
+  void effect(e, t, undefined, n, { render: true, ...i });
+}
+function createTrackedEffect(e, t) {}
+function createReaction(e, t) {
+  let n = undefined;
+  onCleanup(() => n?.());
+  const i = getOwner();
+  return r => {
+    runWithOwner(i, () => {
+      effect(
+        () => (r(), getOwner()),
+        t => {
+          n?.();
+          n = (e.effect || e)?.();
+          dispose(t);
+        },
+        e.error,
+        undefined,
+        { defer: true, ...(false ? { ...t, name: t?.name ?? "effect" } : t) }
+      );
+    });
+  };
 }
-function resolve(fn) {
-  return new Promise((res, rej) => {
-    createRoot((dispose) => {
+function resolve(e) {
+  return new Promise((t, n) => {
+    createRoot(i => {
       computed(() => {
         try {
-          res(fn());
-        } catch (err) {
-          if (err instanceof NotReadyError)
-            throw err;
-          rej(err);
+          t(e());
+        } catch (e) {
+          if (e instanceof NotReadyError) throw e;
+          n(e);
         }
-        dispose();
+        i();
       });
     });
   });
 }
-function createOptimistic(first, second, third) {
+function createOptimistic(e, t, n) {
   return {};
 }
-function onSettled(callback) {
-}
-
-// src/store/reconcile.ts
-function unwrap(value) {
-  return value?.[$TARGET]?.[STORE_NODE] ?? value;
-}
-function getOverrideValue(value, override, nodes, key) {
-  return nodes && key in nodes ? read(nodes[key]) : override && key in override ? override[key] : value[key];
-}
-function getAllKeys(value, override, next) {
-  const keys = getKeys(value, override);
-  const nextKeys = Object.keys(next);
-  return Array.from(/* @__PURE__ */ new Set([...keys, ...nextKeys]));
+function onSettled(e) {
+  let t;
+  const n = getOwner();
+  if (n) onCleanup(() => t?.());
+  globalQueue.enqueue(EFFECT_USER, () => {
+    t = e();
+    !n && t?.();
+  });
 }
-function applyState(next, state, keyFn, all) {
-  const target = state?.[$TARGET];
-  if (!target)
-    return;
-  const previous = target[STORE_VALUE];
-  const override = target[STORE_OVERRIDE];
-  let nodes = target[STORE_NODE];
-  if (next === previous && !override)
-    return;
-  (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
-  target[STORE_VALUE] = next;
-  target[STORE_OVERRIDE] = void 0;
-  if (Array.isArray(previous)) {
-    let changed = false;
-    const prevLength = getOverrideValue(previous, override, nodes, "length");
-    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
-      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
-      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, nodes, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
-        applyState(next[start], wrap(item, target), keyFn, all);
+function unwrap(e) {
+  return e?.[$TARGET]?.[STORE_NODE] ?? e;
+}
+function getOverrideValue(e, t, n, i) {
+  return n && i in n ? read(n[i]) : t && i in t ? t[i] : e[i];
+}
+function getAllKeys(e, t, n) {
+  const i = getKeys(e, t);
+  const r = Object.keys(n);
+  return Array.from(new Set([...i, ...r]));
+}
+function applyState(e, t, n, i) {
+  const r = t?.[$TARGET];
+  if (!r) return;
+  const s = r[STORE_VALUE];
+  const o = r[STORE_OVERRIDE];
+  let u = r[STORE_NODE];
+  if (e === s && !o) return;
+  (r[STORE_LOOKUP] || storeLookup).set(e, r[$PROXY]);
+  r[STORE_VALUE] = e;
+  r[STORE_OVERRIDE] = undefined;
+  if (Array.isArray(s)) {
+    let t = false;
+    const l = getOverrideValue(s, o, u, "length");
+    if (e.length && l && e[0] && n(e[0]) != null) {
+      let c, a, f, E, d, T, R, h;
+      for (
+        f = 0, E = Math.min(l, e.length);
+        f < E && ((T = getOverrideValue(s, o, u, f)) === e[f] || (T && e[f] && n(T) === n(e[f])));
+        f++
+      ) {
+        applyState(e[f], wrap(T, r), n, i);
       }
-      const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
-      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, nodes, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
-        temp[newEnd] = item;
+      const _ = new Array(e.length),
+        S = new Map();
+      for (
+        E = l - 1, d = e.length - 1;
+        E >= f &&
+        d >= f &&
+        ((T = getOverrideValue(s, o, u, E)) === e[d] || (T && e[d] && n(T) === n(e[d])));
+        E--, d--
+      ) {
+        _[d] = T;
       }
-      if (start > newEnd || start > end) {
-        for (j = start; j <= newEnd; j++) {
-          changed = true;
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
+      if (f > d || f > E) {
+        for (a = f; a <= d; a++) {
+          t = true;
+          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
         }
-        for (; j < next.length; j++) {
-          changed = true;
-          const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
-          applyState(next[j], wrapped, keyFn, all);
+        for (; a < e.length; a++) {
+          t = true;
+          const s = wrap(_[a], r);
+          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], s);
+          applyState(e[a], s, n, i);
         }
-        changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
-        prevLength !== next.length && target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
+        t && r[STORE_NODE][$TRACK] && setSignal(r[STORE_NODE][$TRACK], void 0);
+        l !== e.length && r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
         return;
       }
-      newIndicesNext = new Array(newEnd + 1);
-      for (j = newEnd; j >= start; j--) {
-        item = next[j];
-        keyVal = item ? keyFn(item) : item;
-        i = newIndices.get(keyVal);
-        newIndicesNext[j] = i === void 0 ? -1 : i;
-        newIndices.set(keyVal, j);
+      R = new Array(d + 1);
+      for (a = d; a >= f; a--) {
+        T = e[a];
+        h = T ? n(T) : T;
+        c = S.get(h);
+        R[a] = c === undefined ? -1 : c;
+        S.set(h, a);
       }
-      for (i = start; i <= end; i++) {
-        item = getOverrideValue(previous, override, nodes, i);
-        keyVal = item ? keyFn(item) : item;
-        j = newIndices.get(keyVal);
-        if (j !== void 0 && j !== -1) {
-          temp[j] = item;
-          j = newIndicesNext[j];
-          newIndices.set(keyVal, j);
+      for (c = f; c <= E; c++) {
+        T = getOverrideValue(s, o, u, c);
+        h = T ? n(T) : T;
+        a = S.get(h);
+        if (a !== undefined && a !== -1) {
+          _[a] = T;
+          a = R[a];
+          S.set(h, a);
         }
       }
-      for (j = start; j < next.length; j++) {
-        if (j in temp) {
-          const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
-          applyState(next[j], wrapped, keyFn, all);
-        } else
-          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
+      for (a = f; a < e.length; a++) {
+        if (a in _) {
+          const t = wrap(_[a], r);
+          r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], t);
+          applyState(e[a], t, n, i);
+        } else r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
       }
-      if (start < next.length)
-        changed = true;
-    } else if (prevLength && next.length) {
-      for (let i = 0, len = next.length; i < len; i++) {
-        const item = getOverrideValue(previous, override, nodes, i);
-        isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
+      if (f < e.length) t = true;
+    } else if (l && e.length) {
+      for (let t = 0, l = e.length; t < l; t++) {
+        const l = getOverrideValue(s, o, u, t);
+        isWrappable(l) && applyState(e[t], wrap(l, r), n, i);
       }
     }
-    if (prevLength !== next.length) {
-      changed = true;
-      target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
+    if (l !== e.length) {
+      t = true;
+      r[STORE_NODE].length && setSignal(r[STORE_NODE].length, e.length);
     }
-    changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+    t && r[STORE_NODE][$TRACK] && setSignal(r[STORE_NODE][$TRACK], void 0);
     return;
   }
-  if (nodes) {
-    const tracked = nodes[$TRACK];
-    const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      const key = keys[i];
-      const node = nodes[key];
-      const previousValue = unwrap(getOverrideValue(previous, override, nodes, key));
-      let nextValue = unwrap(next[key]);
-      if (previousValue === nextValue)
-        continue;
-      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
-        tracked && setSignal(tracked, void 0);
-        node && setSignal(node, isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
-      } else
-        applyState(nextValue, wrap(previousValue, target), keyFn, all);
-    }
-  }
-  if (nodes = target[STORE_HAS]) {
-    const keys = Object.keys(nodes);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      const key = keys[i];
-      setSignal(nodes[key], key in next);
-    }
-  }
-}
-function reconcile(value, key, all = false) {
-  return (state) => {
-    if (state == null)
-      throw new Error("Cannot reconcile null or undefined state");
-    const keyFn = typeof key === "string" ? (item) => item[key] : key;
-    const eq = keyFn(state);
-    if (eq !== void 0 && keyFn(value) !== keyFn(state))
+  if (u) {
+    const t = u[$TRACK];
+    const l = t || i ? getAllKeys(s, o, e) : Object.keys(u);
+    for (let c = 0, a = l.length; c < a; c++) {
+      const a = l[c];
+      const f = u[a];
+      const E = unwrap(getOverrideValue(s, o, u, a));
+      let d = unwrap(e[a]);
+      if (E === d) continue;
+      if (!E || !isWrappable(E) || (n(E) != null && n(E) !== n(d))) {
+        t && setSignal(t, void 0);
+        f && setSignal(f, isWrappable(d) ? wrap(d, r) : d);
+      } else applyState(d, wrap(E, r), n, i);
+    }
+  }
+  if ((u = r[STORE_HAS])) {
+    const t = Object.keys(u);
+    for (let n = 0, i = t.length; n < i; n++) {
+      const i = t[n];
+      setSignal(u[i], i in e);
+    }
+  }
+}
+function reconcile(e, t, n = false) {
+  return i => {
+    if (i == null) throw new Error("Cannot reconcile null or undefined state");
+    const r = typeof t === "string" ? e => e[t] : t;
+    const s = r(i);
+    if (s !== undefined && r(e) !== r(i))
       throw new Error("Cannot reconcile states with different identity");
-    applyState(value, state, keyFn, all);
+    applyState(e, i, r, n);
   };
 }
-
-// src/store/projection.ts
-function createProjectionInternal(fn, initialValue = {}, options) {
-  let node;
-  const wrappedMap = /* @__PURE__ */ new WeakMap();
-  const traps = {
-    ...storeTraps,
-    get(target, property, receiver) {
-      const o = getOwner();
-      const n = node;
-      (!o || o !== n) && n && read(n);
-      return storeTraps.get(target, property, receiver);
-    }
-  };
-  const wrapProjection = (source) => {
-    if (wrappedMap.has(source))
-      return wrappedMap.get(source);
-    if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
-      return source;
-    const wrapped = createStoreProxy(source, traps, {
+function createProjectionInternal(e, t = {}, n) {
+  let i;
+  const r = new WeakMap();
+  const wrapProjection = e => {
+    if (r.has(e)) return r.get(e);
+    if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
+    const t = createStoreProxy(e, storeTraps, {
       [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: wrappedMap
+      [STORE_LOOKUP]: r,
+      [STORE_FIREWALL]() {
+        return i;
+      }
     });
-    wrappedMap.set(source, wrapped);
-    return wrapped;
+    r.set(e, t);
+    return t;
   };
-  const wrappedStore = wrapProjection(initialValue);
-  node = computed(() => {
-    storeSetter(wrappedStore, (s) => {
-      const value = fn(s);
-      if (value !== s && value !== void 0) {
-        reconcile(value, options?.key || "id", options?.all)(s);
+  const s = wrapProjection(t);
+  i = computed(() => {
+    storeSetter(s, t => {
+      const i = e(t);
+      if (i !== t && i !== undefined) {
+        reconcile(i, n?.key || "id", n?.all)(t);
       }
     });
   });
-  return { store: wrappedStore, node };
-}
-function createProjection(fn, initialValue = {}, options) {
-  return createProjectionInternal(fn, initialValue, options).store;
-}
-
-// src/store/store.ts
-var $TRACK = Symbol(0);
-var $DEEP = Symbol(0);
-var $TARGET = Symbol(0);
-var $PROXY = Symbol(0);
-var $DELETED = Symbol(0);
-var PARENTS = /* @__PURE__ */ new WeakMap();
-var STORE_VALUE = "v";
-var STORE_OVERRIDE = "o";
-var STORE_NODE = "n";
-var STORE_HAS = "h";
-var STORE_WRAP = "w";
-var STORE_LOOKUP = "l";
-function createStoreProxy(value, traps = storeTraps, extend) {
-  let newTarget;
-  if (Array.isArray(value)) {
-    newTarget = [];
-    newTarget.v = value;
-  } else
-    newTarget = { v: value };
-  extend && Object.assign(newTarget, extend);
-  return newTarget[$PROXY] = new Proxy(newTarget, traps);
-}
-var storeLookup = /* @__PURE__ */ new WeakMap();
-function wrap(value, target) {
-  if (target?.[STORE_WRAP])
-    return target[STORE_WRAP](value, target);
-  let p = value[$PROXY] || storeLookup.get(value);
-  if (!p)
-    storeLookup.set(value, p = createStoreProxy(value));
-  return p;
-}
-function isWrappable(obj) {
-  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
-}
-function getNodes(target, type) {
-  let nodes = target[type];
-  if (!nodes)
-    target[type] = nodes = /* @__PURE__ */ Object.create(null);
-  return nodes;
-}
-function getNode(nodes, property, value, equals = isEqual) {
-  if (nodes[property])
-    return nodes[property];
-  return nodes[property] = signal(value, {
-    equals,
-    unobserved() {
-      delete nodes[property];
-    }
-  });
-}
-function trackSelf(target, symbol = $TRACK) {
-  getObserver() && read(getNode(getNodes(target, STORE_NODE), symbol, void 0, false));
-}
-function getKeys(source, override, enumerable = true) {
-  const baseKeys = untrack(() => enumerable ? Object.keys(source) : Reflect.ownKeys(source));
-  if (!override)
-    return baseKeys;
-  const keys = new Set(baseKeys);
-  const overrides = Reflect.ownKeys(override);
-  for (const key of overrides) {
-    if (override[key] !== $DELETED)
-      keys.add(key);
-    else
-      keys.delete(key);
-  }
-  return Array.from(keys);
-}
-function getPropertyDescriptor(source, override, property) {
-  let value = source;
-  if (override && property in override) {
-    if (value[property] === $DELETED)
-      return void 0;
-    if (!(property in value))
-      value = override;
-  }
-  return Reflect.getOwnPropertyDescriptor(value, property);
-}
-var Writing = null;
-var storeTraps = {
-  get(target, property, receiver) {
-    if (property === $TARGET)
-      return target;
-    if (property === $PROXY)
-      return receiver;
-    if (property === $TRACK || property === $DEEP) {
-      trackSelf(target, property);
-      return receiver;
-    }
-    const nodes = getNodes(target, STORE_NODE);
-    const tracked = nodes[property];
-    const overridden = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE];
-    const proxySource = !!target[STORE_VALUE][$TARGET];
-    const storeValue = overridden ? target[STORE_OVERRIDE] : target[STORE_VALUE];
-    if (!tracked) {
-      const desc = Object.getOwnPropertyDescriptor(storeValue, property);
-      if (desc && desc.get)
-        return desc.get.call(receiver);
-    }
-    if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked.e !== NOT_PENDING ? tracked.e : tracked.g : storeValue[property];
-      value2 === $DELETED && (value2 = void 0);
-      if (!isWrappable(value2))
-        return value2;
-      const wrapped = wrap(value2, target);
-      Writing.add(wrapped);
-      return wrapped;
-    }
-    let value = tracked ? overridden || !proxySource ? read(nodes[property]) : (read(nodes[property]), storeValue[property]) : storeValue[property];
-    value === $DELETED && (value = void 0);
-    if (!tracked) {
-      if (!overridden && typeof value === "function" && !storeValue.hasOwnProperty(property)) {
-        let proto;
-        return !Array.isArray(target[STORE_VALUE]) && (proto = Object.getPrototypeOf(target[STORE_VALUE])) && proto !== Object.prototype ? value.bind(storeValue) : value;
+  return { store: s, node: i };
+}
+function createProjection(e, t = {}, n) {
+  return createProjectionInternal(e, t, n).store;
+}
+const $TRACK = Symbol(0),
+  $DEEP = Symbol(0),
+  $TARGET = Symbol(0),
+  $PROXY = Symbol(0),
+  $DELETED = Symbol(0);
+const PARENTS = new WeakMap();
+const STORE_VALUE = "v",
+  STORE_OVERRIDE = "o",
+  STORE_NODE = "n",
+  STORE_HAS = "h",
+  STORE_WRAP = "w",
+  STORE_LOOKUP = "l",
+  STORE_FIREWALL = "f";
+function createStoreProxy(e, t = storeTraps, n) {
+  let i;
+  if (Array.isArray(e)) {
+    i = [];
+    i.v = e;
+  } else i = { v: e };
+  n && Object.assign(i, n);
+  return (i[$PROXY] = new Proxy(i, t));
+}
+const storeLookup = new WeakMap();
+function wrap(e, t) {
+  if (t?.[STORE_WRAP]) return t[STORE_WRAP](e, t);
+  let n = e[$PROXY] || storeLookup.get(e);
+  if (!n) storeLookup.set(e, (n = createStoreProxy(e)));
+  return n;
+}
+function isWrappable(e) {
+  return e != null && typeof e === "object" && !Object.isFrozen(e);
+}
+function getNodes(e, t) {
+  let n = e[t];
+  if (!n) e[t] = n = Object.create(null);
+  return n;
+}
+function getNode(e, t, n, i, r = isEqual) {
+  if (e[t]) return e[t];
+  return (e[t] = signal(
+    n,
+    {
+      equals: r,
+      unobserved() {
+        delete e[t];
+      }
+    },
+    i
+  ));
+}
+function trackSelf(e, t = $TRACK) {
+  getObserver() &&
+    read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL]?.(), false));
+}
+function getKeys(e, t, n = true) {
+  const i = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
+  if (!t) return i;
+  const r = new Set(i);
+  const s = Reflect.ownKeys(t);
+  for (const e of s) {
+    if (t[e] !== $DELETED) r.add(e);
+    else r.delete(e);
+  }
+  return Array.from(r);
+}
+function getPropertyDescriptor(e, t, n) {
+  let i = e;
+  if (t && n in t) {
+    if (i[n] === $DELETED) return void 0;
+    if (!(n in i)) i = t;
+  }
+  return Reflect.getOwnPropertyDescriptor(i, n);
+}
+let Writing = null;
+const storeTraps = {
+  get(e, t, n) {
+    if (t === $TARGET) return e;
+    if (t === $PROXY) return n;
+    if (t === $TRACK || t === $DEEP) {
+      trackSelf(e, t);
+      return n;
+    }
+    const i = getNodes(e, STORE_NODE);
+    const r = i[t];
+    const s = e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE];
+    const o = !!e[STORE_VALUE][$TARGET];
+    const u = s ? e[STORE_OVERRIDE] : e[STORE_VALUE];
+    if (!r) {
+      const e = Object.getOwnPropertyDescriptor(u, t);
+      if (e && e.get) return e.get.call(n);
+    }
+    if (Writing?.has(n)) {
+      let n = r && (s || !o) ? (r.W !== NOT_PENDING ? r.W : r.j) : u[t];
+      n === $DELETED && (n = undefined);
+      if (!isWrappable(n)) return n;
+      const i = wrap(n, e);
+      Writing.add(i);
+      return i;
+    }
+    let l = r ? (s || !o ? read(i[t]) : (read(i[t]), u[t])) : u[t];
+    l === $DELETED && (l = undefined);
+    if (!r) {
+      if (!s && typeof l === "function" && !u.hasOwnProperty(t)) {
+        let t;
+        return !Array.isArray(e[STORE_VALUE]) &&
+          (t = Object.getPrototypeOf(e[STORE_VALUE])) &&
+          t !== Object.prototype
+          ? l.bind(u)
+          : l;
       } else if (getObserver()) {
-        return read(getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value));
+        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]?.()));
       }
     }
-    return isWrappable(value) ? wrap(value, target) : value;
+    return isWrappable(l) ? wrap(l, e) : l;
   },
-  has(target, property) {
-    if (property === $PROXY || property === $TRACK || property === "__proto__")
-      return true;
-    const has = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] !== $DELETED : property in target[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has));
-    return has;
+  has(e, t) {
+    if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
+    const n =
+      e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
+        ? e[STORE_OVERRIDE][t] !== $DELETED
+        : t in e[STORE_VALUE];
+    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]?.()));
+    return n;
   },
-  set(target, property, rawValue) {
-    const store = target[$PROXY];
-    if (Writing?.has(target[$PROXY])) {
+  set(e, t, n) {
+    const i = e[$PROXY];
+    if (Writing?.has(e[$PROXY])) {
       untrack(() => {
-        const state = target[STORE_VALUE];
-        const base = state[property];
-        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : base;
-        const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
-        if (prev === value)
-          return true;
-        const len = target[STORE_OVERRIDE]?.length || state.length;
-        if (value !== void 0 && value === base)
-          delete target[STORE_OVERRIDE][property];
-        else
-          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = /* @__PURE__ */ Object.create(null)))[property] = value;
-        const wrappable = isWrappable(value);
-        if (isWrappable(prev)) {
-          const parents = PARENTS.get(prev);
-          parents && (parents instanceof Set ? parents.delete(store) : PARENTS.delete(prev));
+        const r = e[STORE_VALUE];
+        const s = r[t];
+        const o = e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE] ? e[STORE_OVERRIDE][t] : s;
+        const u = n?.[$TARGET]?.[STORE_VALUE] ?? n;
+        if (o === u) return true;
+        const l = e[STORE_OVERRIDE]?.length || r.length;
+        if (u !== undefined && u === s) delete e[STORE_OVERRIDE][t];
+        else (e[STORE_OVERRIDE] || (e[STORE_OVERRIDE] = Object.create(null)))[t] = u;
+        const c = isWrappable(u);
+        if (isWrappable(o)) {
+          const e = PARENTS.get(o);
+          e && (e instanceof Set ? e.delete(i) : PARENTS.delete(o));
         }
-        if (recursivelyNotify(store, storeLookup) && wrappable)
-          recursivelyAddParent(value, store);
-        target[STORE_HAS]?.[property] && setSignal(target[STORE_HAS][property], true);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] && setSignal(nodes[property], () => wrappable ? wrap(value, target) : value);
-        if (Array.isArray(state)) {
-          const index = parseInt(property) + 1;
-          if (index > len)
-            nodes.length && setSignal(nodes.length, index);
+        if (recursivelyNotify(i, storeLookup) && c) recursivelyAddParent(u, i);
+        e[STORE_HAS]?.[t] && setSignal(e[STORE_HAS][t], true);
+        const a = getNodes(e, STORE_NODE);
+        a[t] && setSignal(a[t], () => (c ? wrap(u, e) : u));
+        if (Array.isArray(r)) {
+          const e = parseInt(t) + 1;
+          if (e > l) a.length && setSignal(a.length, e);
         }
-        nodes[$TRACK] && setSignal(nodes[$TRACK], void 0);
+        a[$TRACK] && setSignal(a[$TRACK], undefined);
       });
     }
     return true;
   },
-  deleteProperty(target, property) {
-    if (Writing?.has(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
+  deleteProperty(e, t) {
+    if (Writing?.has(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
       untrack(() => {
-        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : target[STORE_VALUE][property];
-        if (property in target[STORE_VALUE]) {
-          (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = /* @__PURE__ */ Object.create(null)))[property] = $DELETED;
-        } else if (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]) {
-          delete target[STORE_OVERRIDE][property];
-        } else
-          return true;
-        if (isWrappable(prev)) {
-          const parents = PARENTS.get(prev);
-          parents && (parents instanceof Set ? parents.delete(target) : PARENTS.delete(prev));
+        const n =
+          e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE] ? e[STORE_OVERRIDE][t] : e[STORE_VALUE][t];
+        if (t in e[STORE_VALUE]) {
+          (e[STORE_OVERRIDE] || (e[STORE_OVERRIDE] = Object.create(null)))[t] = $DELETED;
+        } else if (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]) {
+          delete e[STORE_OVERRIDE][t];
+        } else return true;
+        if (isWrappable(n)) {
+          const t = PARENTS.get(n);
+          t && (t instanceof Set ? t.delete(e) : PARENTS.delete(n));
         }
-        if (target[STORE_HAS]?.[property])
-          setSignal(target[STORE_HAS][property], false);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] && setSignal(nodes[property], void 0);
-        nodes[$TRACK] && setSignal(nodes[$TRACK], void 0);
+        if (e[STORE_HAS]?.[t]) setSignal(e[STORE_HAS][t], false);
+        const i = getNodes(e, STORE_NODE);
+        i[t] && setSignal(i[t], undefined);
+        i[$TRACK] && setSignal(i[$TRACK], undefined);
       });
     }
     return true;
   },
-  ownKeys(target) {
-    trackSelf(target);
-    return getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
+  ownKeys(e) {
+    trackSelf(e);
+    return getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);
   },
-  getOwnPropertyDescriptor(target, property) {
-    if (property === $PROXY)
-      return { value: target[$PROXY], writable: true, configurable: true };
-    return getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
+  getOwnPropertyDescriptor(e, t) {
+    if (t === $PROXY) return { value: e[$PROXY], writable: true, configurable: true };
+    return getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
   },
-  getPrototypeOf(target) {
-    return Object.getPrototypeOf(target[STORE_VALUE]);
+  getPrototypeOf(e) {
+    return Object.getPrototypeOf(e[STORE_VALUE]);
   }
 };
-function storeSetter(store, fn) {
-  const prevWriting = Writing;
-  Writing = /* @__PURE__ */ new Set();
-  Writing.add(store);
+function storeSetter(e, t) {
+  const n = Writing;
+  Writing = new Set();
+  Writing.add(e);
   try {
-    const value = fn(store);
-    if (value !== store && value !== void 0) {
-      if (Array.isArray(value)) {
-        for (let i = 0, len = value.length; i < len; i++)
-          store[i] = value[i];
-        store.length = value.length;
+    const n = t(e);
+    if (n !== e && n !== undefined) {
+      if (Array.isArray(n)) {
+        for (let t = 0, i = n.length; t < i; t++) e[t] = n[t];
+        e.length = n.length;
       } else {
-        const keys = /* @__PURE__ */ new Set([...Object.keys(store), ...Object.keys(value)]);
-        keys.forEach((key) => {
-          if (key in value)
-            store[key] = value[key];
-          else
-            delete store[key];
+        const t = new Set([...Object.keys(e), ...Object.keys(n)]);
+        t.forEach(t => {
+          if (t in n) e[t] = n[t];
+          else delete e[t];
         });
       }
     }
   } finally {
     Writing.clear();
-    Writing = prevWriting;
-  }
-}
-function createStore(first, second, options) {
-  const derived = typeof first === "function", wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
-  return [wrappedStore, (fn) => storeSetter(wrappedStore, fn)];
-}
-function recursivelyNotify(state, lookup) {
-  let target = state[$TARGET] || lookup?.get(state)?.[$TARGET];
-  let notified = false;
-  if (target) {
-    const deep2 = getNodes(target, STORE_NODE)[$DEEP];
-    if (deep2) {
-      setSignal(deep2, void 0);
-      notified = true;
-    }
-    lookup = target[STORE_LOOKUP] || lookup;
-  }
-  const parents = PARENTS.get(target?.[STORE_VALUE] || state);
-  if (!parents)
-    return notified;
-  if (parents instanceof Set) {
-    for (let parent of parents)
-      notified = recursivelyNotify(parent, lookup) || notified;
-  } else
-    notified = recursivelyNotify(parents, lookup) || notified;
-  return notified;
-}
-function recursivelyAddParent(state, parent) {
-  let override;
-  const target = state[$TARGET];
-  if (target) {
-    override = target[STORE_OVERRIDE];
-    state = target[STORE_VALUE];
-  }
-  if (parent) {
-    let parents = PARENTS.get(state);
-    if (!parents)
-      PARENTS.set(state, parent);
-    else if (parents !== parent) {
-      if (!(parents instanceof Set))
-        PARENTS.set(state, parents = /* @__PURE__ */ new Set([parents]));
-      else if (parents.has(parent))
-        return;
-      parents.add(parent);
-    } else
-      return;
-  }
-  if (Array.isArray(state)) {
-    const len = override?.length || state.length;
-    for (let i = 0; i < len; i++) {
-      const item = override && i in override ? override[i] : state[i];
-      isWrappable(item) && recursivelyAddParent(item, state);
+    Writing = n;
+  }
+}
+function createStore(e, t, n) {
+  const i = typeof e === "function",
+    r = i ? createProjectionInternal(e, t, n).store : wrap(e);
+  return [r, e => storeSetter(r, e)];
+}
+function recursivelyNotify(e, t) {
+  let n = e[$TARGET] || t?.get(e)?.[$TARGET];
+  let i = false;
+  if (n) {
+    const e = getNodes(n, STORE_NODE)[$DEEP];
+    if (e) {
+      setSignal(e, undefined);
+      i = true;
+    }
+    t = n[STORE_LOOKUP] || t;
+  }
+  const r = PARENTS.get(n?.[STORE_VALUE] || e);
+  if (!r) return i;
+  if (r instanceof Set) {
+    for (let e of r) i = recursivelyNotify(e, t) || i;
+  } else i = recursivelyNotify(r, t) || i;
+  return i;
+}
+function recursivelyAddParent(e, t) {
+  let n;
+  const i = e[$TARGET];
+  if (i) {
+    n = i[STORE_OVERRIDE];
+    e = i[STORE_VALUE];
+  }
+  if (t) {
+    let n = PARENTS.get(e);
+    if (!n) PARENTS.set(e, t);
+    else if (n !== t) {
+      if (!(n instanceof Set)) PARENTS.set(e, (n = new Set([n])));
+      else if (n.has(t)) return;
+      n.add(t);
+    } else return;
+  }
+  if (Array.isArray(e)) {
+    const t = n?.length || e.length;
+    for (let i = 0; i < t; i++) {
+      const t = n && i in n ? n[i] : e[i];
+      isWrappable(t) && recursivelyAddParent(t, e);
     }
   } else {
-    const keys = getKeys(state, override);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const item = override && key in override ? override[key] : state[key];
-      isWrappable(item) && recursivelyAddParent(item, state);
+    const t = getKeys(e, n);
+    for (let i = 0; i < t.length; i++) {
+      const r = t[i];
+      const s = n && r in n ? n[r] : e[r];
+      isWrappable(s) && recursivelyAddParent(s, e);
     }
   }
 }
-function deep(store) {
-  recursivelyAddParent(store);
-  return store[$DEEP];
+function deep(e) {
+  recursivelyAddParent(e);
+  return e[$DEEP];
 }
-
-// src/store/optimistic.ts
-function createOptimisticStore(first, second, options) {
+function createOptimisticStore(e, t, n) {
   return [];
 }
-
-// src/store/utils.ts
-function snapshot(item, map, lookup) {
-  let target, isArray, override, result, unwrapped, v;
-  if (!isWrappable(item))
-    return item;
-  if (map && map.has(item))
-    return map.get(item);
-  if (!map)
-    map = /* @__PURE__ */ new Map();
-  if (target = item[$TARGET] || lookup?.get(item)?.[$TARGET]) {
-    override = target[STORE_OVERRIDE];
-    isArray = Array.isArray(target[STORE_VALUE]);
-    map.set(
-      item,
-      override ? result = isArray ? [] : Object.create(Object.getPrototypeOf(target[STORE_VALUE])) : target[STORE_VALUE]
+function snapshot(e, t, n) {
+  let i, r, s, o, u, l;
+  if (!isWrappable(e)) return e;
+  if (t && t.has(e)) return t.get(e);
+  if (!t) t = new Map();
+  if ((i = e[$TARGET] || n?.get(e)?.[$TARGET])) {
+    s = i[STORE_OVERRIDE];
+    r = Array.isArray(i[STORE_VALUE]);
+    t.set(
+      e,
+      s ? (o = r ? [] : Object.create(Object.getPrototypeOf(i[STORE_VALUE]))) : i[STORE_VALUE]
     );
-    item = target[STORE_VALUE];
-    lookup = storeLookup;
+    e = i[STORE_VALUE];
+    n = storeLookup;
   } else {
-    isArray = Array.isArray(item);
-    map.set(item, item);
-  }
-  if (isArray) {
-    const len = override?.length || item.length;
-    for (let i = 0; i < len; i++) {
-      v = override && i in override ? override[i] : item[i];
-      if (v === $DELETED)
-        continue;
-      if ((unwrapped = snapshot(v, map, lookup)) !== v || result) {
-        if (!result)
-          map.set(item, result = [...item]);
-        result[i] = unwrapped;
+    r = Array.isArray(e);
+    t.set(e, e);
+  }
+  if (r) {
+    const i = s?.length || e.length;
+    for (let r = 0; r < i; r++) {
+      l = s && r in s ? s[r] : e[r];
+      if (l === $DELETED) continue;
+      if ((u = snapshot(l, t, n)) !== l || o) {
+        if (!o) t.set(e, (o = [...e]));
+        o[r] = u;
       }
     }
   } else {
-    const keys = getKeys(item, override);
-    for (let i = 0, l = keys.length; i < l; i++) {
-      let prop = keys[i];
-      const desc = getPropertyDescriptor(item, override, prop);
-      if (desc.get)
-        continue;
-      v = override && prop in override ? override[prop] : item[prop];
-      if ((unwrapped = snapshot(v, map, lookup)) !== item[prop] || result) {
-        if (!result) {
-          result = Object.create(Object.getPrototypeOf(item));
-          Object.assign(result, item);
+    const i = getKeys(e, s);
+    for (let r = 0, c = i.length; r < c; r++) {
+      let c = i[r];
+      const a = getPropertyDescriptor(e, s, c);
+      if (a.get) continue;
+      l = s && c in s ? s[c] : e[c];
+      if ((u = snapshot(l, t, n)) !== e[c] || o) {
+        if (!o) {
+          o = Object.create(Object.getPrototypeOf(e));
+          Object.assign(o, e);
         }
-        result[prop] = unwrapped;
+        o[c] = u;
       }
     }
   }
-  return result || item;
+  return o || e;
 }
 function trueFn() {
   return true;
 }
-var propTraps = {
-  get(_, property, receiver) {
-    if (property === $PROXY)
-      return receiver;
-    return _.get(property);
+const propTraps = {
+  get(e, t, n) {
+    if (t === $PROXY) return n;
+    return e.get(t);
   },
-  has(_, property) {
-    if (property === $PROXY)
-      return true;
-    return _.has(property);
+  has(e, t) {
+    if (t === $PROXY) return true;
+    return e.has(t);
   },
   set: trueFn,
   deleteProperty: trueFn,
-  getOwnPropertyDescriptor(_, property) {
+  getOwnPropertyDescriptor(e, t) {
     return {
       configurable: true,
       enumerable: true,
       get() {
-        return _.get(property);
+        return e.get(t);
       },
       set: trueFn,
       deleteProperty: trueFn
     };
   },
-  ownKeys(_) {
-    return _.keys();
+  ownKeys(e) {
+    return e.keys();
   }
 };
-function resolveSource(s) {
-  return !(s = typeof s === "function" ? s() : s) ? {} : s;
-}
-var $SOURCES = Symbol(0);
-function merge(...sources) {
-  if (sources.length === 1 && typeof sources[0] !== "function")
-    return sources[0];
-  let proxy = false;
-  const flattened = [];
-  for (let i = 0; i < sources.length; i++) {
-    const s = sources[i];
-    proxy = proxy || !!s && $PROXY in s;
-    const childSources = !!s && s[$SOURCES];
-    if (childSources)
-      flattened.push(...childSources);
-    else
-      flattened.push(
-        typeof s === "function" ? (proxy = true, createMemo(s)) : s
-      );
-  }
-  if (SUPPORTS_PROXY && proxy) {
+function resolveSource(e) {
+  return !(e = typeof e === "function" ? e() : e) ? {} : e;
+}
+const $SOURCES = Symbol(0);
+function merge(...e) {
+  if (e.length === 1 && typeof e[0] !== "function") return e[0];
+  let t = false;
+  const n = [];
+  for (let i = 0; i < e.length; i++) {
+    const r = e[i];
+    t = t || (!!r && $PROXY in r);
+    const s = !!r && r[$SOURCES];
+    if (s) n.push(...s);
+    else n.push(typeof r === "function" ? ((t = true), createMemo(r)) : r);
+  }
+  if (SUPPORTS_PROXY && t) {
     return new Proxy(
       {
-        get(property) {
-          if (property === $SOURCES)
-            return flattened;
-          for (let i = flattened.length - 1; i >= 0; i--) {
-            const s = resolveSource(flattened[i]);
-            if (property in s)
-              return s[property];
+        get(e) {
+          if (e === $SOURCES) return n;
+          for (let t = n.length - 1; t >= 0; t--) {
+            const i = resolveSource(n[t]);
+            if (e in i) return i[e];
           }
         },
-        has(property) {
-          for (let i = flattened.length - 1; i >= 0; i--) {
-            if (property in resolveSource(flattened[i]))
-              return true;
+        has(e) {
+          for (let t = n.length - 1; t >= 0; t--) {
+            if (e in resolveSource(n[t])) return true;
           }
           return false;
         },
         keys() {
-          const keys = [];
-          for (let i = 0; i < flattened.length; i++)
-            keys.push(...Object.keys(resolveSource(flattened[i])));
-          return [...new Set(keys)];
+          const e = [];
+          for (let t = 0; t < n.length; t++) e.push(...Object.keys(resolveSource(n[t])));
+          return [...new Set(e)];
         }
       },
       propTraps
     );
   }
-  const defined = /* @__PURE__ */ Object.create(null);
-  let nonTargetKey = false;
-  let lastIndex = flattened.length - 1;
-  for (let i = lastIndex; i >= 0; i--) {
-    const source = flattened[i];
-    if (!source) {
-      i === lastIndex && lastIndex--;
+  const i = Object.create(null);
+  let r = false;
+  let s = n.length - 1;
+  for (let e = s; e >= 0; e--) {
+    const t = n[e];
+    if (!t) {
+      e === s && s--;
       continue;
     }
-    const sourceKeys = Object.getOwnPropertyNames(source);
-    for (let j = sourceKeys.length - 1; j >= 0; j--) {
-      const key = sourceKeys[j];
-      if (key === "__proto__" || key === "constructor")
-        continue;
-      if (!defined[key]) {
-        nonTargetKey = nonTargetKey || i !== lastIndex;
-        const desc = Object.getOwnPropertyDescriptor(source, key);
-        defined[key] = desc.get ? {
-          enumerable: true,
-          configurable: true,
-          get: desc.get.bind(source)
-        } : desc;
+    const o = Object.getOwnPropertyNames(t);
+    for (let n = o.length - 1; n >= 0; n--) {
+      const u = o[n];
+      if (u === "__proto__" || u === "constructor") continue;
+      if (!i[u]) {
+        r = r || e !== s;
+        const n = Object.getOwnPropertyDescriptor(t, u);
+        i[u] = n.get ? { enumerable: true, configurable: true, get: n.get.bind(t) } : n;
       }
     }
   }
-  if (!nonTargetKey)
-    return flattened[lastIndex];
-  const target = {};
-  const definedKeys = Object.keys(defined);
-  for (let i = definedKeys.length - 1; i >= 0; i--) {
-    const key = definedKeys[i], desc = defined[key];
-    if (desc.get)
-      Object.defineProperty(target, key, desc);
-    else
-      target[key] = desc.value;
+  if (!r) return n[s];
+  const o = {};
+  const u = Object.keys(i);
+  for (let e = u.length - 1; e >= 0; e--) {
+    const t = u[e],
+      n = i[t];
+    if (n.get) Object.defineProperty(o, t, n);
+    else o[t] = n.value;
   }
-  target[$SOURCES] = flattened;
-  return target;
+  o[$SOURCES] = n;
+  return o;
 }
-function omit(props, ...keys) {
-  const blocked = new Set(keys);
-  if (SUPPORTS_PROXY && $PROXY in props) {
+function omit(e, ...t) {
+  const n = new Set(t);
+  if (SUPPORTS_PROXY && $PROXY in e) {
     return new Proxy(
       {
-        get(property) {
-          return blocked.has(property) ? void 0 : props[property];
+        get(t) {
+          return n.has(t) ? undefined : e[t];
         },
-        has(property) {
-          return !blocked.has(property) && property in props;
+        has(t) {
+          return !n.has(t) && t in e;
         },
         keys() {
-          return Object.keys(props).filter((k) => !blocked.has(k));
+          return Object.keys(e).filter(e => !n.has(e));
         }
       },
       propTraps
     );
   }
-  const result = {};
-  for (const propName of Object.getOwnPropertyNames(props)) {
-    if (!blocked.has(propName)) {
-      const desc = Object.getOwnPropertyDescriptor(props, propName);
-      !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable ? result[propName] = desc.value : Object.defineProperty(result, propName, desc);
+  const i = {};
+  for (const t of Object.getOwnPropertyNames(e)) {
+    if (!n.has(t)) {
+      const n = Object.getOwnPropertyDescriptor(e, t);
+      !n.get && !n.set && n.enumerable && n.writable && n.configurable
+        ? (i[t] = n.value)
+        : Object.defineProperty(i, t, n);
     }
   }
-  return result;
+  return i;
 }
-
-// src/map.ts
-function mapArray(list, map, options) {
-  const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
+function mapArray(e, t, n) {
+  const i = typeof n?.keyed === "function" ? n.keyed : undefined;
   return createMemo(
     updateKeyedMap.bind({
-      B: createOwner(),
-      m: 0,
-      va: list,
-      G: [],
-      O: map,
-      d: [],
-      a: [],
-      P: keyFn,
-      n: keyFn || options?.keyed === false ? [] : void 0,
-      o: map.length > 1 ? [] : void 0,
-      X: options?.fallback
+      Ie: createOwner(),
+      ge: 0,
+      ye: e,
+      Ce: [],
+      De: t,
+      Pe: [],
+      we: [],
+      be: i,
+      Ve: i || n?.keyed === false ? [] : undefined,
+      Ue: t.length > 1 ? [] : undefined,
+      me: n?.fallback
     })
   );
 }
-var pureOptions = { pureWrite: true };
+const pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.va() || [], newLen = newItems.length;
-  newItems[$TRACK];
-  runWithOwner(this.B, () => {
-    let i, j, mapper = this.n ? () => {
-      this.n[j] = signal(newItems[j], pureOptions);
-      this.o && (this.o[j] = signal(j, pureOptions));
-      return this.O(
-        read.bind(null, this.n[j]),
-        this.o ? read.bind(null, this.o[j]) : void 0
-      );
-    } : this.o ? () => {
-      const item = newItems[j];
-      this.o[j] = signal(j, pureOptions);
-      return this.O(
-        () => item,
-        read.bind(null, this.o[j])
-      );
-    } : () => {
-      const item = newItems[j];
-      return this.O(() => item);
-    };
-    if (newLen === 0) {
-      if (this.m !== 0) {
-        this.B.dispose(false);
-        this.a = [];
-        this.G = [];
-        this.d = [];
-        this.m = 0;
-        this.n && (this.n = []);
-        this.o && (this.o = []);
+  const e = this.ye() || [],
+    t = e.length;
+  e[$TRACK];
+  runWithOwner(this.Ie, () => {
+    let n,
+      i,
+      r = this.Ve
+        ? () => {
+            this.Ve[i] = signal(e[i], pureOptions);
+            this.Ue && (this.Ue[i] = signal(i, pureOptions));
+            return this.De(
+              read.bind(null, this.Ve[i]),
+              this.Ue ? read.bind(null, this.Ue[i]) : undefined
+            );
+          }
+        : this.Ue
+          ? () => {
+              const t = e[i];
+              this.Ue[i] = signal(i, pureOptions);
+              return this.De(() => t, read.bind(null, this.Ue[i]));
+            }
+          : () => {
+              const t = e[i];
+              return this.De(() => t);
+            };
+    if (t === 0) {
+      if (this.ge !== 0) {
+        this.Ie.dispose(false);
+        this.we = [];
+        this.Ce = [];
+        this.Pe = [];
+        this.ge = 0;
+        this.Ve && (this.Ve = []);
+        this.Ue && (this.Ue = []);
       }
-      if (this.X && !this.d[0]) {
-        this.d[0] = runWithOwner(
-          this.a[0] = createOwner(),
-          this.X
-        );
+      if (this.me && !this.Pe[0]) {
+        this.Pe[0] = runWithOwner((this.we[0] = createOwner()), this.me);
       }
-    } else if (this.m === 0) {
-      if (this.a[0])
-        this.a[0].dispose();
-      this.d = new Array(newLen);
-      for (j = 0; j < newLen; j++) {
-        this.G[j] = newItems[j];
-        this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
+    } else if (this.ge === 0) {
+      if (this.we[0]) this.we[0].dispose();
+      this.Pe = new Array(t);
+      for (i = 0; i < t; i++) {
+        this.Ce[i] = e[i];
+        this.Pe[i] = runWithOwner((this.we[i] = createOwner()), r);
       }
-      this.m = newLen;
+      this.ge = t;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.n ? new Array(newLen) : void 0, tempIndexes = this.o ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.m, newLen); start < end && (this.G[start] === newItems[start] || this.n && compare(this.P, this.G[start], newItems[start])); start++) {
-        if (this.n)
-          setSignal(this.n[start], newItems[start]);
+      let s,
+        o,
+        u,
+        l,
+        c,
+        a,
+        f,
+        E = new Array(t),
+        d = new Array(t),
+        T = this.Ve ? new Array(t) : undefined,
+        R = this.Ue ? new Array(t) : undefined;
+      for (
+        s = 0, o = Math.min(this.ge, t);
+        s < o && (this.Ce[s] === e[s] || (this.Ve && compare(this.be, this.Ce[s], e[s])));
+        s++
+      ) {
+        if (this.Ve) setSignal(this.Ve[s], e[s]);
       }
-      for (end = this.m - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.G[end] === newItems[newEnd] || this.n && compare(this.P, this.G[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.d[end];
-        tempNodes[newEnd] = this.a[end];
-        tempRows && (tempRows[newEnd] = this.n[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.o[end]);
+      for (
+        o = this.ge - 1, u = t - 1;
+        o >= s &&
+        u >= s &&
+        (this.Ce[o] === e[u] || (this.Ve && compare(this.be, this.Ce[o], e[u])));
+        o--, u--
+      ) {
+        E[u] = this.Pe[o];
+        d[u] = this.we[o];
+        T && (T[u] = this.Ve[o]);
+        R && (R[u] = this.Ue[o]);
       }
-      newIndices = /* @__PURE__ */ new Map();
-      newIndicesNext = new Array(newEnd + 1);
-      for (j = newEnd; j >= start; j--) {
-        item = newItems[j];
-        key = this.P ? this.P(item) : item;
-        i = newIndices.get(key);
-        newIndicesNext[j] = i === void 0 ? -1 : i;
-        newIndices.set(key, j);
+      a = new Map();
+      f = new Array(u + 1);
+      for (i = u; i >= s; i--) {
+        l = e[i];
+        c = this.be ? this.be(l) : l;
+        n = a.get(c);
+        f[i] = n === undefined ? -1 : n;
+        a.set(c, i);
       }
-      for (i = start; i <= end; i++) {
-        item = this.G[i];
-        key = this.P ? this.P(item) : item;
-        j = newIndices.get(key);
-        if (j !== void 0 && j !== -1) {
-          temp[j] = this.d[i];
-          tempNodes[j] = this.a[i];
-          tempRows && (tempRows[j] = this.n[i]);
-          tempIndexes && (tempIndexes[j] = this.o[i]);
-          j = newIndicesNext[j];
-          newIndices.set(key, j);
-        } else
-          this.a[i].dispose();
+      for (n = s; n <= o; n++) {
+        l = this.Ce[n];
+        c = this.be ? this.be(l) : l;
+        i = a.get(c);
+        if (i !== undefined && i !== -1) {
+          E[i] = this.Pe[n];
+          d[i] = this.we[n];
+          T && (T[i] = this.Ve[n]);
+          R && (R[i] = this.Ue[n]);
+          i = f[i];
+          a.set(c, i);
+        } else this.we[n].dispose();
       }
-      for (j = start; j < newLen; j++) {
-        if (j in temp) {
-          this.d[j] = temp[j];
-          this.a[j] = tempNodes[j];
-          if (tempRows) {
-            this.n[j] = tempRows[j];
-            setSignal(this.n[j], newItems[j]);
+      for (i = s; i < t; i++) {
+        if (i in E) {
+          this.Pe[i] = E[i];
+          this.we[i] = d[i];
+          if (T) {
+            this.Ve[i] = T[i];
+            setSignal(this.Ve[i], e[i]);
           }
-          if (tempIndexes) {
-            this.o[j] = tempIndexes[j];
-            setSignal(this.o[j], j);
+          if (R) {
+            this.Ue[i] = R[i];
+            setSignal(this.Ue[i], i);
           }
         } else {
-          this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
+          this.Pe[i] = runWithOwner((this.we[i] = createOwner()), r);
         }
       }
-      this.d = this.d.slice(0, this.m = newLen);
-      this.G = newItems.slice(0);
+      this.Pe = this.Pe.slice(0, (this.ge = t));
+      this.Ce = e.slice(0);
     }
   });
-  return this.d;
+  return this.Pe;
 }
-function repeat(count, map, options) {
+function repeat(e, t, n) {
   return updateRepeat.bind({
-    B: createOwner(),
-    m: 0,
-    y: 0,
-    wa: count,
-    O: map,
-    a: [],
-    d: [],
-    xa: options?.from,
-    X: options?.fallback
+    Ie: createOwner(),
+    ge: 0,
+    ke: 0,
+    ve: e,
+    De: t,
+    we: [],
+    Pe: [],
+    xe: n?.from,
+    me: n?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.wa();
-  const from = this.xa?.() || 0;
-  runWithOwner(this.B, () => {
-    if (newLen === 0) {
-      if (this.m !== 0) {
-        this.B.dispose(false);
-        this.a = [];
-        this.d = [];
-        this.m = 0;
+  const e = this.ve();
+  const t = this.xe?.() || 0;
+  runWithOwner(this.Ie, () => {
+    if (e === 0) {
+      if (this.ge !== 0) {
+        this.Ie.dispose(false);
+        this.we = [];
+        this.Pe = [];
+        this.ge = 0;
       }
-      if (this.X && !this.d[0]) {
-        this.d[0] = runWithOwner(
-          this.a[0] = createOwner(),
-          this.X
-        );
+      if (this.me && !this.Pe[0]) {
+        this.Pe[0] = runWithOwner((this.we[0] = createOwner()), this.me);
       }
       return;
     }
-    const to = from + newLen;
-    const prevTo = this.y + this.m;
-    if (this.m === 0 && this.a[0])
-      this.a[0].dispose();
-    for (let i = to; i < prevTo; i++)
-      this.a[i - this.y].dispose();
-    if (this.y < from) {
-      let i = this.y;
-      while (i < from && i < this.m)
-        this.a[i++].dispose();
-      this.a.splice(0, from - this.y);
-      this.d.splice(0, from - this.y);
-    } else if (this.y > from) {
-      let i = prevTo - this.y - 1;
-      let difference = this.y - from;
-      this.a.length = this.d.length = newLen;
-      while (i >= difference) {
-        this.a[i] = this.a[i - difference];
-        this.d[i] = this.d[i - difference];
-        i--;
+    const n = t + e;
+    const i = this.ke + this.ge;
+    if (this.ge === 0 && this.we[0]) this.we[0].dispose();
+    for (let e = n; e < i; e++) this.we[e - this.ke].dispose();
+    if (this.ke < t) {
+      let e = this.ke;
+      while (e < t && e < this.ge) this.we[e++].dispose();
+      this.we.splice(0, t - this.ke);
+      this.Pe.splice(0, t - this.ke);
+    } else if (this.ke > t) {
+      let n = i - this.ke - 1;
+      let r = this.ke - t;
+      this.we.length = this.Pe.length = e;
+      while (n >= r) {
+        this.we[n] = this.we[n - r];
+        this.Pe[n] = this.Pe[n - r];
+        n--;
       }
-      for (let i2 = 0; i2 < difference; i2++) {
-        this.d[i2] = runWithOwner(
-          this.a[i2] = createOwner(),
-          () => this.O(i2 + from)
-        );
+      for (let e = 0; e < r; e++) {
+        this.Pe[e] = runWithOwner((this.we[e] = createOwner()), () => this.De(e + t));
       }
     }
-    for (let i = prevTo; i < to; i++) {
-      this.d[i - from] = runWithOwner(
-        this.a[i - from] = createOwner(),
-        () => this.O(i)
-      );
+    for (let e = i; e < n; e++) {
+      this.Pe[e - t] = runWithOwner((this.we[e - t] = createOwner()), () => this.De(e));
     }
-    this.d = this.d.slice(0, newLen);
-    this.y = from;
-    this.m = newLen;
+    this.Pe = this.Pe.slice(0, e);
+    this.ke = t;
+    this.ge = e;
   });
-  return this.d;
-}
-function compare(key, a, b) {
-  return key ? key(a) === key(b) : true;
-}
-
-// src/boundaries.ts
-function boundaryComputed(fn, propagationMask) {
-  const node = computed(fn, void 0, {
-    ja: {
-      la() {
-        let flags = this.f;
-        this.f &= ~this.Y;
-        if (this.Y & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
-          flags &= ~1 /* Pending */;
+  return this.Pe;
+}
+function compare(e, t, n) {
+  return e ? e(t) === e(n) : true;
+}
+function boundaryComputed(e, t) {
+  const n = computed(e, undefined, {
+    _e: {
+      le() {
+        let e = this.J;
+        this.J &= ~this.Ge;
+        if (this.Ge & STATUS_PENDING && !(this.J & STATUS_UNINITIALIZED)) {
+          e &= ~STATUS_PENDING;
         }
-        this.i.notify(this, this.Y, flags);
+        this.Re.notify(this, this.Ge, e);
       },
-      Y: propagationMask
+      Ge: t
     }
   });
-  node.Y = propagationMask;
-  return node;
-}
-function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.i;
-  parentQueue.addChild(owner.i = queue);
-  onCleanup(() => parentQueue.removeChild(owner.i));
-  return runWithOwner(owner, () => {
-    const c = computed(fn);
-    return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
+  n.Ge = t;
+  return n;
+}
+function createBoundChildren(e, t, n, i) {
+  const r = e.Re;
+  r.addChild((e.Re = n));
+  onCleanup(() => r.removeChild(e.Re));
+  return runWithOwner(e, () => {
+    const e = computed(t);
+    return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
   });
 }
-var ConditionalQueue = class extends Queue {
-  u;
-  ga = /* @__PURE__ */ new Set();
-  h = /* @__PURE__ */ new Set();
-  constructor(disabled) {
+class ConditionalQueue extends Queue {
+  He;
+  Qe = new Set();
+  $ = new Set();
+  constructor(e) {
     super();
-    this.u = disabled;
-  }
-  run(type) {
-    if (!type || read(this.u))
-      return;
-    return super.run(type);
-  }
-  notify(node, type, flags) {
-    if (read(this.u)) {
-      if (type & 1 /* Pending */) {
-        if (flags & 1 /* Pending */) {
-          this.h.add(node);
-          type &= ~1 /* Pending */;
-        } else if (this.h.delete(node))
-          type &= ~1 /* Pending */;
+    this.He = e;
+  }
+  run(e) {
+    if (!e || read(this.He)) return;
+    return super.run(e);
+  }
+  notify(e, t, n) {
+    if (read(this.He)) {
+      if (t & STATUS_PENDING) {
+        if (n & STATUS_PENDING) {
+          this.$.add(e);
+          t &= ~STATUS_PENDING;
+        } else if (this.$.delete(e)) t &= ~STATUS_PENDING;
       }
-      if (type & 2 /* Error */) {
-        if (flags & 2 /* Error */) {
-          this.ga.add(node);
-          type &= ~2 /* Error */;
-        } else if (this.ga.delete(node))
-          type &= ~2 /* Error */;
+      if (t & STATUS_ERROR) {
+        if (n & STATUS_ERROR) {
+          this.Qe.add(e);
+          t &= ~STATUS_ERROR;
+        } else if (this.Qe.delete(e)) t &= ~STATUS_ERROR;
       }
     }
-    return type ? super.notify(node, type, flags) : true;
+    return t ? super.notify(e, t, n) : true;
   }
-};
-var CollectionQueue = class extends Queue {
-  Z;
-  a = /* @__PURE__ */ new Set();
-  u = signal(false, { pureWrite: true });
-  qa = false;
-  constructor(type) {
+}
+class CollectionQueue extends Queue {
+  $e;
+  we = new Set();
+  He = signal(false, { pureWrite: true });
+  Le = false;
+  constructor(e) {
     super();
-    this.Z = type;
-  }
-  run(type) {
-    if (!type || read(this.u))
-      return;
-    return super.run(type);
-  }
-  notify(node, type, flags) {
-    if (!(type & this.Z) || this.Z & 1 /* Pending */ && this.qa)
-      return super.notify(node, type, flags);
-    if (flags & this.Z) {
-      this.a.add(node);
-      if (this.a.size === 1)
-        setSignal(this.u, true);
-    } else if (this.a.size > 0) {
-      this.a.delete(node);
-      if (this.a.size === 0)
-        setSignal(this.u, false);
-    }
-    type &= ~this.Z;
-    return type ? super.notify(node, type, flags) : true;
-  }
-};
-function createBoundary(fn, condition) {
-  const owner = createOwner();
-  const queue = new ConditionalQueue(computed(() => condition() === "hidden" /* HIDDEN */));
-  const tree = createBoundChildren(owner, fn, queue, 0);
+    this.$e = e;
+  }
+  run(e) {
+    if (!e || read(this.He)) return;
+    return super.run(e);
+  }
+  notify(e, t, n) {
+    if (!(t & this.$e) || (this.$e & STATUS_PENDING && this.Le)) return super.notify(e, t, n);
+    if (n & this.$e) {
+      this.we.add(e);
+      if (this.we.size === 1) setSignal(this.He, true);
+    } else if (this.we.size > 0) {
+      this.we.delete(e);
+      if (this.we.size === 0) setSignal(this.He, false);
+    }
+    t &= ~this.$e;
+    return t ? super.notify(e, t, n) : true;
+  }
+}
+var BoundaryMode;
+(function (e) {
+  e["VISIBLE"] = "visible";
+  e["HIDDEN"] = "hidden";
+})(BoundaryMode || (BoundaryMode = {}));
+function createBoundary(e, t) {
+  const n = createOwner();
+  const i = new ConditionalQueue(computed(() => t() === BoundaryMode.HIDDEN));
+  const r = createBoundChildren(n, e, i, 0);
   computed(() => {
-    const disabled = read(queue.u);
-    tree.Y = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
-    if (!disabled) {
-      queue.h.forEach(
-        (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
-      );
-      queue.ga.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
-      queue.h.clear();
-      queue.ga.clear();
+    const e = read(i.He);
+    r.Ge = e ? STATUS_ERROR | STATUS_PENDING : 0;
+    if (!e) {
+      i.$.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING));
+      i.Qe.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
+      i.$.clear();
+      i.Qe.clear();
     }
   });
-  return () => read(queue.u) ? void 0 : read(tree);
-}
-function createCollectionBoundary(type, fn, fallback) {
-  const owner = createOwner();
-  const queue = new CollectionQueue(type);
-  const tree = createBoundChildren(owner, fn, queue, type);
-  const decision = computed(() => {
-    if (!read(queue.u)) {
-      const resolved = read(tree);
-      if (!untrack(() => read(queue.u)))
-        queue.qa = true;
-      return resolved;
-    }
-    return fallback(queue);
+  return () => (read(i.He) ? undefined : read(r));
+}
+function createCollectionBoundary(e, t, n) {
+  const i = createOwner();
+  const r = new CollectionQueue(e);
+  const s = createBoundChildren(i, t, r, e);
+  const o = computed(() => {
+    if (!read(r.He)) {
+      const e = read(s);
+      if (!untrack(() => read(r.He))) r.Le = true;
+      return e;
+    }
+    return n(r);
   });
-  return read.bind(null, decision);
-}
-function createLoadBoundary(fn, fallback) {
-  return createCollectionBoundary(1 /* Pending */, fn, () => fallback());
-}
-function createErrorBoundary(fn, fallback) {
-  return createCollectionBoundary(2 /* Error */, fn, (queue) => {
-    let node = queue.a.values().next().value;
-    return fallback(node.C, () => {
-      for (let node2 of queue.a) {
-        recompute(node2, true);
-      }
+  return read.bind(null, o);
+}
+function createLoadBoundary(e, t) {
+  return createCollectionBoundary(STATUS_PENDING, e, () => t());
+}
+function collectErrorSources(e, t) {
+  let n = true;
+  let i = e.D;
+  while (i !== null) {
+    const e = i.V;
+    if (e.D && e.J & STATUS_ERROR) {
+      n = false;
+      collectErrorSources(e, t);
+    }
+    i = i.P;
+  }
+  n && t.push(e);
+}
+function createErrorBoundary(e, t) {
+  return createCollectionBoundary(STATUS_ERROR, e, e => {
+    let n = e.we.values().next().value;
+    return t(n.Y, () => {
+      const t = [];
+      for (const n of e.we) collectErrorSources(n, t);
+      for (const e of t) recompute(e);
+      schedule();
     });
   });
 }
-function flatten(children, options) {
-  if (typeof children === "function" && !children.length) {
-    if (options?.doNotUnwrap)
-      return children;
+function flatten(e, t) {
+  if (typeof e === "function" && !e.length) {
+    if (t?.doNotUnwrap) return e;
     do {
-      children = children();
-    } while (typeof children === "function" && !children.length);
+      e = e();
+    } while (typeof e === "function" && !e.length);
   }
-  if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
-    return;
-  if (Array.isArray(children)) {
-    let results = [];
-    if (flattenArray(children, results, options)) {
+  if (t?.skipNonRendered && (e == null || e === true || e === false || e === "")) return;
+  if (Array.isArray(e)) {
+    let n = [];
+    if (flattenArray(e, n, t)) {
       return () => {
-        let nested = [];
-        flattenArray(results, nested, { ...options, doNotUnwrap: false });
-        return nested;
+        let e = [];
+        flattenArray(n, e, { ...t, doNotUnwrap: false });
+        return e;
       };
     }
-    return results;
+    return n;
   }
-  return children;
+  return e;
 }
-function flattenArray(children, results = [], options) {
-  let notReady = null;
-  let needsUnwrap = false;
-  for (let i = 0; i < children.length; i++) {
+function flattenArray(e, t = [], n) {
+  let i = null;
+  let r = false;
+  for (let s = 0; s < e.length; s++) {
     try {
-      let child = children[i];
-      if (typeof child === "function" && !child.length) {
-        if (options?.doNotUnwrap) {
-          results.push(child);
-          needsUnwrap = true;
+      let i = e[s];
+      if (typeof i === "function" && !i.length) {
+        if (n?.doNotUnwrap) {
+          t.push(i);
+          r = true;
           continue;
         }
         do {
-          child = child();
-        } while (typeof child === "function" && !child.length);
+          i = i();
+        } while (typeof i === "function" && !i.length);
       }
-      if (Array.isArray(child)) {
-        needsUnwrap = flattenArray(child, results, options);
-      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
-      } else
-        results.push(child);
+      if (Array.isArray(i)) {
+        r = flattenArray(i, t, n);
+      } else if (n?.skipNonRendered && (i == null || i === true || i === false || i === "")) {
+      } else t.push(i);
     } catch (e) {
-      if (!(e instanceof NotReadyError))
-        throw e;
-      notReady = e;
-    }
-  }
-  if (notReady)
-    throw notReady;
-  return needsUnwrap;
-}
-
-export { $PROXY, $TARGET, $TRACK, ContextNotFoundError, NoOwnerError, NotReadyError, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createLoadBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getContext, getNextChildId, getObserver, getOwner, isEqual, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, repeat, resolve, runWithOwner, setContext, snapshot, untrack };
+      if (!(e instanceof NotReadyError)) throw e;
+      i = e;
+    }
+  }
+  if (i) throw i;
+  return r;
+}
+export {
+  $PROXY,
+  $TARGET,
+  $TRACK,
+  ContextNotFoundError,
+  NoOwnerError,
+  NotReadyError,
+  SUPPORTS_PROXY,
+  createAsync,
+  createBoundary,
+  createContext,
+  createEffect,
+  createErrorBoundary,
+  createLoadBoundary,
+  createMemo,
+  createOptimistic,
+  createOptimisticStore,
+  createProjection,
+  createReaction,
+  createRenderEffect,
+  createRoot,
+  createSignal,
+  createStore,
+  createTrackedEffect,
+  deep,
+  flatten,
+  flush,
+  getContext,
+  getNextChildId,
+  getObserver,
+  getOwner,
+  isEqual,
+  isPending,
+  isWrappable,
+  mapArray,
+  merge,
+  omit,
+  onCleanup,
+  onSettled,
+  pending,
+  reconcile,
+  repeat,
+  resolve,
+  runWithOwner,
+  setContext,
+  snapshot,
+  untrack
+};