@solidjs/signals 0.8.1 → 0.8.2

package/dist/prod.js

@@ -24,21 +24,21 @@ var SUPPORTS_PROXY = typeof Proxy === "function";
 
 // src/core/heap.ts
 function actualInsertIntoHeap(n, heap) {
-  const parentHeight = (n.q?._ ? n.q.$?.c : n.q?.c) ?? -1;
+  const parentHeight = (n.w?._ ? n.w.$?.c : n.w?.c) ?? -1;
   if (parentHeight >= n.c)
     n.c = parentHeight + 1;
   const height = n.c;
-  const heapAtHeight = heap.p[height];
+  const heapAtHeight = heap.r[height];
   if (heapAtHeight === void 0) {
-    heap.p[height] = n;
+    heap.r[height] = n;
   } else {
-    const tail = heapAtHeight.x;
-    tail.P = n;
-    n.x = tail;
-    heapAtHeight.x = n;
+    const tail = heapAtHeight.z;
+    tail.Q = n;
+    n.z = tail;
+    heapAtHeight.z = n;
   }
-  if (height > heap.J) {
-    heap.J = height;
+  if (height > heap.L) {
+    heap.L = height;
   }
 }
 function insertIntoHeap(n, heap) {
@@ -66,28 +66,28 @@ function deleteFromHeap(n, heap) {
     return;
   n.b = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
   const height = n.c;
-  if (n.x === n) {
-    heap.p[height] = void 0;
+  if (n.z === n) {
+    heap.r[height] = void 0;
   } else {
-    const next = n.P;
-    const dhh = heap.p[height];
+    const next = n.Q;
+    const dhh = heap.r[height];
     const end = next ?? dhh;
     if (n === dhh) {
-      heap.p[height] = next;
+      heap.r[height] = next;
     } else {
-      n.x.P = next;
+      n.z.Q = next;
     }
-    end.x = n.x;
+    end.z = n.z;
   }
-  n.x = n;
-  n.P = void 0;
+  n.z = n;
+  n.Q = void 0;
 }
 function markHeap(heap) {
   if (heap.aa)
     return;
   heap.aa = true;
-  for (let i = 0; i <= heap.J; i++) {
-    for (let el = heap.p[i]; el !== void 0; el = el.P) {
+  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);
     }
@@ -98,12 +98,12 @@ 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.r; link2 !== null; link2 = link2.y) {
+  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.r; link2 !== null; link2 = link2.y) {
+      for (let link2 = child.s; link2 !== null; link2 = link2.A) {
         markNode(link2.j, 1 /* Check */);
       }
     }
@@ -111,25 +111,25 @@ function markNode(el, newState = 2 /* Dirty */) {
 }
 function runHeap(heap, recompute2) {
   heap.aa = false;
-  for (heap.n = 0; heap.n <= heap.J; heap.n++) {
-    let el = heap.p[heap.n];
+  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.p[heap.n];
+      el = heap.r[heap.p];
     }
   }
-  heap.J = 0;
+  heap.L = 0;
 }
 function adjustHeight(el, heap) {
   deleteFromHeap(el, heap);
   let newHeight = el.c;
-  for (let d = el.u; d; d = d.E) {
-    const dep1 = d.Q;
-    const dep = "_owner" in dep1 ? dep1.z : dep1;
+  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;
@@ -138,7 +138,7 @@ function adjustHeight(el, heap) {
   }
   if (el.c !== newHeight) {
     el.c = newHeight;
-    for (let s = el.r; s !== null; s = s.y) {
+    for (let s = el.s; s !== null; s = s.A) {
       insertIntoHeapHeight(s.j, heap);
     }
   }
@@ -158,59 +158,83 @@ function schedule() {
     queueMicrotask(flush);
 }
 var dirtyQueue = {
-  p: new Array(2e3).fill(void 0),
+  r: new Array(2e3).fill(void 0),
   aa: false,
-  n: 0,
-  J: 0
+  p: 0,
+  L: 0
 };
 var zombieQueue = {
-  p: new Array(2e3).fill(void 0),
+  r: new Array(2e3).fill(void 0),
   aa: false,
-  n: 0,
-  J: 0
+  p: 0,
+  L: 0
 };
 var Queue = class {
-  q = null;
-  A = [[], []];
-  R = [];
+  w = null;
+  k = [[], []];
+  l = [];
   created = clock;
   addChild(child) {
-    this.R.push(child);
-    child.q = this;
+    this.l.push(child);
+    child.w = this;
   }
   removeChild(child) {
-    const index = this.R.indexOf(child);
+    const index = this.l.indexOf(child);
     if (index >= 0) {
-      this.R.splice(index, 1);
-      child.q = null;
+      this.l.splice(index, 1);
+      child.w = null;
     }
   }
   notify(node, mask, flags) {
-    if (this.q)
-      return this.q.notify(node, mask, flags);
+    if (this.w)
+      return this.w.notify(node, mask, flags);
     return false;
   }
   run(type) {
-    if (this.A[type - 1].length) {
-      const effects = this.A[type - 1];
-      this.A[type - 1] = [];
+    if (this.k[type - 1].length) {
+      const effects = this.k[type - 1];
+      this.k[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.R.length; i++) {
-      this.R[i].run(type);
+    for (let i = 0; i < this.l.length; i++) {
+      this.l[i].run(type);
     }
   }
   enqueue(type, fn) {
     if (type)
-      this.A[type - 1].push(fn);
+      this.k[type - 1].push(fn);
     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;
+      }
+      child.stashQueues(childStub);
+    }
+  }
+  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);
+    }
+  }
 };
 var GlobalQueue = class _GlobalQueue extends Queue {
   ca = false;
   h = [];
   static S;
-  static la;
+  static ka;
   flush() {
     if (this.ca)
       return;
@@ -221,9 +245,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
         if (!transitionComplete(activeTransition)) {
           runHeap(zombieQueue, _GlobalQueue.S);
           globalQueue.h = [];
-          activeTransition.queues[0].push(...globalQueue.A[0]);
-          activeTransition.queues[1].push(...globalQueue.A[1]);
-          globalQueue.A = [[], []];
+          globalQueue.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
           runPending(activeTransition.pendingNodes, true);
@@ -231,8 +253,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
           return;
         }
         globalQueue.h.push(...activeTransition.pendingNodes);
-        globalQueue.A[0].push(...activeTransition.queues[0]);
-        globalQueue.A[1].push(...activeTransition.queues[1]);
+        globalQueue.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
         if (runPending(globalQueue.h, false))
@@ -246,7 +267,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
           n.e = NOT_PENDING;
         }
         if (n.ha)
-          _GlobalQueue.la(n, false, true);
+          _GlobalQueue.ka(n, false, true);
       }
       globalQueue.h.length = 0;
       clock++;
@@ -261,8 +282,8 @@ var GlobalQueue = class _GlobalQueue extends Queue {
   notify(node, mask, flags) {
     if (mask & 1 /* Pending */) {
       if (flags & 1 /* Pending */) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(node.B.cause))
-          activeTransition.asyncNodes.push(node.B.cause);
+        if (activeTransition && !activeTransition.asyncNodes.includes(node.C.cause))
+          activeTransition.asyncNodes.push(node.C.cause);
       }
       return true;
     }
@@ -276,7 +297,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queues: [[], []]
+        queueStash: { k: [[], []], l: [] }
       };
     }
     transitions.add(activeTransition);
@@ -295,8 +316,8 @@ function runPending(pendingNodes, value) {
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
     n.T = activeTransition;
-    if (n.G) {
-      n.G.da(value);
+    if (n.H) {
+      n.H.da(value);
       needsReset = true;
     }
   }
@@ -325,7 +346,7 @@ function transitionComplete(transition) {
 function notifyUnobserved() {
   for (let i = 0; i < unobserved.length; i++) {
     const source = unobserved[i];
-    if (!source.r)
+    if (!source.s)
       unobserved[i].sa?.();
   }
   unobserved = [];
@@ -333,13 +354,21 @@ function notifyUnobserved() {
 
 // src/core/core.ts
 GlobalQueue.S = recompute;
-GlobalQueue.la = disposeChildren;
+GlobalQueue.ka = disposeChildren;
 var tracking = false;
 var stale = false;
 var pendingValueCheck = false;
 var pendingCheck = null;
 var context = null;
 var defaultContext = {};
+function notifySubs(node) {
+  for (let s = node.s; s !== null; s = s.A) {
+    const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+    if (queue.p > s.j.c)
+      queue.p = s.j.c;
+    insertIntoHeap(s.j, queue);
+  }
+}
 function recompute(el, create = false) {
   deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
   if (el.e !== NOT_PENDING || el.U || el.V)
@@ -347,20 +376,20 @@ function recompute(el, create = false) {
   else {
     markDisposal(el);
     globalQueue.h.push(el);
-    el.V = el.s;
-    el.U = el.o;
-    el.s = null;
-    el.o = null;
+    el.V = el.t;
+    el.U = el.q;
+    el.t = null;
+    el.q = null;
   }
   const oldcontext = context;
   context = el;
-  el.H = null;
+  el.I = null;
   el.b = 4 /* RecomputingDeps */;
-  el.W = clock;
+  el.J = clock;
   let value = el.e === NOT_PENDING ? el.g : el.e;
   let oldHeight = el.c;
   let prevStatusFlags = el.f;
-  let prevError = el.B;
+  let prevError = el.C;
   let prevTracking = tracking;
   clearStatusFlags(el);
   tracking = true;
@@ -379,50 +408,50 @@ function recompute(el, create = false) {
   }
   el.b = 0 /* None */;
   context = oldcontext;
-  const depsTail = el.H;
-  let toRemove = depsTail !== null ? depsTail.E : el.u;
+  const depsTail = el.I;
+  let toRemove = depsTail !== null ? depsTail.F : el.x;
   if (toRemove !== null) {
     do {
       toRemove = unlinkSubs(toRemove);
     } while (toRemove !== null);
     if (depsTail !== null) {
-      depsTail.E = null;
+      depsTail.F = null;
     } else {
-      el.u = null;
+      el.x = null;
     }
   }
   const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, value);
-  const statusFlagsChanged = el.f !== prevStatusFlags || el.B !== prevError;
-  el.ma?.(statusFlagsChanged, prevStatusFlags);
+  const statusFlagsChanged = el.f !== prevStatusFlags || el.C !== prevError;
+  el.la?.(statusFlagsChanged, prevStatusFlags);
   if (valueChanged || statusFlagsChanged) {
     if (valueChanged) {
-      if (create || el.ia || el.I)
+      if (create || el.ia || el.K)
         el.g = value;
       else {
         if (el.e === NOT_PENDING)
           globalQueue.h.push(el);
         el.e = value;
       }
-      if (el.C)
-        el.C.da(value);
+      if (el.D)
+        el.D.da(value);
     }
-    for (let s = el.r; s !== null; s = s.y) {
+    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.n > s.j.c)
-        queue.n = s.j.c;
+      if (s.j.c < el.c && queue.p > s.j.c)
+        queue.p = s.j.c;
       insertIntoHeap(s.j, queue);
     }
   } else if (el.c != oldHeight) {
-    for (let s = el.r; s !== null; s = s.y) {
+    for (let s = el.s; s !== null; s = s.A) {
       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.Q;
-      const dep = "_owner" in dep1 ? dep1.z : dep1;
+    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);
       }
@@ -437,62 +466,62 @@ function updateIfNecessary(el) {
   el.b = 0 /* None */;
 }
 function unlinkSubs(link2) {
-  const dep = link2.Q;
-  const nextDep = link2.E;
-  const nextSub = link2.y;
-  const prevSub = link2.na;
+  const dep = link2.R;
+  const nextDep = link2.F;
+  const nextSub = link2.A;
+  const prevSub = link2.ma;
   if (nextSub !== null) {
-    nextSub.na = prevSub;
+    nextSub.ma = prevSub;
   } else {
-    dep.X = prevSub;
+    dep.W = prevSub;
   }
   if (prevSub !== null) {
-    prevSub.y = nextSub;
+    prevSub.A = nextSub;
   } else {
-    dep.r = nextSub;
+    dep.s = nextSub;
   }
   return nextDep;
 }
 function link(dep, sub) {
-  const prevDep = sub.H;
-  if (prevDep !== null && prevDep.Q === dep) {
+  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.E : sub.u;
-    if (nextDep !== null && nextDep.Q === dep) {
-      sub.H = nextDep;
+    nextDep = prevDep !== null ? prevDep.F : sub.x;
+    if (nextDep !== null && nextDep.R === dep) {
+      sub.I = nextDep;
       return;
     }
   }
-  const prevSub = dep.X;
+  const prevSub = dep.W;
   if (prevSub !== null && prevSub.j === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
     return;
   }
-  const newLink = sub.H = dep.X = {
-    Q: dep,
+  const newLink = sub.I = dep.W = {
+    R: dep,
     j: sub,
-    E: nextDep,
-    na: prevSub,
-    y: null
+    F: nextDep,
+    ma: prevSub,
+    A: null
   };
   if (prevDep !== null) {
-    prevDep.E = newLink;
+    prevDep.F = newLink;
   } else {
-    sub.u = newLink;
+    sub.x = newLink;
   }
   if (prevSub !== null) {
-    prevSub.y = newLink;
+    prevSub.A = newLink;
   } else {
-    dep.r = newLink;
+    dep.s = newLink;
   }
 }
 function isValidLink(checkLink, sub) {
-  const depsTail = sub.H;
+  const depsTail = sub.I;
   if (depsTail !== null) {
-    let link2 = sub.u;
+    let link2 = sub.x;
     do {
       if (link2 === checkLink) {
         return true;
@@ -500,23 +529,23 @@ function isValidLink(checkLink, sub) {
       if (link2 === depsTail) {
         break;
       }
-      link2 = link2.E;
+      link2 = link2.F;
     } while (link2 !== null);
   }
   return false;
 }
 function setStatusFlags(signal2, flags, error = null) {
   signal2.f = flags;
-  signal2.B = error;
+  signal2.C = error;
 }
 function setError(signal2, error) {
-  setStatusFlags(signal2, 2 /* Error */ | 4 /* Uninitialized */, error);
+  setStatusFlags(signal2, 2 /* Error */, error);
 }
 function clearStatusFlags(signal2) {
   setStatusFlags(signal2, 0 /* None */);
 }
 function markDisposal(el) {
-  let child = el.o;
+  let child = el.q;
   while (child) {
     child.b |= 32 /* Zombie */;
     const inHeap = child.b & 8 /* InHeap */;
@@ -525,7 +554,7 @@ function markDisposal(el) {
       insertIntoHeap(child, zombieQueue);
     }
     markDisposal(child);
-    child = child.K;
+    child = child.M;
   }
 }
 function disposeChildren(node, self = false, zombie) {
@@ -533,18 +562,18 @@ function disposeChildren(node, self = false, zombie) {
     return;
   if (self)
     node.b = 64 /* Disposed */;
-  let child = zombie ? node.U : node.o;
+  let child = zombie ? node.U : node.q;
   while (child) {
-    const nextChild = child.K;
-    if (child.u) {
+    const nextChild = child.M;
+    if (child.x) {
       const n = child;
       deleteFromHeap(n, n.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-      let toRemove = n.u;
+      let toRemove = n.x;
       do {
         toRemove = unlinkSubs(toRemove);
       } while (toRemove !== null);
-      n.u = null;
-      n.H = null;
+      n.x = null;
+      n.I = null;
     }
     disposeChildren(child, true);
     child = nextChild;
@@ -552,13 +581,13 @@ function disposeChildren(node, self = false, zombie) {
   if (zombie) {
     node.U = null;
   } else {
-    node.o = null;
-    node.K = null;
+    node.q = null;
+    node.M = null;
   }
   runDisposal(node, zombie);
 }
 function runDisposal(node, zombie) {
-  let disposal = zombie ? node.V : node.s;
+  let disposal = zombie ? node.V : node.t;
   if (!disposal)
     return;
   if (Array.isArray(disposal)) {
@@ -569,7 +598,7 @@ function runDisposal(node, zombie) {
   } else {
     disposal.call(disposal);
   }
-  zombie ? node.V = null : node.s = null;
+  zombie ? node.V = null : node.t = null;
 }
 function withOptions(obj, options) {
   obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
@@ -582,7 +611,7 @@ function withOptions(obj, options) {
 }
 function getNextChildId(owner) {
   if (owner.id != null)
-    return formatId(owner.id, owner.oa++);
+    return formatId(owner.id, owner.na++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(prefix, id) {
@@ -592,43 +621,43 @@ function formatId(prefix, id) {
 function computed(fn, initialValue, options) {
   const self = withOptions(
     {
-      s: null,
+      t: null,
       i: globalQueue,
-      D: defaultContext,
-      oa: 0,
+      E: defaultContext,
+      na: 0,
       ha: fn,
       g: initialValue,
       c: 0,
       ba: null,
-      P: void 0,
+      Q: void 0,
+      z: null,
       x: null,
-      u: null,
-      H: null,
-      r: null,
-      X: null,
-      q: context,
-      K: null,
-      o: null,
+      I: null,
+      s: null,
+      W: null,
+      w: context,
+      M: null,
+      q: null,
       b: 0 /* None */,
       f: 4 /* Uninitialized */,
-      W: clock,
+      J: clock,
       e: NOT_PENDING,
       V: null,
       U: null
     },
     options
   );
-  self.x = self;
+  self.z = self;
   const parent = context?._ ? context.$ : context;
   if (context) {
     context.i && (self.i = context.i);
-    context.D && (self.D = context.D);
-    const lastChild = context.o;
+    context.E && (self.E = context.E);
+    const lastChild = context.q;
     if (lastChild === null) {
-      context.o = self;
+      context.q = self;
     } else {
-      self.K = lastChild;
-      context.o = self;
+      self.M = lastChild;
+      context.q = self;
     }
   }
   if (parent)
@@ -660,6 +689,9 @@ function asyncComputed(asyncFn, initialValue, options) {
           return;
         globalQueue.initTransition(self);
         setError(self, e);
+        self.J = clock;
+        notifySubs(self);
+        schedule();
         flush();
       });
     } else {
@@ -677,6 +709,9 @@ function asyncComputed(asyncFn, initialValue, options) {
             return;
           globalQueue.initTransition(self);
           setError(self, error);
+          self.J = clock;
+          notifySubs(self);
+          schedule();
           flush();
         }
       })();
@@ -697,12 +732,12 @@ function signal(v, options, firewall = null) {
     return firewall.ba = withOptions(
       {
         g: v,
-        r: null,
-        X: null,
-        z: firewall,
+        s: null,
+        W: null,
+        B: firewall,
         ra: firewall.ba,
         f: 0 /* None */,
-        W: clock,
+        J: clock,
         e: NOT_PENDING
       },
       options
@@ -711,10 +746,10 @@ function signal(v, options, firewall = null) {
     return withOptions(
       {
         g: v,
-        r: null,
-        X: null,
+        s: null,
+        W: null,
         f: 0 /* None */,
-        W: clock,
+        J: clock,
         e: NOT_PENDING
       },
       options
@@ -740,65 +775,65 @@ function read(el) {
     c = c.$;
   if (c && tracking) {
     link(el, c);
-    const owner = "_owner" in el ? el.z : el;
+    const owner = "_owner" in el ? el.B : el;
     if ("_fn" in owner) {
       const isZombie = el.b & 32 /* Zombie */;
-      if (owner.c >= (isZombie ? zombieQueue.n : dirtyQueue.n)) {
+      if (owner.c >= (isZombie ? zombieQueue.p : dirtyQueue.p)) {
         markNode(c);
         markHeap(isZombie ? zombieQueue : dirtyQueue);
         updateIfNecessary(owner);
       }
       const height = owner.c;
-      if (height >= c.c && el.q !== c) {
+      if (height >= c.c && el.w !== c) {
         c.c = height + 1;
       }
     }
   }
   if (pendingCheck) {
     const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.T || false;
-    if (!el.G) {
-      el.G = signal(pendingResult);
-      el.G.ia = true;
-      el.G.da = (v) => setSignal(el.G, v);
+    if (!el.H) {
+      el.H = signal(pendingResult);
+      el.H.ia = true;
+      el.H.da = (v) => setSignal(el.H, v);
     }
     const prev = pendingCheck;
     pendingCheck = null;
-    read(el.G);
+    read(el.H);
     pendingCheck = prev;
     prev.g = pendingResult || prev.g;
   }
   if (pendingValueCheck) {
-    if (!el.C) {
-      el.C = signal(
+    if (!el.D) {
+      el.D = signal(
         el.e === NOT_PENDING ? el.g : el.e
       );
-      el.C.ia = true;
-      el.C.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
+      el.D.ia = true;
+      el.D.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.D, v)));
     }
     pendingValueCheck = false;
     try {
-      return read(el.C);
+      return read(el.D);
     } finally {
       pendingValueCheck = true;
     }
   }
   if (el.f & 1 /* Pending */) {
     if (c && !stale || el.f & 4 /* Uninitialized */)
-      throw el.B;
+      throw el.C;
     else if (c && stale && !pendingCheck) {
       setStatusFlags(
         c,
         c.f | 1,
-        el.B
+        el.C
       );
     }
   }
   if (el.f & 2 /* Error */) {
-    if (el.W < clock) {
+    if (el.J < clock) {
       recompute(el, true);
       return read(el);
     } else {
-      throw el.B;
+      throw el.C;
     }
   }
   return !c || el.e === NOT_PENDING || stale && !pendingCheck && el.T && activeTransition !== el.T ? el.g : el.e;
@@ -820,17 +855,12 @@ function setSignal(el, v) {
         globalQueue.h.push(el);
       el.e = v;
     }
-    if (el.C)
-      el.C.da(v);
+    if (el.D)
+      el.D.da(v);
   }
   clearStatusFlags(el);
-  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);
-  }
+  el.J = clock;
+  notifySubs(el);
   schedule();
   return v;
 }
@@ -844,12 +874,12 @@ function onCleanup(fn) {
   if (!context)
     return fn;
   const node = context;
-  if (!node.s) {
-    node.s = fn;
-  } else if (Array.isArray(node.s)) {
-    node.s.push(fn);
+  if (!node.t) {
+    node.t = fn;
+  } else if (Array.isArray(node.t)) {
+    node.t.push(fn);
   } else {
-    node.s = [node.s, fn];
+    node.t = [node.t, fn];
   }
   return fn;
 }
@@ -858,27 +888,27 @@ function createOwner(options) {
   const owner = {
     _: true,
     $: parent?._ ? parent.$ : parent,
-    o: null,
-    K: null,
-    s: null,
+    q: null,
+    M: null,
+    t: null,
     id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
     i: parent?.i ?? globalQueue,
-    D: parent?.D || defaultContext,
-    oa: 0,
+    E: parent?.E || defaultContext,
+    na: 0,
     V: null,
     U: null,
-    q: parent,
+    w: parent,
     dispose(self = true) {
       disposeChildren(owner, self);
     }
   };
   if (parent) {
-    const lastChild = parent.o;
+    const lastChild = parent.q;
     if (lastChild === null) {
-      parent.o = owner;
+      parent.q = owner;
     } else {
-      owner.K = lastChild;
-      parent.o = owner;
+      owner.M = lastChild;
+      parent.q = owner;
     }
   }
   return owner;
@@ -939,7 +969,7 @@ function getContext(context2, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context2, owner) ? owner.D[context2.id] : context2.defaultValue;
+  const value = hasContext(context2, owner) ? owner.E[context2.id] : context2.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -949,13 +979,13 @@ function setContext(context2, value, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.D = {
-    ...owner.D,
+  owner.E = {
+    ...owner.E,
     [context2.id]: isUndefined(value) ? context2.defaultValue : value
   };
 }
 function hasContext(context2, owner) {
-  return !isUndefined(owner?.D[context2.id]);
+  return !isUndefined(owner?.E[context2.id]);
 }
 function isUndefined(value) {
   return typeof value === "undefined";
@@ -968,27 +998,27 @@ function effect(compute, effect2, error, initialValue, options) {
     ...options,
     ja: {
       fa: true,
-      pa: initialValue,
+      oa: initialValue,
       ua: effect2,
-      qa: error,
-      L: void 0,
+      pa: error,
+      N: void 0,
       i: getOwner()?.i ?? globalQueue,
-      I: options?.render ? 1 /* Render */ : 2 /* User */,
-      ma(statusFlagsChanged, prevStatusFlags) {
+      K: options?.render ? 1 /* Render */ : 2 /* User */,
+      la(statusFlagsChanged, prevStatusFlags) {
         if (initialized) {
           const errorChanged = this.f && this.f === prevStatusFlags && statusFlagsChanged;
           this.fa = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
           if (this.fa)
-            this.i.enqueue(this.I, runEffect.bind(this));
+            this.i.enqueue(this.K, runEffect.bind(this));
         }
         if (this.f & 2 /* Error */) {
-          let error2 = this.B;
+          let error2 = this.C;
           this.i.notify(this, 1 /* Pending */, 0);
-          if (this.I === 2 /* User */) {
+          if (this.K === 2 /* User */) {
             try {
-              return this.qa ? this.qa(error2, () => {
-                this.L?.();
-                this.L = void 0;
+              return this.pa ? this.pa(error2, () => {
+                this.N?.();
+                this.N = void 0;
               }) : console.error(error2);
             } catch (e) {
               error2 = e;
@@ -996,7 +1026,7 @@ function effect(compute, effect2, error, initialValue, options) {
           }
           if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
             throw error2;
-        } else if (this.I === 1 /* Render */) {
+        } else if (this.K === 1 /* Render */) {
           this.i.notify(
             this,
             1 /* Pending */ | 2 /* Error */,
@@ -1007,24 +1037,23 @@ function effect(compute, effect2, error, initialValue, options) {
     }
   });
   initialized = true;
-  if (node.I === 1 /* Render */) {
-    node.ha = (p) => !(node.f & 2 /* Error */) ? staleValues(() => compute(p)) : compute(p);
-  }
-  !options?.defer && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.I === 2 /* User */ ? node.i.enqueue(node.I, runEffect.bind(node)) : runEffect.call(node));
-  onCleanup(() => node.L?.());
+  if (node.K === 1 /* Render */)
+    node.ha = (p) => staleValues(() => compute(p));
+  !options?.defer && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.K === 2 /* User */ ? node.i.enqueue(node.K, runEffect.bind(node)) : runEffect.call(node));
+  onCleanup(() => node.N?.());
 }
 function runEffect() {
   if (!this.fa || this.b & 64 /* Disposed */)
     return;
-  this.L?.();
-  this.L = void 0;
+  this.N?.();
+  this.N = void 0;
   try {
-    this.L = this.ua(this.g, this.pa);
+    this.N = this.ua(this.g, this.oa);
   } catch (error) {
     if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
       throw error;
   } finally {
-    this.pa = this.g;
+    this.oa = this.g;
     this.fa = false;
   }
 }
@@ -1768,17 +1797,17 @@ function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return createMemo(
     updateKeyedMap.bind({
-      z: createOwner(),
-      k: 0,
+      B: createOwner(),
+      m: 0,
       va: list,
-      F: [],
-      M: map,
+      G: [],
+      O: map,
       d: [],
       a: [],
-      N: keyFn,
-      l: keyFn || options?.keyed === false ? [] : void 0,
-      m: map.length > 1 ? [] : void 0,
-      Y: options?.fallback
+      P: keyFn,
+      n: keyFn || options?.keyed === false ? [] : void 0,
+      o: map.length > 1 ? [] : void 0,
+      X: options?.fallback
     })
   );
 }
@@ -1786,80 +1815,80 @@ var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
   const newItems = this.va() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.z, () => {
-    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.l[j]),
-        this.m ? read.bind(null, this.m[j]) : void 0
+  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.m ? () => {
+    } : this.o ? () => {
       const item = newItems[j];
-      this.m[j] = signal(j, pureOptions);
-      return this.M(
+      this.o[j] = signal(j, pureOptions);
+      return this.O(
         () => item,
-        read.bind(null, this.m[j])
+        read.bind(null, this.o[j])
       );
     } : () => {
       const item = newItems[j];
-      return this.M(() => item);
+      return this.O(() => item);
     };
     if (newLen === 0) {
-      if (this.k !== 0) {
-        this.z.dispose(false);
+      if (this.m !== 0) {
+        this.B.dispose(false);
         this.a = [];
-        this.F = [];
+        this.G = [];
         this.d = [];
-        this.k = 0;
-        this.l && (this.l = []);
-        this.m && (this.m = []);
+        this.m = 0;
+        this.n && (this.n = []);
+        this.o && (this.o = []);
       }
-      if (this.Y && !this.d[0]) {
+      if (this.X && !this.d[0]) {
         this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
-          this.Y
+          this.X
         );
       }
-    } else if (this.k === 0) {
+    } 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.F[j] = newItems[j];
+        this.G[j] = newItems[j];
         this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
       }
-      this.k = newLen;
+      this.m = newLen;
     } else {
-      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]);
+      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]);
       }
-      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--) {
+      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.l[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.m[end]);
+        tempRows && (tempRows[newEnd] = this.n[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.o[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.N ? this.N(item) : item;
+        key = this.P ? this.P(item) : item;
         i = newIndices.get(key);
         newIndicesNext[j] = i === void 0 ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.F[i];
-        key = this.N ? this.N(item) : item;
+        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.l[i]);
-          tempIndexes && (tempIndexes[j] = this.m[i]);
+          tempRows && (tempRows[j] = this.n[i]);
+          tempIndexes && (tempIndexes[j] = this.o[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -1870,70 +1899,70 @@ function updateKeyedMap() {
           this.d[j] = temp[j];
           this.a[j] = tempNodes[j];
           if (tempRows) {
-            this.l[j] = tempRows[j];
-            setSignal(this.l[j], newItems[j]);
+            this.n[j] = tempRows[j];
+            setSignal(this.n[j], newItems[j]);
           }
           if (tempIndexes) {
-            this.m[j] = tempIndexes[j];
-            setSignal(this.m[j], j);
+            this.o[j] = tempIndexes[j];
+            setSignal(this.o[j], j);
           }
         } else {
           this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
         }
       }
-      this.d = this.d.slice(0, this.k = newLen);
-      this.F = newItems.slice(0);
+      this.d = this.d.slice(0, this.m = newLen);
+      this.G = newItems.slice(0);
     }
   });
   return this.d;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    z: createOwner(),
-    k: 0,
-    w: 0,
+    B: createOwner(),
+    m: 0,
+    y: 0,
     wa: count,
-    M: map,
+    O: map,
     a: [],
     d: [],
     xa: options?.from,
-    Y: options?.fallback
+    X: options?.fallback
   });
 }
 function updateRepeat() {
   const newLen = this.wa();
   const from = this.xa?.() || 0;
-  runWithOwner(this.z, () => {
+  runWithOwner(this.B, () => {
     if (newLen === 0) {
-      if (this.k !== 0) {
-        this.z.dispose(false);
+      if (this.m !== 0) {
+        this.B.dispose(false);
         this.a = [];
         this.d = [];
-        this.k = 0;
+        this.m = 0;
       }
-      if (this.Y && !this.d[0]) {
+      if (this.X && !this.d[0]) {
         this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
-          this.Y
+          this.X
         );
       }
       return;
     }
     const to = from + newLen;
-    const prevTo = this.w + this.k;
-    if (this.k === 0 && this.a[0])
+    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.w].dispose();
-    if (this.w < from) {
-      let i = this.w;
-      while (i < from && i < this.k)
+      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.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.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];
@@ -1943,19 +1972,19 @@ function updateRepeat() {
       for (let i2 = 0; i2 < difference; i2++) {
         this.d[i2] = runWithOwner(
           this.a[i2] = createOwner(),
-          () => this.M(i2 + from)
+          () => this.O(i2 + from)
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
       this.d[i - from] = runWithOwner(
         this.a[i - from] = createOwner(),
-        () => this.M(i)
+        () => this.O(i)
       );
     }
     this.d = this.d.slice(0, newLen);
-    this.w = from;
-    this.k = newLen;
+    this.y = from;
+    this.m = newLen;
   });
   return this.d;
 }
@@ -1967,18 +1996,18 @@ function compare(key, a, b) {
 function boundaryComputed(fn, propagationMask) {
   const node = computed(fn, void 0, {
     ja: {
-      ma() {
+      la() {
         let flags = this.f;
-        this.f &= ~this.Z;
-        if (this.Z & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
+        this.f &= ~this.Y;
+        if (this.Y & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
           flags &= ~1 /* Pending */;
         }
-        this.i.notify(this, this.Z, flags);
+        this.i.notify(this, this.Y, flags);
       },
-      Z: propagationMask
+      Y: propagationMask
     }
   });
-  node.Z = propagationMask;
+  node.Y = propagationMask;
   return node;
 }
 function createBoundChildren(owner, fn, queue, mask) {
@@ -1991,20 +2020,20 @@ function createBoundChildren(owner, fn, queue, mask) {
   });
 }
 var ConditionalQueue = class extends Queue {
-  t;
+  u;
   ga = /* @__PURE__ */ new Set();
   h = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.t = disabled;
+    this.u = disabled;
   }
   run(type) {
-    if (!type || read(this.t))
+    if (!type || read(this.u))
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (read(this.t)) {
+    if (read(this.u)) {
       if (type & 1 /* Pending */) {
         if (flags & 1 /* Pending */) {
           this.h.add(node);
@@ -2024,38 +2053,32 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  O;
+  Z;
   a = /* @__PURE__ */ new Set();
-  t = signal(false, { pureWrite: true });
-  ka = false;
+  u = signal(false, { pureWrite: true });
+  qa = false;
   constructor(type) {
     super();
-    this.O = type;
+    this.Z = type;
   }
   run(type) {
-    if (!type || read(this.t))
+    if (!type || read(this.u))
       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.O) || this.O & 1 /* Pending */ && this.ka)
+    if (!(type & this.Z) || this.Z & 1 /* Pending */ && this.qa)
       return super.notify(node, type, flags);
-    if (flags & this.O) {
+    if (flags & this.Z) {
       this.a.add(node);
       if (this.a.size === 1)
-        setSignal(this.t, true);
+        setSignal(this.u, true);
     } else if (this.a.size > 0) {
       this.a.delete(node);
       if (this.a.size === 0)
-        setSignal(this.t, false);
+        setSignal(this.u, false);
     }
-    type &= ~this.O;
+    type &= ~this.Z;
     return type ? super.notify(node, type, flags) : true;
   }
 };
@@ -2064,8 +2087,8 @@ function createBoundary(fn, condition) {
   const queue = new ConditionalQueue(computed(() => condition() === "hidden" /* HIDDEN */));
   const tree = createBoundChildren(owner, fn, queue, 0);
   computed(() => {
-    const disabled = read(queue.t);
-    tree.Z = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
+    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 */)
@@ -2075,17 +2098,17 @@ function createBoundary(fn, condition) {
       queue.ga.clear();
     }
   });
-  return () => read(queue.t) ? void 0 : read(tree);
+  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.t)) {
+    if (!read(queue.u)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue.t)))
-        queue.ka = true;
+      if (!untrack(() => read(queue.u)))
+        queue.qa = true;
       return resolved;
     }
     return fallback(queue);
@@ -2098,7 +2121,7 @@ function createLoadBoundary(fn, fallback) {
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(2 /* Error */, fn, (queue) => {
     let node = queue.a.values().next().value;
-    return fallback(node.B, () => {
+    return fallback(node.C, () => {
       for (let node2 of queue.a) {
         recompute(node2, true);
       }