@solidjs/signals 0.8.0 → 0.8.1

package/dist/prod.js

@@ -24,16 +24,16 @@ var SUPPORTS_PROXY = typeof Proxy === "function";
 
 // src/core/heap.ts
 function actualInsertIntoHeap(n, heap) {
-  const parentHeight = (n.s?.Z ? n.s._?.e : n.s?.e) ?? -1;
-  if (parentHeight >= n.e)
-    n.e = parentHeight + 1;
-  const height = n.e;
-  const heapAtHeight = heap.o[height];
+  const parentHeight = (n.q?._ ? n.q.$?.c : n.q?.c) ?? -1;
+  if (parentHeight >= n.c)
+    n.c = parentHeight + 1;
+  const height = n.c;
+  const heapAtHeight = heap.p[height];
   if (heapAtHeight === void 0) {
-    heap.o[height] = n;
+    heap.p[height] = n;
   } else {
     const tail = heapAtHeight.x;
-    tail.O = n;
+    tail.P = n;
     n.x = tail;
     heapAtHeight.x = n;
   }
@@ -65,29 +65,29 @@ function deleteFromHeap(n, heap) {
   if (!(flags & (8 /* InHeap */ | 16 /* InHeapHeight */)))
     return;
   n.b = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
-  const height = n.e;
+  const height = n.c;
   if (n.x === n) {
-    heap.o[height] = void 0;
+    heap.p[height] = void 0;
   } else {
-    const next = n.O;
-    const dhh = heap.o[height];
+    const next = n.P;
+    const dhh = heap.p[height];
     const end = next ?? dhh;
     if (n === dhh) {
-      heap.o[height] = next;
+      heap.p[height] = next;
     } else {
-      n.x.O = next;
+      n.x.P = next;
     }
     end.x = n.x;
   }
   n.x = n;
-  n.O = void 0;
+  n.P = void 0;
 }
 function markHeap(heap) {
-  if (heap.$)
+  if (heap.aa)
     return;
-  heap.$ = true;
+  heap.aa = true;
   for (let i = 0; i <= heap.J; i++) {
-    for (let el = heap.o[i]; el !== void 0; el = el.O) {
+    for (let el = heap.p[i]; el !== void 0; el = el.P) {
       if (el.b & 8 /* InHeap */)
         markNode(el);
     }
@@ -98,48 +98,48 @@ function markNode(el, newState = 2 /* Dirty */) {
   if ((flags & (1 /* Check */ | 2 /* Dirty */)) >= newState)
     return;
   el.b = flags & ~(1 /* Check */ | 2 /* Dirty */) | newState;
-  for (let link2 = el.p; link2 !== null; link2 = link2.y) {
-    markNode(link2.m, 1 /* Check */);
+  for (let link2 = el.r; link2 !== null; link2 = link2.y) {
+    markNode(link2.j, 1 /* Check */);
   }
-  if (el.aa !== null) {
-    for (let child = el.aa; child !== null; child = child.qa) {
-      for (let link2 = child.p; link2 !== null; link2 = link2.y) {
-        markNode(link2.m, 1 /* Check */);
+  if (el.ba !== null) {
+    for (let child = el.ba; child !== null; child = child.ra) {
+      for (let link2 = child.r; link2 !== null; link2 = link2.y) {
+        markNode(link2.j, 1 /* Check */);
       }
     }
   }
 }
 function runHeap(heap, recompute2) {
-  heap.$ = false;
-  for (heap.t = 0; heap.t <= heap.J; heap.t++) {
-    let el = heap.o[heap.t];
+  heap.aa = false;
+  for (heap.n = 0; heap.n <= heap.J; heap.n++) {
+    let el = heap.p[heap.n];
     while (el !== void 0) {
       if (el.b & 8 /* InHeap */)
         recompute2(el);
       else {
         adjustHeight(el, heap);
       }
-      el = heap.o[heap.t];
+      el = heap.p[heap.n];
     }
   }
   heap.J = 0;
 }
 function adjustHeight(el, heap) {
   deleteFromHeap(el, heap);
-  let newHeight = el.e;
+  let newHeight = el.c;
   for (let d = el.u; d; d = d.E) {
-    const dep1 = d.P;
+    const dep1 = d.Q;
     const dep = "_owner" in dep1 ? dep1.z : dep1;
     if ("_fn" in dep) {
-      if (dep.e >= newHeight) {
-        newHeight = dep.e + 1;
+      if (dep.c >= newHeight) {
+        newHeight = dep.c + 1;
       }
     }
   }
-  if (el.e !== newHeight) {
-    el.e = newHeight;
-    for (let s = el.p; s !== null; s = s.y) {
-      insertIntoHeapHeight(s.m, heap);
+  if (el.c !== newHeight) {
+    el.c = newHeight;
+    for (let s = el.r; s !== null; s = s.y) {
+      insertIntoHeapHeight(s.j, heap);
     }
   }
 }
@@ -154,40 +154,40 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.ba)
+  if (!globalQueue.ca)
     queueMicrotask(flush);
 }
 var dirtyQueue = {
-  o: new Array(2e3).fill(void 0),
-  $: false,
-  t: 0,
+  p: new Array(2e3).fill(void 0),
+  aa: false,
+  n: 0,
   J: 0
 };
 var zombieQueue = {
-  o: new Array(2e3).fill(void 0),
-  $: false,
-  t: 0,
+  p: new Array(2e3).fill(void 0),
+  aa: false,
+  n: 0,
   J: 0
 };
 var Queue = class {
-  s = null;
+  q = null;
   A = [[], []];
-  Q = [];
+  R = [];
   created = clock;
   addChild(child) {
-    this.Q.push(child);
-    child.s = this;
+    this.R.push(child);
+    child.q = this;
   }
   removeChild(child) {
-    const index = this.Q.indexOf(child);
+    const index = this.R.indexOf(child);
     if (index >= 0) {
-      this.Q.splice(index, 1);
-      child.s = null;
+      this.R.splice(index, 1);
+      child.q = null;
     }
   }
   notify(node, mask, flags) {
-    if (this.s)
-      return this.s.notify(node, mask, flags);
+    if (this.q)
+      return this.q.notify(node, mask, flags);
     return false;
   }
   run(type) {
@@ -196,8 +196,8 @@ var Queue = class {
       this.A[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.Q.length; i++) {
-      this.Q[i].run(type);
+    for (let i = 0; i < this.R.length; i++) {
+      this.R[i].run(type);
     }
   }
   enqueue(type, fn) {
@@ -207,19 +207,19 @@ var Queue = class {
   }
 };
 var GlobalQueue = class _GlobalQueue extends Queue {
-  ba = false;
+  ca = false;
   h = [];
-  static R;
-  static ka;
+  static S;
+  static la;
   flush() {
-    if (this.ba)
+    if (this.ca)
       return;
-    this.ba = true;
+    this.ca = true;
     try {
-      runHeap(dirtyQueue, _GlobalQueue.R);
+      runHeap(dirtyQueue, _GlobalQueue.S);
       if (activeTransition) {
         if (!transitionComplete(activeTransition)) {
-          runHeap(zombieQueue, _GlobalQueue.R);
+          runHeap(zombieQueue, _GlobalQueue.S);
           globalQueue.h = [];
           activeTransition.queues[0].push(...globalQueue.A[0]);
           activeTransition.queues[1].push(...globalQueue.A[1]);
@@ -236,17 +236,17 @@ var GlobalQueue = class _GlobalQueue extends Queue {
         transitions.delete(activeTransition);
         activeTransition = null;
         if (runPending(globalQueue.h, false))
-          runHeap(dirtyQueue, _GlobalQueue.R);
+          runHeap(dirtyQueue, _GlobalQueue.S);
       } else if (transitions.size)
-        runHeap(zombieQueue, _GlobalQueue.R);
+        runHeap(zombieQueue, _GlobalQueue.S);
       for (let i = 0; i < globalQueue.h.length; i++) {
         const n = globalQueue.h[i];
-        if (n.d !== NOT_PENDING) {
-          n.g = n.d;
-          n.d = NOT_PENDING;
+        if (n.e !== NOT_PENDING) {
+          n.g = n.e;
+          n.e = NOT_PENDING;
         }
         if (n.ha)
-          _GlobalQueue.ka(n, false, true);
+          _GlobalQueue.la(n, false, true);
       }
       globalQueue.h.length = 0;
       clock++;
@@ -254,7 +254,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       this.run(1 /* Render */);
       this.run(2 /* User */);
     } finally {
-      this.ba = false;
+      this.ca = false;
       unobserved.length && notifyUnobserved();
     }
   }
@@ -272,7 +272,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
     if (activeTransition && activeTransition.time === clock)
       return;
     if (!activeTransition) {
-      activeTransition = node.S ?? {
+      activeTransition = node.T ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
@@ -283,7 +283,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
     activeTransition.time = clock;
     for (let i = 0; i < globalQueue.h.length; i++) {
       const n = globalQueue.h[i];
-      n.S = activeTransition;
+      n.T = activeTransition;
       activeTransition.pendingNodes.push(n);
     }
     globalQueue.h = activeTransition.pendingNodes;
@@ -294,9 +294,9 @@ function runPending(pendingNodes, value) {
   const p = pendingNodes.slice();
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
-    n.S = activeTransition;
+    n.T = activeTransition;
     if (n.G) {
-      n.G.ca(value);
+      n.G.da(value);
       needsReset = true;
     }
   }
@@ -325,15 +325,15 @@ function transitionComplete(transition) {
 function notifyUnobserved() {
   for (let i = 0; i < unobserved.length; i++) {
     const source = unobserved[i];
-    if (!source.p)
-      unobserved[i].ra?.();
+    if (!source.r)
+      unobserved[i].sa?.();
   }
   unobserved = [];
 }
 
 // src/core/core.ts
-GlobalQueue.R = recompute;
-GlobalQueue.ka = disposeChildren;
+GlobalQueue.S = recompute;
+GlobalQueue.la = disposeChildren;
 var tracking = false;
 var stale = false;
 var pendingValueCheck = false;
@@ -342,23 +342,23 @@ var context = null;
 var defaultContext = {};
 function recompute(el, create = false) {
   deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-  if (el.d !== NOT_PENDING || el.T || el.U)
+  if (el.e !== NOT_PENDING || el.U || el.V)
     disposeChildren(el);
   else {
     markDisposal(el);
     globalQueue.h.push(el);
-    el.U = el.q;
-    el.T = el.n;
-    el.q = null;
-    el.n = null;
+    el.V = el.s;
+    el.U = el.o;
+    el.s = null;
+    el.o = null;
   }
   const oldcontext = context;
   context = el;
   el.H = null;
   el.b = 4 /* RecomputingDeps */;
-  el.V = clock;
-  let value = el.d === NOT_PENDING ? el.g : el.d;
-  let oldHeight = el.e;
+  el.W = clock;
+  let value = el.e === NOT_PENDING ? el.g : el.e;
+  let oldHeight = el.c;
   let prevStatusFlags = el.f;
   let prevError = el.B;
   let prevTracking = tracking;
@@ -391,37 +391,37 @@ function recompute(el, create = false) {
       el.u = null;
     }
   }
-  const valueChanged = !el.da || !el.da(el.d === NOT_PENDING ? el.g : el.d, value);
+  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, value);
   const statusFlagsChanged = el.f !== prevStatusFlags || el.B !== prevError;
-  el.la?.(statusFlagsChanged, prevStatusFlags);
+  el.ma?.(statusFlagsChanged, prevStatusFlags);
   if (valueChanged || statusFlagsChanged) {
     if (valueChanged) {
       if (create || el.ia || el.I)
         el.g = value;
       else {
-        if (el.d === NOT_PENDING)
+        if (el.e === NOT_PENDING)
           globalQueue.h.push(el);
-        el.d = value;
+        el.e = value;
       }
       if (el.C)
-        el.C.ca(value);
+        el.C.da(value);
     }
-    for (let s = el.p; s !== null; s = s.y) {
-      const queue = s.m.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-      if (s.m.e < el.e && queue.t > s.m.e)
-        queue.t = s.m.e;
-      insertIntoHeap(s.m, queue);
+    for (let s = el.r; s !== null; s = s.y) {
+      const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+      if (s.j.c < el.c && queue.n > s.j.c)
+        queue.n = s.j.c;
+      insertIntoHeap(s.j, queue);
     }
-  } else if (el.e != oldHeight) {
-    for (let s = el.p; s !== null; s = s.y) {
-      insertIntoHeapHeight(s.m, s.m.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  } else if (el.c != oldHeight) {
+    for (let s = el.r; s !== null; s = s.y) {
+      insertIntoHeapHeight(s.j, s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
     }
   }
 }
 function updateIfNecessary(el) {
   if (el.b & 1 /* Check */) {
     for (let d = el.u; d; d = d.E) {
-      const dep1 = d.P;
+      const dep1 = d.Q;
       const dep = "_owner" in dep1 ? dep1.z : dep1;
       if ("_fn" in dep) {
         updateIfNecessary(dep);
@@ -437,45 +437,45 @@ function updateIfNecessary(el) {
   el.b = 0 /* None */;
 }
 function unlinkSubs(link2) {
-  const dep = link2.P;
+  const dep = link2.Q;
   const nextDep = link2.E;
   const nextSub = link2.y;
-  const prevSub = link2.ma;
+  const prevSub = link2.na;
   if (nextSub !== null) {
-    nextSub.ma = prevSub;
+    nextSub.na = prevSub;
   } else {
-    dep.W = prevSub;
+    dep.X = prevSub;
   }
   if (prevSub !== null) {
     prevSub.y = nextSub;
   } else {
-    dep.p = nextSub;
+    dep.r = nextSub;
   }
   return nextDep;
 }
 function link(dep, sub) {
   const prevDep = sub.H;
-  if (prevDep !== null && prevDep.P === dep) {
+  if (prevDep !== null && prevDep.Q === dep) {
     return;
   }
   let nextDep = null;
   const isRecomputing = sub.b & 4 /* RecomputingDeps */;
   if (isRecomputing) {
     nextDep = prevDep !== null ? prevDep.E : sub.u;
-    if (nextDep !== null && nextDep.P === dep) {
+    if (nextDep !== null && nextDep.Q === dep) {
       sub.H = nextDep;
       return;
     }
   }
-  const prevSub = dep.W;
-  if (prevSub !== null && prevSub.m === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
+  const prevSub = dep.X;
+  if (prevSub !== null && prevSub.j === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
     return;
   }
-  const newLink = sub.H = dep.W = {
-    P: dep,
-    m: sub,
+  const newLink = sub.H = dep.X = {
+    Q: dep,
+    j: sub,
     E: nextDep,
-    ma: prevSub,
+    na: prevSub,
     y: null
   };
   if (prevDep !== null) {
@@ -486,7 +486,7 @@ function link(dep, sub) {
   if (prevSub !== null) {
     prevSub.y = newLink;
   } else {
-    dep.p = newLink;
+    dep.r = newLink;
   }
 }
 function isValidLink(checkLink, sub) {
@@ -516,7 +516,7 @@ function clearStatusFlags(signal2) {
   setStatusFlags(signal2, 0 /* None */);
 }
 function markDisposal(el) {
-  let child = el.n;
+  let child = el.o;
   while (child) {
     child.b |= 32 /* Zombie */;
     const inHeap = child.b & 8 /* InHeap */;
@@ -533,7 +533,7 @@ function disposeChildren(node, self = false, zombie) {
     return;
   if (self)
     node.b = 64 /* Disposed */;
-  let child = zombie ? node.T : node.n;
+  let child = zombie ? node.U : node.o;
   while (child) {
     const nextChild = child.K;
     if (child.u) {
@@ -550,15 +550,15 @@ function disposeChildren(node, self = false, zombie) {
     child = nextChild;
   }
   if (zombie) {
-    node.T = null;
+    node.U = null;
   } else {
-    node.n = null;
+    node.o = null;
     node.K = null;
   }
   runDisposal(node, zombie);
 }
 function runDisposal(node, zombie) {
-  let disposal = zombie ? node.U : node.q;
+  let disposal = zombie ? node.V : node.s;
   if (!disposal)
     return;
   if (Array.isArray(disposal)) {
@@ -569,20 +569,20 @@ function runDisposal(node, zombie) {
   } else {
     disposal.call(disposal);
   }
-  zombie ? node.U = null : node.q = null;
+  zombie ? node.V = null : node.s = null;
 }
 function withOptions(obj, options) {
   obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
-  obj.da = options?.equals != null ? options.equals : isEqual;
-  obj.xa = !!options?.pureWrite;
-  obj.ra = options?.unobserved;
+  obj.ea = options?.equals != null ? options.equals : isEqual;
+  obj.ya = !!options?.pureWrite;
+  obj.sa = options?.unobserved;
   if (options?.ja)
     Object.assign(obj, options.ja);
   return obj;
 }
 function getNextChildId(owner) {
   if (owner.id != null)
-    return formatId(owner.id, owner.na++);
+    return formatId(owner.id, owner.oa++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(prefix, id) {
@@ -592,47 +592,47 @@ function formatId(prefix, id) {
 function computed(fn, initialValue, options) {
   const self = withOptions(
     {
-      q: null,
+      s: null,
       i: globalQueue,
       D: defaultContext,
-      na: 0,
+      oa: 0,
       ha: fn,
       g: initialValue,
-      e: 0,
-      aa: null,
-      O: void 0,
+      c: 0,
+      ba: null,
+      P: void 0,
       x: null,
       u: null,
       H: null,
-      p: null,
-      W: null,
-      s: context,
+      r: null,
+      X: null,
+      q: context,
       K: null,
-      n: null,
+      o: null,
       b: 0 /* None */,
       f: 4 /* Uninitialized */,
-      V: clock,
-      d: NOT_PENDING,
-      U: null,
-      T: null
+      W: clock,
+      e: NOT_PENDING,
+      V: null,
+      U: null
     },
     options
   );
   self.x = self;
-  const parent = context?.Z ? context._ : context;
+  const parent = context?._ ? context.$ : context;
   if (context) {
     context.i && (self.i = context.i);
     context.D && (self.D = context.D);
-    const lastChild = context.n;
+    const lastChild = context.o;
     if (lastChild === null) {
-      context.n = self;
+      context.o = self;
     } else {
       self.K = lastChild;
-      context.n = self;
+      context.o = self;
     }
   }
   if (parent)
-    self.e = parent.e + 1;
+    self.c = parent.c + 1;
   recompute(self, true);
   return self;
 }
@@ -685,7 +685,7 @@ function asyncComputed(asyncFn, initialValue, options) {
     throw new NotReadyError(context);
   };
   const self = computed(fn, initialValue, options);
-  self.sa = () => {
+  self.ta = () => {
     refreshing = true;
     recompute(self);
     flush();
@@ -694,16 +694,16 @@ function asyncComputed(asyncFn, initialValue, options) {
 }
 function signal(v, options, firewall = null) {
   if (firewall !== null) {
-    return firewall.aa = withOptions(
+    return firewall.ba = withOptions(
       {
         g: v,
-        p: null,
-        W: null,
+        r: null,
+        X: null,
         z: firewall,
-        qa: firewall.aa,
+        ra: firewall.ba,
         f: 0 /* None */,
-        V: clock,
-        d: NOT_PENDING
+        W: clock,
+        e: NOT_PENDING
       },
       options
     );
@@ -711,11 +711,11 @@ function signal(v, options, firewall = null) {
     return withOptions(
       {
         g: v,
-        p: null,
-        W: null,
+        r: null,
+        X: null,
         f: 0 /* None */,
-        V: clock,
-        d: NOT_PENDING
+        W: clock,
+        e: NOT_PENDING
       },
       options
     );
@@ -736,30 +736,30 @@ function untrack(fn) {
 }
 function read(el) {
   let c = context;
-  if (c?.Z)
-    c = c._;
+  if (c?._)
+    c = c.$;
   if (c && tracking) {
     link(el, c);
     const owner = "_owner" in el ? el.z : el;
     if ("_fn" in owner) {
       const isZombie = el.b & 32 /* Zombie */;
-      if (owner.e >= (isZombie ? zombieQueue.t : dirtyQueue.t)) {
+      if (owner.c >= (isZombie ? zombieQueue.n : dirtyQueue.n)) {
         markNode(c);
         markHeap(isZombie ? zombieQueue : dirtyQueue);
         updateIfNecessary(owner);
       }
-      const height = owner.e;
-      if (height >= c.e && el.s !== c) {
-        c.e = height + 1;
+      const height = owner.c;
+      if (height >= c.c && el.q !== c) {
+        c.c = height + 1;
       }
     }
   }
   if (pendingCheck) {
-    const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.S || false;
+    const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.T || false;
     if (!el.G) {
       el.G = signal(pendingResult);
       el.G.ia = true;
-      el.G.ca = (v) => setSignal(el.G, v);
+      el.G.da = (v) => setSignal(el.G, v);
     }
     const prev = pendingCheck;
     pendingCheck = null;
@@ -770,10 +770,10 @@ function read(el) {
   if (pendingValueCheck) {
     if (!el.C) {
       el.C = signal(
-        el.d === NOT_PENDING ? el.g : el.d
+        el.e === NOT_PENDING ? el.g : el.e
       );
       el.C.ia = true;
-      el.C.ca = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
+      el.C.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
     }
     pendingValueCheck = false;
     try {
@@ -794,39 +794,42 @@ function read(el) {
     }
   }
   if (el.f & 2 /* Error */) {
-    if (el.V < clock) {
+    if (el.W < clock) {
       recompute(el, true);
       return read(el);
     } else {
       throw el.B;
     }
   }
-  return !c || el.d === NOT_PENDING || stale && !pendingCheck && el.S && activeTransition !== el.S ? el.g : el.d;
+  return !c || el.e === NOT_PENDING || stale && !pendingCheck && el.T && activeTransition !== el.T ? el.g : el.e;
 }
 function setSignal(el, v) {
   if (typeof v === "function") {
     v = v(
-      el.d === NOT_PENDING ? el.g : el.d
+      el.e === NOT_PENDING ? el.g : el.e
     );
   }
-  const valueChanged = !el.da || !el.da(el.d === NOT_PENDING ? el.g : el.d, v);
+  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;
     else {
-      if (el.d === NOT_PENDING)
+      if (el.e === NOT_PENDING)
         globalQueue.h.push(el);
-      el.d = v;
+      el.e = v;
     }
     if (el.C)
-      el.C.ca(v);
+      el.C.da(v);
   }
   clearStatusFlags(el);
-  el.V = clock;
-  for (let link2 = el.p; link2 !== null; link2 = link2.y) {
-    insertIntoHeap(link2.m, link2.m.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  el.W = clock;
+  for (let s = el.r; s !== null; s = s.y) {
+    const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+    if (queue.n > s.j.c)
+      queue.n = s.j.c;
+    insertIntoHeap(s.j, queue);
   }
   schedule();
   return v;
@@ -841,41 +844,41 @@ function onCleanup(fn) {
   if (!context)
     return fn;
   const node = context;
-  if (!node.q) {
-    node.q = fn;
-  } else if (Array.isArray(node.q)) {
-    node.q.push(fn);
+  if (!node.s) {
+    node.s = fn;
+  } else if (Array.isArray(node.s)) {
+    node.s.push(fn);
   } else {
-    node.q = [node.q, fn];
+    node.s = [node.s, fn];
   }
   return fn;
 }
 function createOwner(options) {
   const parent = context;
   const owner = {
-    Z: true,
-    _: parent?.Z ? parent._ : parent,
-    n: null,
+    _: true,
+    $: parent?._ ? parent.$ : parent,
+    o: null,
     K: null,
-    q: null,
+    s: null,
     id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
     i: parent?.i ?? globalQueue,
     D: parent?.D || defaultContext,
-    na: 0,
+    oa: 0,
+    V: null,
     U: null,
-    T: null,
-    s: parent,
+    q: parent,
     dispose(self = true) {
       disposeChildren(owner, self);
     }
   };
   if (parent) {
-    const lastChild = parent.n;
+    const lastChild = parent.o;
     if (lastChild === null) {
-      parent.n = owner;
+      parent.o = owner;
     } else {
       owner.K = lastChild;
-      parent.n = owner;
+      parent.o = owner;
     }
   }
   return owner;
@@ -964,18 +967,18 @@ function effect(compute, effect2, error, initialValue, options) {
   const node = computed(compute, initialValue, {
     ...options,
     ja: {
-      ea: true,
-      oa: initialValue,
-      ta: effect2,
-      pa: error,
+      fa: true,
+      pa: initialValue,
+      ua: effect2,
+      qa: error,
       L: void 0,
       i: getOwner()?.i ?? globalQueue,
       I: options?.render ? 1 /* Render */ : 2 /* User */,
-      la(statusFlagsChanged, prevStatusFlags) {
+      ma(statusFlagsChanged, prevStatusFlags) {
         if (initialized) {
           const errorChanged = this.f && this.f === prevStatusFlags && statusFlagsChanged;
-          this.ea = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
-          if (this.ea)
+          this.fa = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
+          if (this.fa)
             this.i.enqueue(this.I, runEffect.bind(this));
         }
         if (this.f & 2 /* Error */) {
@@ -983,7 +986,7 @@ function effect(compute, effect2, error, initialValue, options) {
           this.i.notify(this, 1 /* Pending */, 0);
           if (this.I === 2 /* User */) {
             try {
-              return this.pa ? this.pa(error2, () => {
+              return this.qa ? this.qa(error2, () => {
                 this.L?.();
                 this.L = void 0;
               }) : console.error(error2);
@@ -1011,18 +1014,18 @@ function effect(compute, effect2, error, initialValue, options) {
   onCleanup(() => node.L?.());
 }
 function runEffect() {
-  if (!this.ea || this.b & 64 /* Disposed */)
+  if (!this.fa || this.b & 64 /* Disposed */)
     return;
   this.L?.();
   this.L = void 0;
   try {
-    this.L = this.ta(this.g, this.oa);
+    this.L = this.ua(this.g, this.pa);
   } catch (error) {
     if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
       throw error;
   } finally {
-    this.oa = this.g;
-    this.ea = false;
+    this.pa = this.g;
+    this.fa = false;
   }
 }
 
@@ -1053,7 +1056,7 @@ function createMemo(compute, value, options) {
 function createAsync(compute, value, options) {
   const node = asyncComputed(compute, value, options);
   const ret = read.bind(null, node);
-  ret.refresh = node.sa;
+  ret.refresh = node.ta;
   return ret;
 }
 function createEffect(compute, effectFn, value, options) {
@@ -1366,7 +1369,7 @@ var storeTraps = {
         return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked.d !== NOT_PENDING ? tracked.d : tracked.g : storeValue[property];
+      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;
@@ -1766,78 +1769,78 @@ function mapArray(list, map, options) {
   return createMemo(
     updateKeyedMap.bind({
       z: createOwner(),
-      j: 0,
-      ua: list,
+      k: 0,
+      va: list,
       F: [],
       M: map,
-      c: [],
+      d: [],
       a: [],
       N: keyFn,
-      k: keyFn || options?.keyed === false ? [] : void 0,
-      l: map.length > 1 ? [] : void 0,
-      X: options?.fallback
+      l: keyFn || options?.keyed === false ? [] : void 0,
+      m: map.length > 1 ? [] : void 0,
+      Y: options?.fallback
     })
   );
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.ua() || [], newLen = newItems.length;
+  const newItems = this.va() || [], newLen = newItems.length;
   newItems[$TRACK];
   runWithOwner(this.z, () => {
-    let i, j, mapper = this.k ? () => {
-      this.k[j] = signal(newItems[j], pureOptions);
-      this.l && (this.l[j] = signal(j, pureOptions));
+    let i, j, mapper = this.l ? () => {
+      this.l[j] = signal(newItems[j], pureOptions);
+      this.m && (this.m[j] = signal(j, pureOptions));
       return this.M(
-        read.bind(null, this.k[j]),
-        this.l ? read.bind(null, this.l[j]) : void 0
+        read.bind(null, this.l[j]),
+        this.m ? read.bind(null, this.m[j]) : void 0
       );
-    } : this.l ? () => {
+    } : this.m ? () => {
       const item = newItems[j];
-      this.l[j] = signal(j, pureOptions);
+      this.m[j] = signal(j, pureOptions);
       return this.M(
         () => item,
-        read.bind(null, this.l[j])
+        read.bind(null, this.m[j])
       );
     } : () => {
       const item = newItems[j];
       return this.M(() => item);
     };
     if (newLen === 0) {
-      if (this.j !== 0) {
+      if (this.k !== 0) {
         this.z.dispose(false);
         this.a = [];
         this.F = [];
-        this.c = [];
-        this.j = 0;
-        this.k && (this.k = []);
+        this.d = [];
+        this.k = 0;
         this.l && (this.l = []);
+        this.m && (this.m = []);
       }
-      if (this.X && !this.c[0]) {
-        this.c[0] = runWithOwner(
+      if (this.Y && !this.d[0]) {
+        this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
-          this.X
+          this.Y
         );
       }
-    } else if (this.j === 0) {
+    } else if (this.k === 0) {
       if (this.a[0])
         this.a[0].dispose();
-      this.c = new Array(newLen);
+      this.d = new Array(newLen);
       for (j = 0; j < newLen; j++) {
         this.F[j] = newItems[j];
-        this.c[j] = runWithOwner(this.a[j] = createOwner(), mapper);
+        this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
       }
-      this.j = newLen;
+      this.k = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.k ? new Array(newLen) : void 0, tempIndexes = this.l ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.j, newLen); start < end && (this.F[start] === newItems[start] || this.k && compare(this.N, this.F[start], newItems[start])); start++) {
-        if (this.k)
-          setSignal(this.k[start], newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.l ? new Array(newLen) : void 0, tempIndexes = this.m ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.k, newLen); start < end && (this.F[start] === newItems[start] || this.l && compare(this.N, this.F[start], newItems[start])); start++) {
+        if (this.l)
+          setSignal(this.l[start], newItems[start]);
       }
-      for (end = this.j - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.k && compare(this.N, this.F[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.c[end];
+      for (end = this.k - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.l && compare(this.N, this.F[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.d[end];
         tempNodes[newEnd] = this.a[end];
-        tempRows && (tempRows[newEnd] = this.k[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.l[end]);
+        tempRows && (tempRows[newEnd] = this.l[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.m[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
@@ -1853,10 +1856,10 @@ function updateKeyedMap() {
         key = this.N ? this.N(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.c[i];
+          temp[j] = this.d[i];
           tempNodes[j] = this.a[i];
-          tempRows && (tempRows[j] = this.k[i]);
-          tempIndexes && (tempIndexes[j] = this.l[i]);
+          tempRows && (tempRows[j] = this.l[i]);
+          tempIndexes && (tempIndexes[j] = this.m[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -1864,97 +1867,97 @@ function updateKeyedMap() {
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.c[j] = temp[j];
+          this.d[j] = temp[j];
           this.a[j] = tempNodes[j];
           if (tempRows) {
-            this.k[j] = tempRows[j];
-            setSignal(this.k[j], newItems[j]);
+            this.l[j] = tempRows[j];
+            setSignal(this.l[j], newItems[j]);
           }
           if (tempIndexes) {
-            this.l[j] = tempIndexes[j];
-            setSignal(this.l[j], j);
+            this.m[j] = tempIndexes[j];
+            setSignal(this.m[j], j);
           }
         } else {
-          this.c[j] = runWithOwner(this.a[j] = createOwner(), mapper);
+          this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
         }
       }
-      this.c = this.c.slice(0, this.j = newLen);
+      this.d = this.d.slice(0, this.k = newLen);
       this.F = newItems.slice(0);
     }
   });
-  return this.c;
+  return this.d;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
     z: createOwner(),
-    j: 0,
+    k: 0,
     w: 0,
-    va: count,
+    wa: count,
     M: map,
     a: [],
-    c: [],
-    wa: options?.from,
-    X: options?.fallback
+    d: [],
+    xa: options?.from,
+    Y: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.va();
-  const from = this.wa?.() || 0;
+  const newLen = this.wa();
+  const from = this.xa?.() || 0;
   runWithOwner(this.z, () => {
     if (newLen === 0) {
-      if (this.j !== 0) {
+      if (this.k !== 0) {
         this.z.dispose(false);
         this.a = [];
-        this.c = [];
-        this.j = 0;
+        this.d = [];
+        this.k = 0;
       }
-      if (this.X && !this.c[0]) {
-        this.c[0] = runWithOwner(
+      if (this.Y && !this.d[0]) {
+        this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
-          this.X
+          this.Y
         );
       }
       return;
     }
     const to = from + newLen;
-    const prevTo = this.w + this.j;
-    if (this.j === 0 && this.a[0])
+    const prevTo = this.w + this.k;
+    if (this.k === 0 && this.a[0])
       this.a[0].dispose();
     for (let i = to; i < prevTo; i++)
       this.a[i - this.w].dispose();
     if (this.w < from) {
       let i = this.w;
-      while (i < from && i < this.j)
+      while (i < from && i < this.k)
         this.a[i++].dispose();
       this.a.splice(0, from - this.w);
-      this.c.splice(0, from - this.w);
+      this.d.splice(0, from - this.w);
     } else if (this.w > from) {
       let i = prevTo - this.w - 1;
       let difference = this.w - from;
-      this.a.length = this.c.length = newLen;
+      this.a.length = this.d.length = newLen;
       while (i >= difference) {
         this.a[i] = this.a[i - difference];
-        this.c[i] = this.c[i - difference];
+        this.d[i] = this.d[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this.c[i2] = runWithOwner(
+        this.d[i2] = runWithOwner(
           this.a[i2] = createOwner(),
           () => this.M(i2 + from)
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this.c[i - from] = runWithOwner(
+      this.d[i - from] = runWithOwner(
         this.a[i - from] = createOwner(),
         () => this.M(i)
       );
     }
-    this.c = this.c.slice(0, newLen);
+    this.d = this.d.slice(0, newLen);
     this.w = from;
-    this.j = newLen;
+    this.k = newLen;
   });
-  return this.c;
+  return this.d;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
@@ -1964,18 +1967,18 @@ function compare(key, a, b) {
 function boundaryComputed(fn, propagationMask) {
   const node = computed(fn, void 0, {
     ja: {
-      la() {
+      ma() {
         let flags = this.f;
-        this.f &= ~this.Y;
-        if (this.Y & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
+        this.f &= ~this.Z;
+        if (this.Z & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
           flags &= ~1 /* Pending */;
         }
-        this.i.notify(this, this.Y, flags);
+        this.i.notify(this, this.Z, flags);
       },
-      Y: propagationMask
+      Z: propagationMask
     }
   });
-  node.Y = propagationMask;
+  node.Z = propagationMask;
   return node;
 }
 function createBoundChildren(owner, fn, queue, mask) {
@@ -1988,20 +1991,20 @@ function createBoundChildren(owner, fn, queue, mask) {
   });
 }
 var ConditionalQueue = class extends Queue {
-  r;
-  fa = /* @__PURE__ */ new Set();
+  t;
+  ga = /* @__PURE__ */ new Set();
   h = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.r = disabled;
+    this.t = disabled;
   }
   run(type) {
-    if (!type || read(this.r))
+    if (!type || read(this.t))
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (read(this.r)) {
+    if (read(this.t)) {
       if (type & 1 /* Pending */) {
         if (flags & 1 /* Pending */) {
           this.h.add(node);
@@ -2011,9 +2014,9 @@ var ConditionalQueue = class extends Queue {
       }
       if (type & 2 /* Error */) {
         if (flags & 2 /* Error */) {
-          this.fa.add(node);
+          this.ga.add(node);
           type &= ~2 /* Error */;
-        } else if (this.fa.delete(node))
+        } else if (this.ga.delete(node))
           type &= ~2 /* Error */;
       }
     }
@@ -2021,31 +2024,38 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  ga;
+  O;
   a = /* @__PURE__ */ new Set();
-  r = signal(false, { pureWrite: true });
+  t = signal(false, { pureWrite: true });
+  ka = false;
   constructor(type) {
     super();
-    this.ga = type;
+    this.O = type;
   }
   run(type) {
-    if (!type || read(this.r))
+    if (!type || read(this.t))
       return;
     return super.run(type);
   }
+  enqueue(type, fn) {
+    if (this.O & 1 /* Pending */ && this.ka) {
+      return this.q?.enqueue(type, fn);
+    }
+    return super.enqueue(type, fn);
+  }
   notify(node, type, flags) {
-    if (!(type & this.ga))
+    if (!(type & this.O) || this.O & 1 /* Pending */ && this.ka)
       return super.notify(node, type, flags);
-    if (flags & this.ga) {
+    if (flags & this.O) {
       this.a.add(node);
       if (this.a.size === 1)
-        setSignal(this.r, true);
+        setSignal(this.t, true);
     } else if (this.a.size > 0) {
       this.a.delete(node);
       if (this.a.size === 0)
-        setSignal(this.r, false);
+        setSignal(this.t, false);
     }
-    type &= ~this.ga;
+    type &= ~this.O;
     return type ? super.notify(node, type, flags) : true;
   }
 };
@@ -2054,28 +2064,29 @@ function createBoundary(fn, condition) {
   const queue = new ConditionalQueue(computed(() => condition() === "hidden" /* HIDDEN */));
   const tree = createBoundChildren(owner, fn, queue, 0);
   computed(() => {
-    const disabled = read(queue.r);
-    tree.Y = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
+    const disabled = read(queue.t);
+    tree.Z = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
     if (!disabled) {
       queue.h.forEach(
         (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
       );
-      queue.fa.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
+      queue.ga.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
       queue.h.clear();
-      queue.fa.clear();
+      queue.ga.clear();
     }
   });
-  return () => read(queue.r) ? void 0 : read(tree);
+  return () => read(queue.t) ? 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.r)) {
+    if (!read(queue.t)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue.r)))
-        return resolved;
+      if (!untrack(() => read(queue.t)))
+        queue.ka = true;
+      return resolved;
     }
     return fallback(queue);
   });