@solidjs/signals 0.8.2 → 0.8.4

package/dist/node.cjs

@@ -1,2214 +1,2016 @@
-'use strict';
-
-// src/core/error.ts
-var NotReadyError = class extends Error {
-  constructor(cause) {
+"use strict";
+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) {
-  var _a, _b, _c;
-  const parentHeight = (((_a = n.w) == null ? void 0 : _a._) ? (_b = n.w.$) == null ? void 0 : _b.c : (_c = n.w) == null ? void 0 : _c.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 e = 0;
+const t = 1 << 0;
+const n = 1 << 1;
+const r = 1 << 2;
+const i = 1 << 3;
+const s = 1 << 4;
+const o = 1 << 5;
+const u = 1 << 6;
+const l = 0;
+const f = 1 << 0;
+const c = 1 << 1;
+const a = 1 << 2;
+const d = 1;
+const h = 2;
+const p = {};
+const y = typeof Proxy === "function";
+const g = {};
+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 r = e.o;
+  const i = t.l[r];
+  if (i === undefined) t.l[r] = e;
+  else {
+    const t = i.h;
+    t.p = e;
+    e.h = t;
+    i.h = e;
+  }
+  if (r > t._) t._ = r;
+}
+function insertIntoHeap(e, o) {
+  let u = e.S;
+  if (u & (i | r)) return;
+  if (u & t) {
+    e.S = (u & -4) | n | i;
+  } else e.S = u | i;
+  if (!(u & s)) actualInsertIntoHeap(e, o);
+}
+function insertIntoHeapHeight(e, t) {
+  let n = e.S;
+  if (n & (i | r | s)) return;
+  e.S = n | s;
+  actualInsertIntoHeap(e, t);
+}
+function deleteFromHeap(e, t) {
+  const n = e.S;
+  if (!(n & (i | s))) return;
+  e.S = n & -25;
+  const r = e.o;
+  if (e.h === e) t.l[r] = undefined;
+  else {
+    const n = e.p;
+    const i = t.l[r];
+    const s = n ?? i;
+    if (e === i) t.l[r] = n;
+    else e.h.p = n;
+    s.h = e.h;
+  }
+  e.h = e;
+  e.p = undefined;
+}
+function markHeap(e) {
+  if (e.m) return;
+  e.m = true;
+  for (let t = 0; t <= e._; t++) {
+    for (let n = e.l[t]; n !== undefined; n = n.p) {
+      if (n.S & i) markNode(n);
+    }
+  }
+}
+function markNode(e, r = n) {
+  const i = e.S;
+  if ((i & (t | n)) >= r) return;
+  e.S = (i & -4) | r;
+  for (let n = e.O; n !== null; n = n.C) {
+    markNode(n.N, t);
+  }
+  if (e.k !== null) {
+    for (let n = e.k; n !== null; n = n.j) {
+      for (let e = n.O; e !== null; e = e.C) {
+        markNode(e.N, t);
       }
     }
   }
 }
-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.m = false;
+  for (e.A = 0; e.A <= e._; e.A++) {
+    let n = e.l[e.A];
+    while (n !== undefined) {
+      if (n.S & i) t(n);
+      else adjustHeight(n, e);
+      n = e.l[e.A];
     }
   }
-  heap.L = 0;
+  e._ = 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.W; t; t = t.P) {
+    const e = t.H;
+    const r = e.I || e;
+    if (r.F && r.o >= n) n = r.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.C) {
+      insertIntoHeapHeight(n.N, t);
     }
   }
 }
-
-// src/core/scheduler.ts
-var clock = 0;
-var activeTransition = null;
-var unobserved = [];
-var transitions = /* @__PURE__ */ new Set();
-var scheduled = false;
+const w = new Set();
+const _ = { l: new Array(2e3).fill(undefined), m: false, A: 0, _: 0 };
+const S = { l: new Array(2e3).fill(undefined), m: false, A: 0, _: 0 };
+let b = 0;
+let m = null;
+let x = false;
 function schedule() {
-  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 = [];
-  created = clock;
-  addChild(child) {
-    this.l.push(child);
-    child.w = this;
-  }
-  removeChild(child) {
-    const index = this.l.indexOf(child);
-    if (index >= 0) {
-      this.l.splice(index, 1);
-      child.w = null;
-    }
-  }
-  notify(node, mask, flags) {
-    if (this.w)
-      return this.w.notify(node, mask, flags);
+  if (x) return;
+  x = true;
+  if (!O.R) queueMicrotask(flush);
+}
+class Queue {
+  i = null;
+  V = [[], []];
+  q = [];
+  created = b;
+  addChild(e) {
+    this.q.push(e);
+    e.i = this;
+  }
+  removeChild(e) {
+    const t = this.q.indexOf(e);
+    if (t >= 0) {
+      this.q.splice(t, 1);
+      e.i = null;
+    }
+  }
+  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.V[e - 1].length) {
+      const t = this.V[e - 1];
+      this.V[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.q.length; t++) {
+      this.q[t].run(e);
     }
   }
-  enqueue(type, fn) {
-    if (type)
-      this.k[type - 1].push(fn);
+  enqueue(e, t) {
+    if (e) this.V[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.V[0].push(...this.V[0]);
+    e.V[1].push(...this.V[1]);
+    this.V = [[], []];
+    for (let t = 0; t < this.q.length; t++) {
+      let n = this.q[t];
+      let r = e.q[t];
+      if (!r) {
+        r = { V: [[], []], q: [] };
+        e.q[t] = r;
       }
-      child.stashQueues(childStub);
+      n.stashQueues(r);
     }
   }
-  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.V[0].push(...e.V[0]);
+    this.V[1].push(...e.V[1]);
+    for (let t = 0; t < e.q.length; t++) {
+      const n = e.q[t];
+      let r = this.q[t];
+      if (r) r.restoreQueues(n);
     }
   }
-};
-var GlobalQueue = class _GlobalQueue extends Queue {
-  ca = false;
-  h = [];
-  static S;
-  static ka;
+}
+class GlobalQueue extends Queue {
+  R = false;
+  M = [];
+  static D;
+  static B;
   flush() {
-    if (this.ca)
-      return;
-    this.ca = true;
+    if (this.R) return;
+    this.R = true;
     try {
-      runHeap(dirtyQueue, _GlobalQueue.S);
-      if (activeTransition) {
-        if (!transitionComplete(activeTransition)) {
-          runHeap(zombieQueue, _GlobalQueue.S);
-          globalQueue.h = [];
-          globalQueue.stashQueues(activeTransition.queueStash);
-          clock++;
-          scheduled = false;
-          runPending(activeTransition.pendingNodes, true);
-          activeTransition = null;
+      runHeap(_, GlobalQueue.D);
+      if (m) {
+        if (!transitionComplete(m)) {
+          runHeap(S, GlobalQueue.D);
+          this.M = [];
+          this.stashQueues(m.queueStash);
+          b++;
+          x = false;
+          runPending(m.pendingNodes, true);
+          m = null;
           return;
         }
-        globalQueue.h.push(...activeTransition.pendingNodes);
-        globalQueue.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;
+        this.M.push(...m.pendingNodes);
+        this.restoreQueues(m.queueStash);
+        w.delete(m);
+        m = null;
+        if (runPending(this.M, false)) runHeap(_, GlobalQueue.D);
+      } else if (w.size) runHeap(S, GlobalQueue.D);
+      for (let e = 0; e < this.M.length; e++) {
+        const t = this.M[e];
+        if (t.K !== p) {
+          t.G = t.K;
+          t.K = p;
+          if (t.T) t.U = true;
         }
-        if (n.ha)
-          _GlobalQueue.ka(n, false, true);
+        if (t.F) GlobalQueue.B(t, false, true);
       }
-      globalQueue.h.length = 0;
-      clock++;
-      scheduled = false;
-      this.run(1 /* Render */);
-      this.run(2 /* User */);
+      this.M.length = 0;
+      b++;
+      x = false;
+      this.run(d);
+      this.run(h);
     } finally {
-      this.ca = false;
-      unobserved.length && notifyUnobserved();
+      this.R = 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 & f) {
+      if (n & f) {
+        if (m && !m.asyncNodes.includes(e.L.cause)) m.asyncNodes.push(e.L.cause);
       }
       return true;
     }
     return false;
   }
-  initTransition(node) {
-    if (activeTransition && activeTransition.time === clock)
-      return;
-    if (!activeTransition) {
-      activeTransition = node.T ?? {
-        time: clock,
-        pendingNodes: [],
-        asyncNodes: [],
-        queueStash: { k: [[], []], l: [] }
-      };
+  initTransition(e) {
+    if (m && m.time === b) return;
+    if (!m) {
+      m = e.J ?? { time: b, pendingNodes: [], asyncNodes: [], queueStash: { V: [[], []], q: [] } };
     }
-    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);
+    w.add(m);
+    m.time = b;
+    for (let e = 0; e < this.M.length; e++) {
+      const t = this.M[e];
+      t.J = m;
+      m.pendingNodes.push(t);
     }
-    globalQueue.h = activeTransition.pendingNodes;
+    this.M = m.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 r = e.slice();
+  for (let e = 0; e < r.length; e++) {
+    const i = r[e];
+    i.J = m;
+    if (i.X) {
+      i.X.Y(t);
+      n = true;
+    }
+    if (i.Z && i.Z.K !== p) {
+      i.Z.Y(i.Z.K);
+      i.Z.K = p;
+      n = true;
     }
   }
-  return needsReset;
+  return n;
 }
-var globalQueue = new GlobalQueue();
+const O = new GlobalQueue();
 function flush() {
-  while (scheduled) {
-    globalQueue.flush();
+  while (x) {
+    O.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].$ & f) {
+      t = false;
       break;
     }
   }
-  return done;
-}
-function notifyUnobserved() {
-  var _a, _b;
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source.s)
-      (_b = (_a = unobserved[i]).sa) == null ? void 0 : _b.call(_a);
-  }
-  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) {
-  var _a;
-  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 = m;
+  m = e.J;
+  t(e);
+  m = n;
+}
+GlobalQueue.D = recompute;
+GlobalQueue.B = disposeChildren;
+let C = false;
+let v = false;
+let N = false;
+let k = null;
+let E = null;
+function notifySubs(e) {
+  for (let t = e.O; t !== null; t = t.C) {
+    const e = t.N.S & o ? S : _;
+    if (e.A > t.N.o) e.A = t.N.o;
+    insertIntoHeap(t.N, e);
+  }
+}
+function recompute(t, n = false) {
+  deleteFromHeap(t, t.S & o ? S : _);
+  if (t.K !== p || t.ee || t.te) disposeChildren(t);
   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);
-  tracking = true;
+    markDisposal(t);
+    O.M.push(t);
+    t.te = t.ne;
+    t.ee = t.re;
+    t.ne = null;
+    t.re = null;
+  }
+  const i = E;
+  E = t;
+  t.ie = null;
+  t.S = r;
+  t.se = b;
+  let s = t.K === p ? t.G : t.K;
+  let u = t.o;
+  let d = t.$;
+  let h = t.L;
+  let y = C;
+  setStatusFlags(t, l | (d & a));
+  C = true;
   try {
-    value = el.ha(value);
+    s = t.F(s);
+    t.$ &= ~a;
   } 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);
-    }
+      if (e.cause !== t) link(e.cause, t);
+      setStatusFlags(t, (d & ~c) | f, e);
+    } else setStatusFlags(t, c, e);
   } finally {
-    tracking = prevTracking;
+    C = y;
   }
-  el.b = 0 /* None */;
-  context = oldcontext;
-  const depsTail = el.I;
-  let toRemove = depsTail !== null ? depsTail.F : el.x;
-  if (toRemove !== null) {
+  t.S = e;
+  E = i;
+  const g = t.ie;
+  let w = g !== null ? g.P : t.W;
+  if (w !== 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;
-  (_a = el.la) == null ? void 0 : _a.call(el, statusFlagsChanged, prevStatusFlags);
-  if (valueChanged || statusFlagsChanged) {
-    if (valueChanged) {
-      if (create || el.ia || el.K)
-        el.g = value;
+      w = unlinkSubs(w);
+    } while (w !== null);
+    if (g !== null) g.P = null;
+    else t.W = null;
+  }
+  const x = !t.oe || !t.oe(t.K === p || t.ue ? t.G : t.K, s);
+  const v = t.$ !== d || t.L !== h;
+  t.le?.(v, d);
+  if (x || v) {
+    if (x) {
+      if (n || t.ue || (t.T && t.J != m)) t.G = s;
       else {
-        if (el.e === NOT_PENDING)
-          globalQueue.h.push(el);
-        el.e = value;
+        if (t.K === p) O.M.push(t);
+        t.K = s;
       }
-      if (el.D)
-        el.D.da(value);
+      if (t.Z) t.Z.Y(s);
     }
-    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 e = t.O; e !== null; e = e.C) {
+      const n = e.N.S & o ? S : _;
+      if (e.N.o < t.o && n.A > e.N.o) n.A = e.N.o;
+      insertIntoHeap(e.N, 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 (t.o != u) {
+    for (let e = t.O; e !== null; e = e.C) {
+      insertIntoHeapHeight(e.N, e.N.S & o ? S : _);
     }
   }
+  if (t.T && t.J && m !== t.J) runInTransition(t, 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(r) {
+  if (r.S & t) {
+    for (let e = r.W; e; e = e.P) {
+      const t = e.H;
+      const i = t.I || t;
+      if (i.F) {
+        updateIfNecessary(i);
       }
-      if (el.b & 2 /* Dirty */) {
+      if (r.S & n) {
         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 (r.S & n) {
+    recompute(r);
   }
-  return nextDep;
+  r.S = e;
 }
-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.H;
+  const n = e.P;
+  const r = e.C;
+  const i = e.fe;
+  if (r !== null) r.fe = i;
+  else t.ce = i;
+  if (i !== null) i.C = r;
+  else {
+    t.O = r;
+    if (r === null) {
+      t.ae?.();
+      t.F && unobserved(t);
+    }
+  }
+  return n;
+}
+function unobserved(e) {
+  deleteFromHeap(e, e.S & o ? S : _);
+  let t = e.W;
+  while (t !== null) {
+    t = unlinkSubs(t);
+  }
+  e.W = null;
+  runDisposal(e);
+}
+function link(e, t) {
+  const n = t.ie;
+  if (n !== null && n.H === e) return;
+  let i = null;
+  const s = t.S & r;
+  if (s) {
+    i = n !== null ? n.P : t.W;
+    if (i !== null && i.H === e) {
+      t.ie = 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 o = e.ce;
+  if (o !== null && o.N === t && (!s || isValidLink(o, t))) return;
+  const u = (t.ie = e.ce = { H: e, N: t, P: i, fe: o, C: null });
+  if (n !== null) n.P = u;
+  else t.W = u;
+  if (o !== null) o.C = u;
+  else e.O = u;
 }
-function isValidLink(checkLink, sub) {
-  const depsTail = sub.I;
-  if (depsTail !== null) {
-    let link2 = sub.x;
+function isValidLink(e, t) {
+  const n = t.ie;
+  if (n !== null) {
+    let r = t.W;
     do {
-      if (link2 === checkLink) {
-        return true;
-      }
-      if (link2 === depsTail) {
-        break;
-      }
-      link2 = link2.F;
-    } while (link2 !== null);
+      if (r === e) return true;
+      if (r === n) break;
+      r = r.P;
+    } while (r !== 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.$ = t;
+  e.L = n;
+}
+function markDisposal(e) {
+  let t = e.re;
+  while (t) {
+    t.S |= o;
+    if (t.S & i) {
+      deleteFromHeap(t, _);
+      insertIntoHeap(t, S);
+    }
+    markDisposal(t);
+    t = t.de;
+  }
+}
+function dispose(e) {
+  let t = e.W || null;
+  do {
+    t = unlinkSubs(t);
+  } while (t !== null);
+  e.W = null;
+  e.ie = null;
+  disposeChildren(e, true);
+}
+function disposeChildren(e, t = false, n) {
+  if (e.S & u) return;
+  if (t) e.S = u;
+  let r = n ? e.ee : e.re;
+  while (r) {
+    const e = r.de;
+    if (r.W) {
+      const e = r;
+      deleteFromHeap(e, e.S & o ? S : _);
+      let t = e.W;
       do {
-        toRemove = unlinkSubs(toRemove);
-      } while (toRemove !== null);
-      n.x = null;
-      n.I = null;
+        t = unlinkSubs(t);
+      } while (t !== null);
+      e.W = null;
+      e.ie = null;
     }
-    disposeChildren(child, true);
-    child = nextChild;
+    disposeChildren(r, true);
+    r = e;
   }
-  if (zombie) {
-    node.U = null;
+  if (n) {
+    e.ee = null;
   } else {
-    node.q = null;
-    node.M = null;
+    e.re = null;
+    e.de = 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 == null ? void 0 : options.id) ?? ((context == null ? void 0 : context.id) != null ? getNextChildId(context) : void 0);
-  obj.ea = (options == null ? void 0 : options.equals) != null ? options.equals : isEqual;
-  obj.ya = !!(options == null ? void 0 : options.pureWrite);
-  obj.sa = options == null ? void 0 : options.unobserved;
-  if (options == null ? void 0 : 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.he++);
+  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 == null ? void 0 : context._) ? context.$ : 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;
+function formatId(e, t) {
+  const n = t.toString(36),
+    r = n.length - 1;
+  return e + (r ? String.fromCharCode(64 + r) : "") + n;
+}
+function computed(t, n, r) {
+  const i = {
+    id: r?.id ?? (E?.id != null ? getNextChildId(E) : undefined),
+    oe: r?.equals != null ? r.equals : isEqual,
+    pe: !!r?.pureWrite,
+    ae: r?.unobserved,
+    ne: null,
+    ye: E?.ye ?? O,
+    ge: E?.ge ?? g,
+    he: 0,
+    F: t,
+    G: n,
+    o: 0,
+    k: null,
+    p: undefined,
+    h: null,
+    W: null,
+    ie: null,
+    O: null,
+    ce: null,
+    i: E,
+    de: null,
+    re: null,
+    S: e,
+    $: a,
+    se: b,
+    K: p,
+    te: null,
+    ee: null
+  };
+  if (r?.we) Object.assign(i, r.we);
+  i.h = i;
+  const s = E?.t ? E.u : E;
+  if (E) {
+    const e = E.re;
+    if (e === null) {
+      E.re = 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.de = e;
+      E.re = i;
+    }
+  }
+  if (s) i.o = s.o + 1;
+  recompute(i, true);
+  return i;
+}
+function asyncComputed(e, t, n) {
+  let r = undefined;
+  let i = false;
+  const fn = t => {
+    const n = e(t, i);
+    i = false;
+    r = n;
+    const o = n instanceof Promise;
+    const u = n[Symbol.asyncIterator];
+    if (!o && !u) {
+      return n;
+    }
+    if (o) {
+      n.then(e => {
+        if (r !== n) return;
+        O.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 (r !== n) return;
+        O.initTransition(s);
+        setStatusFlags(s, c, e);
+        s.se = b;
+        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 (r !== n) return;
+            O.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 (r !== n) return;
+          O.initTransition(s);
+          setStatusFlags(s, c, e);
+          s.se = b;
+          notifySubs(s);
           schedule();
           flush();
         }
       })();
     }
-    globalQueue.initTransition(context);
-    throw new NotReadyError(context);
+    O.initTransition(E);
+    throw new NotReadyError(E);
   };
-  const self = computed(fn, initialValue, options);
-  self.ta = () => {
-    refreshing = true;
-    recompute(self);
+  const s = computed(fn, t, n);
+  s._e = () => {
+    i = 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 r = {
+    id: t?.id ?? (E?.id != null ? getNextChildId(E) : undefined),
+    oe: t?.equals != null ? t.equals : isEqual,
+    pe: !!t?.pureWrite,
+    ae: t?.unobserved,
+    G: e,
+    O: null,
+    ce: null,
+    $: l,
+    se: b,
+    I: n,
+    j: n?.k || null,
+    K: p
+  };
+  n && (n.k = r);
+  return r;
 }
-function isEqual(a, b) {
-  return a === b;
+function isEqual(e, t) {
+  return e === t;
 }
-function untrack(fn) {
-  if (!tracking)
-    return fn();
-  tracking = false;
+function untrack(e) {
+  if (!C) return e();
+  C = false;
   try {
-    return fn();
+    return e();
   } finally {
-    tracking = true;
-  }
-}
-function read(el) {
-  let c = context;
-  if (c == null ? void 0 : 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);
+    C = true;
+  }
+}
+function read(e) {
+  let t = E;
+  if (t?.t) t = t.u;
+  if (t && C && !k && !N) {
+    link(e, t);
+    const n = e.I || e;
+    if (n.F) {
+      const r = e.S & o;
+      if (n.o >= (r ? S.A : _.A)) {
+        markNode(t);
+        markHeap(r ? S : _);
+        updateIfNecessary(n);
       }
-      const height = owner.c;
-      if (height >= c.c && el.w !== c) {
-        c.c = height + 1;
+      const i = n.o;
+      if (i >= t.o && e.i !== t) {
+        t.o = i + 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 (k) {
+    if (!e.X) {
+      e.X = signal(false);
+      e.X.ue = true;
+      e.X.Y = t => setSignal(e.X, t);
     }
-    const prev = pendingCheck;
-    pendingCheck = null;
-    read(el.H);
-    pendingCheck = prev;
-    prev.g = pendingResult || prev.g;
+    const t = k;
+    k = null;
+    t.G = read(e.X) || t.G;
+    k = 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 (N) {
+    if (!e.Z) {
+      e.Z = signal(e.G);
+      e.Z.ue = true;
+      e.Z.Y = t => setSignal(e.Z, t);
     }
-    pendingValueCheck = false;
+    N = false;
     try {
-      return read(el.D);
+      return read(e.Z);
     } finally {
-      pendingValueCheck = true;
+      N = 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.$ & f) {
+    if ((t && !v) || e.$ & a) throw e.L;
+    else if (t && v && !k) {
+      setStatusFlags(t, t.$ | 1, e.L);
     }
   }
-  if (el.f & 2 /* Error */) {
-    if (el.J < clock) {
-      recompute(el, true);
-      return read(el);
+  if (e.$ & c) {
+    if (e.se < b) {
+      recompute(e, true);
+      return read(e);
     } else {
-      throw el.C;
+      throw e.L;
     }
   }
-  return !c || el.e === NOT_PENDING || stale && !pendingCheck && el.T && activeTransition !== el.T ? el.g : el.e;
+  return !t || e.ue || e.K === p || (v && !k && e.J && m !== e.J) ? e.G : e.K;
 }
-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.K === p ? e.G : e.K);
   }
-  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.K === p || e.ue ? e.G : e.K, t);
+  if (!n && !e.$) return t;
+  if (n) {
+    if (e.ue) e.G = t;
     else {
-      if (el.e === NOT_PENDING)
-        globalQueue.h.push(el);
-      el.e = v;
+      if (e.K === p) O.M.push(e);
+      e.K = t;
     }
-    if (el.D)
-      el.D.da(v);
+    if (e.Z) e.Z.K = t;
   }
-  clearStatusFlags(el);
-  el.J = clock;
-  notifySubs(el);
+  setStatusFlags(e, l);
+  e.se = b;
+  notifySubs(e);
   schedule();
-  return v;
+  return t;
 }
 function getObserver() {
-  return tracking ? context : null;
+  return C ? E : null;
 }
 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);
+  return E;
+}
+function onCleanup(e) {
+  if (!E) return e;
+  const t = E;
+  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 == null ? void 0 : parent._) ? parent.$ : parent,
-    q: null,
-    M: null,
-    t: null,
-    id: (options == null ? void 0 : options.id) ?? ((parent == null ? void 0 : parent.id) != null ? getNextChildId(parent) : void 0),
-    i: (parent == null ? void 0 : parent.i) ?? globalQueue,
-    E: (parent == null ? void 0 : 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 = E;
+  const n = {
+    t: true,
+    u: t?.t ? t.u : t,
+    re: null,
+    de: null,
+    ne: null,
+    id: e?.id ?? (t?.id != null ? getNextChildId(t) : undefined),
+    ye: t?.ye ?? O,
+    ge: t?.ge || g,
+    he: 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.re;
+    if (e === null) {
+      t.re = n;
     } else {
-      owner.M = lastChild;
-      parent.q = owner;
+      n.de = e;
+      t.re = 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 = E;
+  E = e;
   try {
-    return fn();
+    return t();
   } finally {
-    context = oldContext;
+    E = n;
   }
 }
-function staleValues(fn, set = true) {
-  const prevStale = stale;
-  stale = set;
+function staleValues(e, t = true) {
+  const n = v;
+  v = t;
   try {
-    return fn();
+    return e();
   } finally {
-    stale = prevStale;
+    v = n;
   }
 }
-function pending(fn) {
-  const prevLatest = pendingValueCheck;
-  pendingValueCheck = true;
+function pending(e) {
+  const t = N;
+  N = true;
   try {
-    return staleValues(fn, false);
+    return staleValues(e, false);
   } finally {
-    pendingValueCheck = prevLatest;
+    N = t;
   }
 }
-function isPending(fn, loadingValue) {
-  const current = pendingCheck;
-  pendingCheck = { g: false };
+function isPending(e, t) {
+  const n = k;
+  k = { G: 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 k.G;
+  } catch (e) {
+    if (!(e instanceof NotReadyError)) return false;
+    if (t !== undefined) return t;
+    throw e;
   } finally {
-    pendingCheck = current;
+    k = 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.ge[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 == null ? void 0 : owner.E[context2.id]);
-}
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-
-// src/core/effect.ts
-function effect(compute, effect2, error, initialValue, options) {
-  var _a;
-  let initialized = false;
-  const node = computed(compute, initialValue, {
-    ...options,
-    ja: {
-      fa: true,
-      oa: initialValue,
-      ua: effect2,
-      pa: error,
-      N: void 0,
-      i: ((_a = getOwner()) == null ? void 0 : _a.i) ?? globalQueue,
-      K: (options == null ? void 0 : 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.ge = { ...n.ge, [e.id]: isUndefined(t) ? e.defaultValue : t };
+}
+function hasContext(e, t) {
+  return !isUndefined(t?.ge[e.id]);
+}
+function isUndefined(e) {
+  return typeof e === "undefined";
+}
+function effect(e, t, n, r, i) {
+  let s = false;
+  const o = computed(e, r, {
+    ...i,
+    we: {
+      U: true,
+      Se: r,
+      be: t,
+      me: n,
+      xe: undefined,
+      T: i?.render ? d : h,
+      le(e, t) {
+        if (s) {
+          const n = this.$ && this.$ === t && e;
+          this.U = !(this.$ & c) && !(this.$ & f & ~t) && !n;
+          if (this.U) this.ye.enqueue(this.T, 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.$ & c) {
+          let e = this.L;
+          this.ye.notify(this, f, 0);
+          if (this.T === h) {
             try {
-              return this.pa ? this.pa(error2, () => {
-                var _a2;
-                (_a2 = this.N) == null ? void 0 : _a2.call(this);
-                this.N = void 0;
-              }) : console.error(error2);
-            } catch (e) {
-              error2 = e;
+              return this.me
+                ? this.me(e, () => {
+                    this.xe?.();
+                    this.xe = 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.ye.notify(this, c, c)) throw e;
+        } else if (this.T === d) {
+          this.ye.notify(this, f | c, this.$);
         }
       }
     }
   });
-  initialized = true;
-  if (node.K === 1 /* Render */)
-    node.ha = (p) => staleValues(() => compute(p));
-  !(options == null ? void 0 : options.defer) && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.K === 2 /* User */ ? node.i.enqueue(node.K, runEffect.bind(node)) : runEffect.call(node));
-  onCleanup(() => {
-    var _a2;
-    return (_a2 = node.N) == null ? void 0 : _a2.call(node);
-  });
+  s = true;
+  if (o.T === d) o.F = t => staleValues(() => e(t));
+  !i?.defer &&
+    !(o.$ & (c | f)) &&
+    (o.T === h ? o.ye.enqueue(o.T, runEffect.bind(o)) : runEffect.call(o));
+  onCleanup(() => o.xe?.());
 }
 function runEffect() {
-  var _a;
-  if (!this.fa || this.b & 64 /* Disposed */)
-    return;
-  (_a = this.N) == null ? void 0 : _a.call(this);
-  this.N = void 0;
+  if (!this.U || this.S & u) return;
+  this.xe?.();
+  this.xe = undefined;
   try {
-    this.N = this.ua(this.g, this.oa);
-  } catch (error) {
-    if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
-      throw error;
+    this.xe = this.be(this.G, this.Se);
+  } catch (e) {
+    if (!this.ye.notify(this, c, c)) 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 == null ? void 0 : 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.Se = this.G;
+    this.U = false;
+  }
+}
+function createSignal(e, t, n) {
+  if (typeof e === "function") {
+    const r = computed(e, t, n);
+    return [read.bind(null, r), setSignal.bind(null, r)];
+  }
+  const r = getOwner();
+  const i = r?.id != null;
+  const s = signal(e, i ? { id: getNextChildId(r), ...t } : t);
+  return [read.bind(null, s), setSignal.bind(null, s)];
+}
+function createMemo(e, t, n) {
+  let r = computed(e, t, n);
+  return read.bind(null, r);
+}
+function createAsync(e, t, n) {
+  const r = asyncComputed(e, t, n);
+  const i = read.bind(null, r);
+  i.refresh = r._e;
+  return i;
+}
+function createEffect(e, t, n, r) {
+  void effect(e, t.effect || t, t.error, n, r);
+}
+function createRenderEffect(e, t, n, r) {
+  void effect(e, t, undefined, n, { render: true, ...r });
+}
+function createTrackedEffect(e, t) {}
+function createReaction(e, t) {
+  let n = undefined;
+  onCleanup(() => n?.());
+  const r = getOwner();
+  return i => {
+    runWithOwner(r, () => {
+      effect(
+        () => (i(), 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(r => {
       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();
+        r();
       });
     });
   });
 }
-function createOptimistic(first, second, third) {
+function createOptimistic(e, t, n) {
   return {};
 }
-function onSettled(callback) {
-}
-
-// src/store/reconcile.ts
-function unwrap(value) {
-  var _a;
-  return ((_a = value == null ? void 0 : value[$TARGET]) == null ? void 0 : _a[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?.());
+  O.enqueue(h, () => {
+    t = e();
+    !n && t?.();
+  });
 }
-function applyState(next, state, keyFn, all) {
-  const target = state == null ? void 0 : 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?.[W]?.[R] ?? e;
+}
+function getOverrideValue(e, t, n, r) {
+  return n && r in n ? read(n[r]) : t && r in t ? t[r] : e[r];
+}
+function getAllKeys(e, t, n) {
+  const r = getKeys(e, t);
+  const i = Object.keys(n);
+  return Array.from(new Set([...r, ...i]));
+}
+function applyState(e, t, n, r) {
+  const i = t?.[W];
+  if (!i) return;
+  const s = i[F];
+  const o = i[Q];
+  let u = i[R];
+  if (e === s && !o) return;
+  (i[M] || B).set(e, i[P]);
+  i[F] = e;
+  i[Q] = 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 f, c, a, d, h, p, y, g;
+      for (
+        a = 0, d = Math.min(l, e.length);
+        a < d && ((p = getOverrideValue(s, o, u, a)) === e[a] || (p && e[a] && n(p) === n(e[a])));
+        a++
+      ) {
+        applyState(e[a], wrap(p, i), n, r);
       }
-      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 w = new Array(e.length),
+        _ = new Map();
+      for (
+        d = l - 1, h = e.length - 1;
+        d >= a &&
+        h >= a &&
+        ((p = getOverrideValue(s, o, u, d)) === e[h] || (p && e[h] && n(p) === n(e[h])));
+        d--, h--
+      ) {
+        w[h] = p;
       }
-      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 (a > h || a > d) {
+        for (c = a; c <= h; c++) {
+          t = true;
+          i[R][c] && setSignal(i[R][c], wrap(e[c], i));
         }
-        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 (; c < e.length; c++) {
+          t = true;
+          const s = wrap(w[c], i);
+          i[R][c] && setSignal(i[R][c], s);
+          applyState(e[c], s, n, r);
         }
-        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 && i[R][j] && setSignal(i[R][j], void 0);
+        l !== e.length && i[R].length && setSignal(i[R].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);
+      y = new Array(h + 1);
+      for (c = h; c >= a; c--) {
+        p = e[c];
+        g = p ? n(p) : p;
+        f = _.get(g);
+        y[c] = f === undefined ? -1 : f;
+        _.set(g, c);
       }
-      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 (f = a; f <= d; f++) {
+        p = getOverrideValue(s, o, u, f);
+        g = p ? n(p) : p;
+        c = _.get(g);
+        if (c !== undefined && c !== -1) {
+          w[c] = p;
+          c = y[c];
+          _.set(g, c);
         }
       }
-      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 (c = a; c < e.length; c++) {
+        if (c in w) {
+          const t = wrap(w[c], i);
+          i[R][c] && setSignal(i[R][c], t);
+          applyState(e[c], t, n, r);
+        } else i[R][c] && setSignal(i[R][c], wrap(e[c], i));
       }
-      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 (a < 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, i), n, r);
       }
     }
-    if (prevLength !== next.length) {
-      changed = true;
-      target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
+    if (l !== e.length) {
+      t = true;
+      i[R].length && setSignal(i[R].length, e.length);
     }
-    changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+    t && i[R][j] && setSignal(i[R][j], 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[j];
+    const l = t || r ? getAllKeys(s, o, e) : Object.keys(u);
+    for (let f = 0, c = l.length; f < c; f++) {
+      const c = l[f];
+      const a = u[c];
+      const d = unwrap(getOverrideValue(s, o, u, c));
+      let h = unwrap(e[c]);
+      if (d === h) continue;
+      if (!d || !isWrappable(d) || (n(d) != null && n(d) !== n(h))) {
+        t && setSignal(t, void 0);
+        a && setSignal(a, isWrappable(h) ? wrap(h, i) : h);
+      } else applyState(h, wrap(d, i), n, r);
+    }
+  }
+  if ((u = i[V])) {
+    const t = Object.keys(u);
+    for (let n = 0, r = t.length; n < r; n++) {
+      const r = t[n];
+      setSignal(u[r], r in e);
+    }
+  }
+}
+function reconcile(e, t, n = false) {
+  return r => {
+    if (r == null) throw new Error("Cannot reconcile null or undefined state");
+    const i = typeof t === "string" ? e => e[t] : t;
+    const s = i(r);
+    if (s !== undefined && i(e) !== i(r))
       throw new Error("Cannot reconcile states with different identity");
-    applyState(value, state, keyFn, all);
+    applyState(e, r, i, 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) => {
-    var _a;
-    if (wrappedMap.has(source))
-      return wrappedMap.get(source);
-    if (((_a = source[$TARGET]) == null ? void 0 : _a[STORE_WRAP]) === wrapProjection)
-      return source;
-    const wrapped = createStoreProxy(source, traps, {
-      [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: wrappedMap
+function createProjectionInternal(e, t = {}, n) {
+  let r;
+  const i = new WeakMap();
+  const wrapProjection = e => {
+    if (i.has(e)) return i.get(e);
+    if (e[W]?.[q] === wrapProjection) return e;
+    const t = createStoreProxy(e, G, {
+      [q]: wrapProjection,
+      [M]: i,
+      [D]() {
+        return r;
+      }
     });
-    wrappedMap.set(source, wrapped);
-    return wrapped;
+    i.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 == null ? void 0 : options.key) || "id", options == null ? void 0 : options.all)(s);
+  const s = wrapProjection(t);
+  r = computed(() => {
+    storeSetter(s, t => {
+      const r = e(t);
+      if (r !== t && r !== undefined) {
+        reconcile(r, 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 == null ? void 0 : 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 == null ? void 0 : 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: r };
+}
+function createProjection(e, t = {}, n) {
+  return createProjectionInternal(e, t, n).store;
+}
+const j = Symbol(0),
+  A = Symbol(0),
+  W = Symbol(0),
+  P = Symbol(0),
+  H = Symbol(0);
+const I = new WeakMap();
+const F = "v",
+  Q = "o",
+  R = "n",
+  V = "h",
+  q = "w",
+  M = "l",
+  D = "f";
+function createStoreProxy(e, t = G, n) {
+  let r;
+  if (Array.isArray(e)) {
+    r = [];
+    r.v = e;
+  } else r = { v: e };
+  n && Object.assign(r, n);
+  return (r[P] = new Proxy(r, t));
+}
+const B = new WeakMap();
+function wrap(e, t) {
+  if (t?.[q]) return t[q](e, t);
+  let n = e[P] || B.get(e);
+  if (!n) B.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, r, i = isEqual) {
+  if (e[t]) return e[t];
+  return (e[t] = signal(
+    n,
+    {
+      equals: i,
+      unobserved() {
+        delete e[t];
+      }
+    },
+    r
+  ));
+}
+function trackSelf(e, t = j) {
+  getObserver() && read(getNode(getNodes(e, R), t, undefined, e[D]?.(), false));
+}
+function getKeys(e, t, n = true) {
+  const r = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
+  if (!t) return r;
+  const i = new Set(r);
+  const s = Reflect.ownKeys(t);
+  for (const e of s) {
+    if (t[e] !== H) i.add(e);
+    else i.delete(e);
+  }
+  return Array.from(i);
+}
+function getPropertyDescriptor(e, t, n) {
+  let r = e;
+  if (t && n in t) {
+    if (r[n] === H) return void 0;
+    if (!(n in r)) r = t;
+  }
+  return Reflect.getOwnPropertyDescriptor(r, n);
+}
+let K = null;
+const G = {
+  get(e, t, n) {
+    if (t === W) return e;
+    if (t === P) return n;
+    if (t === j || t === A) {
+      trackSelf(e, t);
+      return n;
+    }
+    const r = getNodes(e, R);
+    const i = r[t];
+    const s = e[Q] && t in e[Q];
+    const o = !!e[F][W];
+    const u = s ? e[Q] : e[F];
+    if (!i) {
+      const e = Object.getOwnPropertyDescriptor(u, t);
+      if (e && e.get) return e.get.call(n);
+    }
+    if (K?.has(n)) {
+      let n = i && (s || !o) ? (i.K !== p ? i.K : i.G) : u[t];
+      n === H && (n = undefined);
+      if (!isWrappable(n)) return n;
+      const r = wrap(n, e);
+      K.add(r);
+      return r;
+    }
+    let l = i ? (s || !o ? read(r[t]) : (read(r[t]), u[t])) : u[t];
+    l === H && (l = undefined);
+    if (!i) {
+      if (!s && typeof l === "function" && !u.hasOwnProperty(t)) {
+        let t;
+        return !Array.isArray(e[F]) && (t = Object.getPrototypeOf(e[F])) && t !== Object.prototype
+          ? l.bind(u)
+          : l;
       } else if (getObserver()) {
-        return read(getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value));
+        return read(getNode(r, t, isWrappable(l) ? wrap(l, e) : l, e[D]?.()));
       }
     }
-    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 === P || t === j || t === "__proto__") return true;
+    const n = e[Q] && t in e[Q] ? e[Q][t] !== H : t in e[F];
+    getObserver() && read(getNode(getNodes(e, V), t, n, e[D]?.()));
+    return n;
   },
-  set(target, property, rawValue) {
-    const store = target[$PROXY];
-    if (Writing == null ? void 0 : Writing.has(target[$PROXY])) {
+  set(e, t, n) {
+    const r = e[P];
+    if (K?.has(e[P])) {
       untrack(() => {
-        var _a, _b, _c;
-        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 = ((_a = rawValue == null ? void 0 : rawValue[$TARGET]) == null ? void 0 : _a[STORE_VALUE]) ?? rawValue;
-        if (prev === value)
-          return true;
-        const len = ((_b = target[STORE_OVERRIDE]) == null ? void 0 : _b.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 i = e[F];
+        const s = i[t];
+        const o = e[Q] && t in e[Q] ? e[Q][t] : s;
+        const u = n?.[W]?.[F] ?? n;
+        if (o === u) return true;
+        const l = e[Q]?.length || i.length;
+        if (u !== undefined && u === s) delete e[Q][t];
+        else (e[Q] || (e[Q] = Object.create(null)))[t] = u;
+        const f = isWrappable(u);
+        if (isWrappable(o)) {
+          const e = I.get(o);
+          e && (e instanceof Set ? e.delete(r) : I.delete(o));
         }
-        if (recursivelyNotify(store, storeLookup) && wrappable)
-          recursivelyAddParent(value, store);
-        ((_c = target[STORE_HAS]) == null ? void 0 : _c[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(r, B) && f) recursivelyAddParent(u, r);
+        e[V]?.[t] && setSignal(e[V][t], true);
+        const c = getNodes(e, R);
+        c[t] && setSignal(c[t], () => (f ? wrap(u, e) : u));
+        if (Array.isArray(i)) {
+          const e = parseInt(t) + 1;
+          if (e > l) c.length && setSignal(c.length, e);
         }
-        nodes[$TRACK] && setSignal(nodes[$TRACK], void 0);
+        c[j] && setSignal(c[j], undefined);
       });
     }
     return true;
   },
-  deleteProperty(target, property) {
-    var _a;
-    if ((Writing == null ? void 0 : Writing.has(target[$PROXY])) && ((_a = target[STORE_OVERRIDE]) == null ? void 0 : _a[property]) !== $DELETED) {
+  deleteProperty(e, t) {
+    if (K?.has(e[P]) && e[Q]?.[t] !== H) {
       untrack(() => {
-        var _a2;
-        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[Q] && t in e[Q] ? e[Q][t] : e[F][t];
+        if (t in e[F]) {
+          (e[Q] || (e[Q] = Object.create(null)))[t] = H;
+        } else if (e[Q] && t in e[Q]) {
+          delete e[Q][t];
+        } else return true;
+        if (isWrappable(n)) {
+          const t = I.get(n);
+          t && (t instanceof Set ? t.delete(e) : I.delete(n));
         }
-        if ((_a2 = target[STORE_HAS]) == null ? void 0 : _a2[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[V]?.[t]) setSignal(e[V][t], false);
+        const r = getNodes(e, R);
+        r[t] && setSignal(r[t], undefined);
+        r[j] && setSignal(r[j], undefined);
       });
     }
     return true;
   },
-  ownKeys(target) {
-    trackSelf(target);
-    return getKeys(target[STORE_VALUE], target[STORE_OVERRIDE], false);
+  ownKeys(e) {
+    trackSelf(e);
+    return getKeys(e[F], e[Q], 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 === P) return { value: e[P], writable: true, configurable: true };
+    return getPropertyDescriptor(e[F], e[Q], t);
   },
-  getPrototypeOf(target) {
-    return Object.getPrototypeOf(target[STORE_VALUE]);
+  getPrototypeOf(e) {
+    return Object.getPrototypeOf(e[F]);
   }
 };
-function storeSetter(store, fn) {
-  const prevWriting = Writing;
-  Writing = /* @__PURE__ */ new Set();
-  Writing.add(store);
+function storeSetter(e, t) {
+  const n = K;
+  K = new Set();
+  K.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, r = n.length; t < r; 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) {
-  var _a;
-  let target = state[$TARGET] || ((_a = lookup == null ? void 0 : lookup.get(state)) == null ? void 0 : _a[$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 == null ? void 0 : 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 == null ? void 0 : 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);
+    K.clear();
+    K = n;
+  }
+}
+function createStore(e, t, n) {
+  const r = typeof e === "function",
+    i = r ? createProjectionInternal(e, t, n).store : wrap(e);
+  return [i, e => storeSetter(i, e)];
+}
+function recursivelyNotify(e, t) {
+  let n = e[W] || t?.get(e)?.[W];
+  let r = false;
+  if (n) {
+    const e = getNodes(n, R)[A];
+    if (e) {
+      setSignal(e, undefined);
+      r = true;
+    }
+    t = n[M] || t;
+  }
+  const i = I.get(n?.[F] || e);
+  if (!i) return r;
+  if (i instanceof Set) {
+    for (let e of i) r = recursivelyNotify(e, t) || r;
+  } else r = recursivelyNotify(i, t) || r;
+  return r;
+}
+function recursivelyAddParent(e, t) {
+  let n;
+  const r = e[W];
+  if (r) {
+    n = r[Q];
+    e = r[F];
+  }
+  if (t) {
+    let n = I.get(e);
+    if (!n) I.set(e, t);
+    else if (n !== t) {
+      if (!(n instanceof Set)) I.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 r = 0; r < t; r++) {
+      const t = n && r in n ? n[r] : e[r];
+      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 r = 0; r < t.length; r++) {
+      const i = t[r];
+      const s = n && i in n ? n[i] : e[i];
+      isWrappable(s) && recursivelyAddParent(s, e);
     }
   }
 }
-function deep(store) {
-  recursivelyAddParent(store);
-  return store[$DEEP];
+function deep(e) {
+  recursivelyAddParent(e);
+  return e[A];
 }
-
-// src/store/optimistic.ts
-function createOptimisticStore(first, second, options) {
+function createOptimisticStore(e, t, n) {
   return [];
 }
-
-// src/store/utils.ts
-function snapshot(item, map, lookup) {
-  var _a;
-  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] || ((_a = lookup == null ? void 0 : lookup.get(item)) == null ? void 0 : _a[$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]
-    );
-    item = target[STORE_VALUE];
-    lookup = storeLookup;
+function snapshot(e, t, n) {
+  let r, i, s, o, u, l;
+  if (!isWrappable(e)) return e;
+  if (t && t.has(e)) return t.get(e);
+  if (!t) t = new Map();
+  if ((r = e[W] || n?.get(e)?.[W])) {
+    s = r[Q];
+    i = Array.isArray(r[F]);
+    t.set(e, s ? (o = i ? [] : Object.create(Object.getPrototypeOf(r[F]))) : r[F]);
+    e = r[F];
+    n = B;
   } else {
-    isArray = Array.isArray(item);
-    map.set(item, item);
-  }
-  if (isArray) {
-    const len = (override == null ? void 0 : 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;
+    i = Array.isArray(e);
+    t.set(e, e);
+  }
+  if (i) {
+    const r = s?.length || e.length;
+    for (let i = 0; i < r; i++) {
+      l = s && i in s ? s[i] : e[i];
+      if (l === H) continue;
+      if ((u = snapshot(l, t, n)) !== l || o) {
+        if (!o) t.set(e, (o = [...e]));
+        o[i] = 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 r = getKeys(e, s);
+    for (let i = 0, f = r.length; i < f; i++) {
+      let f = r[i];
+      const c = getPropertyDescriptor(e, s, f);
+      if (c.get) continue;
+      l = s && f in s ? s[f] : e[f];
+      if ((u = snapshot(l, t, n)) !== e[f] || o) {
+        if (!o) {
+          o = Object.create(Object.getPrototypeOf(e));
+          Object.assign(o, e);
         }
-        result[prop] = unwrapped;
+        o[f] = 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 T = {
+  get(e, t, n) {
+    if (t === P) return n;
+    return e.get(t);
   },
-  has(_, property) {
-    if (property === $PROXY)
-      return true;
-    return _.has(property);
+  has(e, t) {
+    if (t === P) 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 U = Symbol(0);
+function merge(...e) {
+  if (e.length === 1 && typeof e[0] !== "function") return e[0];
+  let t = false;
+  const n = [];
+  for (let r = 0; r < e.length; r++) {
+    const i = e[r];
+    t = t || (!!i && P in i);
+    const s = !!i && i[U];
+    if (s) n.push(...s);
+    else n.push(typeof i === "function" ? ((t = true), createMemo(i)) : i);
+  }
+  if (y && 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 === U) return n;
+          for (let t = n.length - 1; t >= 0; t--) {
+            const r = resolveSource(n[t]);
+            if (e in r) return r[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
+      T
     );
   }
-  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 r = Object.create(null);
+  let i = 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 (!r[u]) {
+        i = i || e !== s;
+        const n = Object.getOwnPropertyDescriptor(t, u);
+        r[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 (!i) return n[s];
+  const o = {};
+  const u = Object.keys(r);
+  for (let e = u.length - 1; e >= 0; e--) {
+    const t = u[e],
+      n = r[t];
+    if (n.get) Object.defineProperty(o, t, n);
+    else o[t] = n.value;
   }
-  target[$SOURCES] = flattened;
-  return target;
+  o[U] = 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 (y && P 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
+      T
     );
   }
-  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 r = {};
+  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
+        ? (r[t] = n.value)
+        : Object.defineProperty(r, t, n);
     }
   }
-  return result;
+  return r;
 }
-
-// src/map.ts
-function mapArray(list, map, options) {
-  const keyFn = typeof (options == null ? void 0 : options.keyed) === "function" ? options.keyed : void 0;
+function mapArray(e, t, n) {
+  const r = 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 == null ? void 0 : options.keyed) === false ? [] : void 0,
-      o: map.length > 1 ? [] : void 0,
-      X: options == null ? void 0 : options.fallback
+      Oe: createOwner(),
+      Ce: 0,
+      ve: e,
+      Ne: [],
+      ke: t,
+      Ee: [],
+      je: [],
+      Ae: r,
+      We: r || n?.keyed === false ? [] : undefined,
+      Pe: t.length > 1 ? [] : undefined,
+      He: n?.fallback
     })
   );
 }
-var pureOptions = { pureWrite: true };
+const L = { 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.ve() || [],
+    t = e.length;
+  e[j];
+  runWithOwner(this.Oe, () => {
+    let n,
+      r,
+      i = this.We
+        ? () => {
+            this.We[r] = signal(e[r], L);
+            this.Pe && (this.Pe[r] = signal(r, L));
+            return this.ke(
+              read.bind(null, this.We[r]),
+              this.Pe ? read.bind(null, this.Pe[r]) : undefined
+            );
+          }
+        : this.Pe
+          ? () => {
+              const t = e[r];
+              this.Pe[r] = signal(r, L);
+              return this.ke(() => t, read.bind(null, this.Pe[r]));
+            }
+          : () => {
+              const t = e[r];
+              return this.ke(() => t);
+            };
+    if (t === 0) {
+      if (this.Ce !== 0) {
+        this.Oe.dispose(false);
+        this.je = [];
+        this.Ne = [];
+        this.Ee = [];
+        this.Ce = 0;
+        this.We && (this.We = []);
+        this.Pe && (this.Pe = []);
       }
-      if (this.X && !this.d[0]) {
-        this.d[0] = runWithOwner(
-          this.a[0] = createOwner(),
-          this.X
-        );
+      if (this.He && !this.Ee[0]) {
+        this.Ee[0] = runWithOwner((this.je[0] = createOwner()), this.He);
       }
-    } 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.Ce === 0) {
+      if (this.je[0]) this.je[0].dispose();
+      this.Ee = new Array(t);
+      for (r = 0; r < t; r++) {
+        this.Ne[r] = e[r];
+        this.Ee[r] = runWithOwner((this.je[r] = createOwner()), i);
       }
-      this.m = newLen;
+      this.Ce = 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,
+        f,
+        c,
+        a,
+        d = new Array(t),
+        h = new Array(t),
+        p = this.We ? new Array(t) : undefined,
+        y = this.Pe ? new Array(t) : undefined;
+      for (
+        s = 0, o = Math.min(this.Ce, t);
+        s < o && (this.Ne[s] === e[s] || (this.We && compare(this.Ae, this.Ne[s], e[s])));
+        s++
+      ) {
+        if (this.We) setSignal(this.We[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.Ce - 1, u = t - 1;
+        o >= s &&
+        u >= s &&
+        (this.Ne[o] === e[u] || (this.We && compare(this.Ae, this.Ne[o], e[u])));
+        o--, u--
+      ) {
+        d[u] = this.Ee[o];
+        h[u] = this.je[o];
+        p && (p[u] = this.We[o]);
+        y && (y[u] = this.Pe[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);
+      c = new Map();
+      a = new Array(u + 1);
+      for (r = u; r >= s; r--) {
+        l = e[r];
+        f = this.Ae ? this.Ae(l) : l;
+        n = c.get(f);
+        a[r] = n === undefined ? -1 : n;
+        c.set(f, r);
       }
-      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.Ne[n];
+        f = this.Ae ? this.Ae(l) : l;
+        r = c.get(f);
+        if (r !== undefined && r !== -1) {
+          d[r] = this.Ee[n];
+          h[r] = this.je[n];
+          p && (p[r] = this.We[n]);
+          y && (y[r] = this.Pe[n]);
+          r = a[r];
+          c.set(f, r);
+        } else this.je[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 (r = s; r < t; r++) {
+        if (r in d) {
+          this.Ee[r] = d[r];
+          this.je[r] = h[r];
+          if (p) {
+            this.We[r] = p[r];
+            setSignal(this.We[r], e[r]);
           }
-          if (tempIndexes) {
-            this.o[j] = tempIndexes[j];
-            setSignal(this.o[j], j);
+          if (y) {
+            this.Pe[r] = y[r];
+            setSignal(this.Pe[r], r);
           }
         } else {
-          this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
+          this.Ee[r] = runWithOwner((this.je[r] = createOwner()), i);
         }
       }
-      this.d = this.d.slice(0, this.m = newLen);
-      this.G = newItems.slice(0);
+      this.Ee = this.Ee.slice(0, (this.Ce = t));
+      this.Ne = e.slice(0);
     }
   });
-  return this.d;
+  return this.Ee;
 }
-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 == null ? void 0 : options.from,
-    X: options == null ? void 0 : options.fallback
+    Oe: createOwner(),
+    Ce: 0,
+    Ie: 0,
+    Fe: e,
+    ke: t,
+    je: [],
+    Ee: [],
+    Qe: n?.from,
+    He: n?.fallback
   });
 }
 function updateRepeat() {
-  var _a;
-  const newLen = this.wa();
-  const from = ((_a = this.xa) == null ? void 0 : _a.call(this)) || 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.Fe();
+  const t = this.Qe?.() || 0;
+  runWithOwner(this.Oe, () => {
+    if (e === 0) {
+      if (this.Ce !== 0) {
+        this.Oe.dispose(false);
+        this.je = [];
+        this.Ee = [];
+        this.Ce = 0;
       }
-      if (this.X && !this.d[0]) {
-        this.d[0] = runWithOwner(
-          this.a[0] = createOwner(),
-          this.X
-        );
+      if (this.He && !this.Ee[0]) {
+        this.Ee[0] = runWithOwner((this.je[0] = createOwner()), this.He);
       }
       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 r = this.Ie + this.Ce;
+    if (this.Ce === 0 && this.je[0]) this.je[0].dispose();
+    for (let e = n; e < r; e++) this.je[e - this.Ie].dispose();
+    if (this.Ie < t) {
+      let e = this.Ie;
+      while (e < t && e < this.Ce) this.je[e++].dispose();
+      this.je.splice(0, t - this.Ie);
+      this.Ee.splice(0, t - this.Ie);
+    } else if (this.Ie > t) {
+      let n = r - this.Ie - 1;
+      let i = this.Ie - t;
+      this.je.length = this.Ee.length = e;
+      while (n >= i) {
+        this.je[n] = this.je[n - i];
+        this.Ee[n] = this.Ee[n - i];
+        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 < i; e++) {
+        this.Ee[e] = runWithOwner((this.je[e] = createOwner()), () => this.ke(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 = r; e < n; e++) {
+      this.Ee[e - t] = runWithOwner((this.je[e - t] = createOwner()), () => this.ke(e));
     }
-    this.d = this.d.slice(0, newLen);
-    this.y = from;
-    this.m = newLen;
+    this.Ee = this.Ee.slice(0, e);
+    this.Ie = t;
+    this.Ce = 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.Ee;
+}
+function compare(e, t, n) {
+  return e ? e(t) === e(n) : true;
+}
+function boundaryComputed(e, t) {
+  const n = computed(e, undefined, {
+    we: {
+      le() {
+        let e = this.$;
+        this.$ &= ~this.Re;
+        if (this.Re & f && !(this.$ & a)) {
+          e &= ~f;
         }
-        this.i.notify(this, this.Y, flags);
+        this.ye.notify(this, this.Re, e);
       },
-      Y: propagationMask
+      Re: 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.Re = t;
+  return n;
+}
+function createBoundChildren(e, t, n, r) {
+  const i = e.ye;
+  i.addChild((e.ye = n));
+  onCleanup(() => i.removeChild(e.ye));
+  return runWithOwner(e, () => {
+    const e = computed(t);
+    return boundaryComputed(() => staleValues(() => flatten(read(e))), r);
   });
 }
-var ConditionalQueue = class extends Queue {
-  u;
-  ga = /* @__PURE__ */ new Set();
-  h = /* @__PURE__ */ new Set();
-  constructor(disabled) {
+class ConditionalQueue extends Queue {
+  Ve;
+  qe = new Set();
+  M = 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.Ve = e;
+  }
+  run(e) {
+    if (!e || read(this.Ve)) return;
+    return super.run(e);
+  }
+  notify(e, t, n) {
+    if (read(this.Ve)) {
+      if (t & f) {
+        if (n & f) {
+          this.M.add(e);
+          t &= ~f;
+        } else if (this.M.delete(e)) t &= ~f;
       }
-      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 & c) {
+        if (n & c) {
+          this.qe.add(e);
+          t &= ~c;
+        } else if (this.qe.delete(e)) t &= ~c;
       }
     }
-    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 {
+  Me;
+  je = new Set();
+  Ve = signal(false, { pureWrite: true });
+  De = 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.Me = e;
+  }
+  run(e) {
+    if (!e || read(this.Ve)) return;
+    return super.run(e);
+  }
+  notify(e, t, n) {
+    if (!(t & this.Me) || (this.Me & f && this.De)) return super.notify(e, t, n);
+    if (n & this.Me) {
+      this.je.add(e);
+      if (this.je.size === 1) setSignal(this.Ve, true);
+    } else if (this.je.size > 0) {
+      this.je.delete(e);
+      if (this.je.size === 0) setSignal(this.Ve, false);
+    }
+    t &= ~this.Me;
+    return t ? super.notify(e, t, n) : true;
+  }
+}
+var z;
+(function (e) {
+  e["VISIBLE"] = "visible";
+  e["HIDDEN"] = "hidden";
+})(z || (z = {}));
+function createBoundary(e, t) {
+  const n = createOwner();
+  const r = new ConditionalQueue(computed(() => t() === z.HIDDEN));
+  const i = createBoundChildren(n, e, r, 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(r.Ve);
+    i.Re = e ? c | f : 0;
+    if (!e) {
+      r.M.forEach(e => r.notify(e, f, f));
+      r.qe.forEach(e => r.notify(e, c, c));
+      r.M.clear();
+      r.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(r.Ve) ? undefined : read(i));
+}
+function createCollectionBoundary(e, t, n) {
+  const r = createOwner();
+  const i = new CollectionQueue(e);
+  const s = createBoundChildren(r, t, i, e);
+  const o = computed(() => {
+    if (!read(i.Ve)) {
+      const e = read(s);
+      if (!untrack(() => read(i.Ve))) i.De = true;
+      return e;
+    }
+    return n(i);
   });
-  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(f, e, () => t());
+}
+function collectErrorSources(e, t) {
+  let n = true;
+  let r = e.W;
+  while (r !== null) {
+    const e = r.H;
+    if (e.W && e.$ & c) {
+      n = false;
+      collectErrorSources(e, t);
+    }
+    r = r.P;
+  }
+  n && t.push(e);
+}
+function createErrorBoundary(e, t) {
+  return createCollectionBoundary(c, e, e => {
+    let n = e.je.values().next().value;
+    return t(n.L, () => {
+      const t = [];
+      for (const n of e.je) collectErrorSources(n, t);
+      for (const e of t) recompute(e);
+      schedule();
     });
   });
 }
-function flatten(children, options) {
-  if (typeof children === "function" && !children.length) {
-    if (options == null ? void 0 : 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 == null ? void 0 : 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 r = null;
+  let i = false;
+  for (let s = 0; s < e.length; s++) {
     try {
-      let child = children[i];
-      if (typeof child === "function" && !child.length) {
-        if (options == null ? void 0 : options.doNotUnwrap) {
-          results.push(child);
-          needsUnwrap = true;
+      let r = e[s];
+      if (typeof r === "function" && !r.length) {
+        if (n?.doNotUnwrap) {
+          t.push(r);
+          i = true;
           continue;
         }
         do {
-          child = child();
-        } while (typeof child === "function" && !child.length);
+          r = r();
+        } while (typeof r === "function" && !r.length);
       }
-      if (Array.isArray(child)) {
-        needsUnwrap = flattenArray(child, results, options);
-      } else if ((options == null ? void 0 : options.skipNonRendered) && (child == null || child === true || child === false || child === "")) {
-      } else
-        results.push(child);
+      if (Array.isArray(r)) {
+        i = flattenArray(r, t, n);
+      } else if (n?.skipNonRendered && (r == null || r === true || r === false || r === "")) {
+      } else t.push(r);
     } catch (e) {
-      if (!(e instanceof NotReadyError))
-        throw e;
-      notReady = e;
+      if (!(e instanceof NotReadyError)) throw e;
+      r = e;
     }
   }
-  if (notReady)
-    throw notReady;
-  return needsUnwrap;
+  if (r) throw r;
+  return i;
 }
-
-exports.$PROXY = $PROXY;
-exports.$TARGET = $TARGET;
-exports.$TRACK = $TRACK;
+exports.$PROXY = P;
+exports.$TARGET = W;
+exports.$TRACK = j;
 exports.ContextNotFoundError = ContextNotFoundError;
 exports.NoOwnerError = NoOwnerError;
 exports.NotReadyError = NotReadyError;
-exports.SUPPORTS_PROXY = SUPPORTS_PROXY;
+exports.SUPPORTS_PROXY = y;
 exports.createAsync = createAsync;
 exports.createBoundary = createBoundary;
 exports.createContext = createContext;