@solidjs/universal 2.0.0-beta.3 → 2.0.0-beta.4

package/dist/universal.cjs

@@ -72,9 +72,9 @@ function deleteFromHeap(e, t) {
   if (e.T === e) t.l[i] = undefined;else {
     const n = e.S;
     const r = t.l[i];
-    const o = n ?? r;
+    const s = n ?? r;
     if (e === r) t.l[i] = n;else e.T.S = n;
-    o.T = e.T;
+    s.T = e.T;
   }
   e.T = e;
   e.S = undefined;
@@ -145,34 +145,94 @@ const zombieQueue = {
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
+let stashedOptimisticReads = null;
 function runLaneEffects(e) {
   for (const t of activeLanes) {
-    if (t.k || t.U.size > 0) continue;
-    const n = t.W[e - 1];
+    if (t.U || t.k.size > 0) continue;
+    const n = t.G[e - 1];
     if (n.length) {
-      t.W[e - 1] = [];
+      t.G[e - 1] = [];
       runQueue(n, e);
     }
   }
 }
+function queueStashedOptimisticEffects(e) {
+  for (let t = e.I; t !== null; t = t.p) {
+    const e = t.h;
+    if (!e.W) continue;
+    if (e.W === EFFECT_TRACKED) {
+      if (!e.H) {
+        e.H = true;
+        e.F.enqueue(EFFECT_USER, e.M);
+      }
+      continue;
+    }
+    const n = e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (n.P > e.o) n.P = e.o;
+    insertIntoHeap(e, n);
+  }
+}
+function mergeTransitionState(e, t) {
+  t.$ = e;
+  e.j.push(...t.j);
+  for (const n of activeLanes) {
+    if (n.K === t) n.K = e;
+  }
+  e.Y.push(...t.Y);
+  for (const n of t.Z) e.Z.add(n);
+  for (const n of t.B) {
+    if (!e.B.includes(n)) e.B.push(n);
+  }
+}
+function resolveOptimisticNodes(e) {
+  for (let t = 0; t < e.length; t++) {
+    const n = e[t];
+    n.q = undefined;
+    if (n.X !== NOT_PENDING) {
+      n.J = n.X;
+      n.X = NOT_PENDING;
+    }
+    const i = n.ee;
+    n.ee = NOT_PENDING;
+    if (i !== NOT_PENDING && n.J !== i) insertSubs(n, true);
+    n.K = null;
+  }
+  e.length = 0;
+}
+function cleanupCompletedLanes(e) {
+  for (const t of activeLanes) {
+    const n = e ? t.K === e : !t.K;
+    if (!n) continue;
+    if (!t.U) {
+      if (t.G[0].length) runQueue(t.G[0], EFFECT_RENDER);
+      if (t.G[1].length) runQueue(t.G[1], EFFECT_USER);
+    }
+    if (t.te.q === t) t.te.q = undefined;
+    t.k.clear();
+    t.G[0].length = 0;
+    t.G[1].length = 0;
+    activeLanes.delete(t);
+    signalLanes.delete(t.te);
+  }
+}
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.H && true) queueMicrotask(flush);
+  if (!globalQueue.ne && true) queueMicrotask(flush);
 }
 class Queue {
   i = null;
-  G = [[], []];
-  F = [];
+  ie = [[], []];
+  re = [];
   created = clock;
   addChild(e) {
-    this.F.push(e);
+    this.re.push(e);
     e.i = this;
   }
   removeChild(e) {
-    const t = this.F.indexOf(e);
+    const t = this.re.indexOf(e);
     if (t >= 0) {
-      this.F.splice(t, 1);
+      this.re.splice(t, 1);
       e.i = null;
     }
   }
@@ -181,91 +241,104 @@ class Queue {
     return false;
   }
   run(e) {
-    if (this.G[e - 1].length) {
-      const t = this.G[e - 1];
-      this.G[e - 1] = [];
+    if (this.ie[e - 1].length) {
+      const t = this.ie[e - 1];
+      this.ie[e - 1] = [];
       runQueue(t, e);
     }
-    for (let t = 0; t < this.F.length; t++) this.F[t].run?.(e);
+    for (let t = 0; t < this.re.length; t++) this.re[t].run?.(e);
   }
   enqueue(e, t) {
     if (e) {
       if (currentOptimisticLane) {
         const n = findLane(currentOptimisticLane);
-        n.W[e - 1].push(t);
+        n.G[e - 1].push(t);
       } else {
-        this.G[e - 1].push(t);
+        this.ie[e - 1].push(t);
       }
     }
     schedule();
   }
   stashQueues(e) {
-    e.G[0].push(...this.G[0]);
-    e.G[1].push(...this.G[1]);
-    this.G = [[], []];
-    for (let t = 0; t < this.F.length; t++) {
-      let n = this.F[t];
-      let i = e.F[t];
+    e.ie[0].push(...this.ie[0]);
+    e.ie[1].push(...this.ie[1]);
+    this.ie = [[], []];
+    for (let t = 0; t < this.re.length; t++) {
+      let n = this.re[t];
+      let i = e.re[t];
       if (!i) {
         i = {
-          G: [[], []],
-          F: []
+          ie: [[], []],
+          re: []
         };
-        e.F[t] = i;
+        e.re[t] = i;
       }
       n.stashQueues(i);
     }
   }
   restoreQueues(e) {
-    this.G[0].push(...e.G[0]);
-    this.G[1].push(...e.G[1]);
-    for (let t = 0; t < e.F.length; t++) {
-      const n = e.F[t];
-      let i = this.F[t];
+    this.ie[0].push(...e.ie[0]);
+    this.ie[1].push(...e.ie[1]);
+    for (let t = 0; t < e.re.length; t++) {
+      const n = e.re[t];
+      let i = this.re[t];
       if (i) i.restoreQueues(n);
     }
   }
 }
 class GlobalQueue extends Queue {
-  H = false;
-  M = [];
-  $ = [];
-  j = new Set();
-  static K;
-  static Y;
-  static B = null;
+  ne = false;
+  se = [];
+  Y = [];
+  Z = new Set();
+  static oe;
+  static ue;
+  static ce = null;
   flush() {
-    if (this.H) return;
-    this.H = true;
+    if (this.ne) return;
+    this.ne = true;
     try {
-      runHeap(dirtyQueue, GlobalQueue.K);
+      runHeap(dirtyQueue, GlobalQueue.oe);
       if (activeTransition) {
         const e = transitionComplete(activeTransition);
         if (!e) {
-          let e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.K);
-          this.M = [];
-          this.$ = [];
-          this.j = new Set();
+          const e = activeTransition;
+          runHeap(zombieQueue, GlobalQueue.oe);
+          this.se = [];
+          this.Y = [];
+          this.Z = new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(activeTransition.Z);
+          this.stashQueues(e.ae);
           clock++;
           scheduled = dirtyQueue.R >= dirtyQueue.P;
-          reassignPendingTransition(activeTransition.M);
+          reassignPendingTransition(e.se);
           activeTransition = null;
-          finalizePureQueue(null, true);
+          if (!e.j.length && e.Y.length) {
+            stashedOptimisticReads = new Set();
+            for (let t = 0; t < e.Y.length; t++) {
+              const n = e.Y[t];
+              if (n.L || n.fe) continue;
+              stashedOptimisticReads.add(n);
+              queueStashedOptimisticEffects(n);
+            }
+          }
+          try {
+            finalizePureQueue(null, true);
+          } finally {
+            stashedOptimisticReads = null;
+          }
           return;
         }
-        this.M !== activeTransition.M && this.M.push(...activeTransition.M);
-        this.restoreQueues(activeTransition.Z);
+        this.se !== activeTransition.se && this.se.push(...activeTransition.se);
+        this.restoreQueues(activeTransition.ae);
         transitions.delete(activeTransition);
         const t = activeTransition;
         activeTransition = null;
-        reassignPendingTransition(this.M);
+        reassignPendingTransition(this.se);
         finalizePureQueue(t);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.K);
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.oe);
         finalizePureQueue();
       }
       clock++;
@@ -275,16 +348,19 @@ class GlobalQueue extends Queue {
       runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
     } finally {
-      this.H = false;
+      this.ne = false;
     }
   }
   notify(e, t, n, i) {
     if (t & STATUS_PENDING) {
       if (n & STATUS_PENDING) {
-        const t = i !== undefined ? i : e.q;
-        if (activeTransition && t && !activeTransition.X.includes(t.source)) {
-          activeTransition.X.push(t.source);
-          schedule();
+        const t = i !== undefined ? i : e.le;
+        if (activeTransition && t) {
+          const e = t.source;
+          if (!activeTransition.B.includes(e)) {
+            activeTransition.B.push(e);
+            schedule();
+          }
         }
       }
       return true;
@@ -294,61 +370,59 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (e) e = currentTransition(e);
     if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.J === clock) return;
+    if (!e && activeTransition && activeTransition.Ee === clock) return;
     if (!activeTransition) {
       activeTransition = e ?? {
-        J: clock,
-        M: [],
-        X: [],
-        $: [],
-        j: new Set(),
-        ee: [],
-        Z: {
-          G: [[], []],
-          F: []
+        Ee: clock,
+        se: [],
+        B: [],
+        Y: [],
+        Z: new Set(),
+        j: [],
+        ae: {
+          ie: [[], []],
+          re: []
         },
-        te: false
+        $: false
       };
     } else if (e) {
       const t = activeTransition;
-      t.te = e;
-      e.ee.push(...t.ee);
-      for (const n of activeLanes) {
-        if (n.ne === t) n.ne = e;
-      }
-      e.$.push(...t.$);
-      for (const n of t.j) {
-        e.j.add(n);
-      }
+      mergeTransitionState(e, t);
       transitions.delete(t);
       activeTransition = e;
     }
     transitions.add(activeTransition);
-    activeTransition.J = clock;
-    for (let e = 0; e < this.M.length; e++) {
-      const t = this.M[e];
-      t.ne = activeTransition;
-      activeTransition.M.push(t);
+    activeTransition.Ee = clock;
+    if (this.se !== activeTransition.se) {
+      for (let e = 0; e < this.se.length; e++) {
+        const t = this.se[e];
+        t.K = activeTransition;
+        activeTransition.se.push(t);
+      }
+      this.se = activeTransition.se;
     }
-    this.M = activeTransition.M;
-    for (let e = 0; e < this.$.length; e++) {
-      const t = this.$[e];
-      t.ne = activeTransition;
-      activeTransition.$.push(t);
+    if (this.Y !== activeTransition.Y) {
+      for (let e = 0; e < this.Y.length; e++) {
+        const t = this.Y[e];
+        t.K = activeTransition;
+        activeTransition.Y.push(t);
+      }
+      this.Y = activeTransition.Y;
     }
-    this.$ = activeTransition.$;
     for (const e of activeLanes) {
-      if (!e.ne) e.ne = activeTransition;
+      if (!e.K) e.K = activeTransition;
+    }
+    if (this.Z !== activeTransition.Z) {
+      for (const e of this.Z) activeTransition.Z.add(e);
+      this.Z = activeTransition.Z;
     }
-    for (const e of this.j) activeTransition.j.add(e);
-    this.j = activeTransition.j;
   }
 }
 function insertSubs(e, t = false) {
-  const n = e.ie || currentOptimisticLane;
-  const i = e.re !== undefined;
+  const n = e.q || currentOptimisticLane;
+  const i = e.Te !== undefined;
   for (let r = e.I; r !== null; r = r.p) {
-    if (i && r.h.oe) {
+    if (i && r.h.de) {
       r.h.O |= REACTIVE_SNAPSHOT_STALE;
       continue;
     }
@@ -357,93 +431,64 @@ function insertSubs(e, t = false) {
       assignOrMergeLane(r.h, n);
     } else if (t) {
       r.h.O |= REACTIVE_OPTIMISTIC_DIRTY;
-      r.h.ie = undefined;
+      r.h.q = undefined;
     }
     const e = r.h;
-    if (e.se === EFFECT_TRACKED) {
-      if (!e.ue) {
-        e.ue = true;
-        e.ce.enqueue(EFFECT_USER, e.ae);
+    if (e.W === EFFECT_TRACKED) {
+      if (!e.H) {
+        e.H = true;
+        e.F.enqueue(EFFECT_USER, e.M);
       }
       continue;
     }
-    const o = r.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (o.P > r.h.o) o.P = r.h.o;
-    insertIntoHeap(r.h, o);
+    const s = r.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (s.P > r.h.o) s.P = r.h.o;
+    insertIntoHeap(r.h, s);
   }
 }
 function commitPendingNodes() {
-  const e = globalQueue.M;
+  const e = globalQueue.se;
   for (let t = 0; t < e.length; t++) {
     const n = e[t];
-    if (n.le !== NOT_PENDING) {
-      n.fe = n.le;
-      n.le = NOT_PENDING;
-      if (n.se && n.se !== EFFECT_TRACKED) n.ue = true;
+    if (n.X !== NOT_PENDING) {
+      n.J = n.X;
+      n.X = NOT_PENDING;
+      if (n.W && n.W !== EFFECT_TRACKED) n.H = true;
     }
-    if (n.Ee & STATUS_PENDING) {
-      const e = n.q?.source;
-      if (e && !(e.Ee & STATUS_PENDING)) {
-        n.Ee &= -6;
-        n.q = null;
-      }
-    } else n.Ee &= ~STATUS_UNINITIALIZED;
-    if (n.L) GlobalQueue.Y(n, false, true);
+    if (!(n.Se & STATUS_PENDING)) n.Se &= ~STATUS_UNINITIALIZED;
+    if (n.L) GlobalQueue.ue(n, false, true);
   }
   e.length = 0;
 }
 function finalizePureQueue(e = null, t = false) {
-  let n = !t;
+  const n = !t;
   if (n) commitPendingNodes();
   if (!t) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.K);
+  if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.oe);
   if (n) {
     commitPendingNodes();
-    const t = e ? e.$ : globalQueue.$;
-    for (let e = 0; e < t.length; e++) {
-      const n = t[e];
-      n.ie = undefined;
-      if (n.le !== NOT_PENDING) {
-        n.fe = n.le;
-        n.le = NOT_PENDING;
-      }
-      const i = n.Te;
-      n.Te = NOT_PENDING;
-      if (i !== NOT_PENDING && n.fe !== i) insertSubs(n, true);
-      n.ne = null;
-    }
-    t.length = 0;
-    e ? e.j : globalQueue.j;
-    for (const t of activeLanes) {
-      const n = e ? t.ne === e : !t.ne;
-      if (!n) continue;
-      if (!t.k) {
-        if (t.W[0].length) runQueue(t.W[0], EFFECT_RENDER);
-        if (t.W[1].length) runQueue(t.W[1], EFFECT_USER);
-      }
-      if (t.de.ie === t) t.de.ie = undefined;
-      t.U.clear();
-      t.W[0].length = 0;
-      t.W[1].length = 0;
-      activeLanes.delete(t);
-      signalLanes.delete(t.de);
-    }
+    resolveOptimisticNodes(e ? e.Y : globalQueue.Y);
+    e ? e.Z : globalQueue.Z;
+    cleanupCompletedLanes(e);
   }
 }
 function checkBoundaryChildren(e) {
-  for (const t of e.F) {
+  for (const t of e.re) {
     t.checkSources?.();
     checkBoundaryChildren(t);
   }
 }
 function reassignPendingTransition(e) {
   for (let t = 0; t < e.length; t++) {
-    e[t].ne = activeTransition;
+    e[t].K = activeTransition;
   }
 }
 const globalQueue = new GlobalQueue();
 function flush() {
-  while (scheduled) {
+  if (globalQueue.ne) {
+    return;
+  }
+  while (scheduled || activeTransition) {
     globalQueue.flush();
   }
 }
@@ -451,21 +496,30 @@ function runQueue(e, t) {
   for (let n = 0; n < e.length; n++) e[n](t);
 }
 function transitionComplete(e) {
-  if (e.te) return true;
-  if (e.ee.length) return false;
+  if (e.$) return true;
+  if (e.j.length) return false;
   let t = true;
-  for (let n = 0; n < e.X.length; n++) {
-    const i = e.X[n];
-    if (i.Ee & STATUS_PENDING && i.q?.source === i) {
+  for (let n = 0; n < e.B.length; n++) {
+    const i = e.B[n];
+    if (i.Se & STATUS_PENDING && i.le?.source === i) {
       t = false;
       break;
     }
   }
-  t && (e.te = true);
+  if (t) {
+    for (let n = 0; n < e.Y.length; n++) {
+      const i = e.Y[n];
+      if (hasActiveOverride(i) && "Se" in i && i.Se & STATUS_PENDING && i.le instanceof NotReadyError && i.le.source !== i) {
+        t = false;
+        break;
+      }
+    }
+  }
+  t && (e.$ = true);
   return t;
 }
 function currentTransition(e) {
-  while (e.te && typeof e.te === "object") e = e.te;
+  while (e.$ && typeof e.$ === "object") e = e.$;
   return e;
 }
 function runInTransition(e, t) {
@@ -484,119 +538,213 @@ function getOrCreateLane(e) {
   if (t) {
     return findLane(t);
   }
-  const n = e.Se;
-  const i = n?.ie ? findLane(n.ie) : null;
+  const n = e.Re;
+  const i = n?.q ? findLane(n.q) : null;
   t = {
-    de: e,
-    U: new Set(),
-    W: [[], []],
-    k: null,
-    ne: activeTransition,
-    Re: i
+    te: e,
+    k: new Set(),
+    G: [[], []],
+    U: null,
+    K: activeTransition,
+    Oe: i
   };
   signalLanes.set(e, t);
   activeLanes.add(t);
-  e.Oe = false;
+  e._e = false;
   return t;
 }
 function findLane(e) {
-  while (e.k) e = e.k;
+  while (e.U) e = e.U;
   return e;
 }
 function mergeLanes(e, t) {
   e = findLane(e);
   t = findLane(t);
   if (e === t) return e;
-  t.k = e;
-  for (const n of t.U) e.U.add(n);
-  e.W[0].push(...t.W[0]);
-  e.W[1].push(...t.W[1]);
+  t.U = e;
+  for (const n of t.k) e.k.add(n);
+  e.G[0].push(...t.G[0]);
+  e.G[1].push(...t.G[1]);
   return e;
 }
 function resolveLane(e) {
-  const t = e.ie;
+  const t = e.q;
   if (!t) return undefined;
   const n = findLane(t);
   if (activeLanes.has(n)) return n;
-  e.ie = undefined;
+  e.q = undefined;
   return undefined;
 }
+function resolveTransition(e) {
+  return resolveLane(e)?.K ?? e.K;
+}
 function hasActiveOverride(e) {
-  return !!(e.Te !== undefined && e.Te !== NOT_PENDING);
+  return !!(e.ee !== undefined && e.ee !== NOT_PENDING);
 }
 function assignOrMergeLane(e, t) {
   const n = findLane(t);
-  const i = e.ie;
+  const i = e.q;
   if (i) {
-    if (i.k) {
-      e.ie = t;
+    if (i.U) {
+      e.q = t;
       return;
     }
     const r = findLane(i);
     if (activeLanes.has(r)) {
       if (r !== n && !hasActiveOverride(e)) {
-        if (n.Re && findLane(n.Re) === r) {
-          e.ie = t;
-        } else if (r.Re && findLane(r.Re) === n) ;else mergeLanes(n, r);
+        if (n.Oe && findLane(n.Oe) === r) {
+          e.q = t;
+        } else if (r.Oe && findLane(r.Oe) === n) ;else mergeLanes(n, r);
       }
       return;
     }
   }
-  e.ie = t;
+  e.q = t;
+}
+function addPendingSource(e, t) {
+  if (e.Ie === t || e.pe?.has(t)) return false;
+  if (!e.Ie) {
+    e.Ie = t;
+    return true;
+  }
+  if (!e.pe) {
+    e.pe = new Set([e.Ie, t]);
+  } else {
+    e.pe.add(t);
+  }
+  e.Ie = undefined;
+  return true;
+}
+function removePendingSource(e, t) {
+  if (e.Ie) {
+    if (e.Ie !== t) return false;
+    e.Ie = undefined;
+    return true;
+  }
+  if (!e.pe?.delete(t)) return false;
+  if (e.pe.size === 1) {
+    e.Ie = e.pe.values().next().value;
+    e.pe = undefined;
+  } else if (e.pe.size === 0) {
+    e.pe = undefined;
+  }
+  return true;
+}
+function clearPendingSources(e) {
+  e.Ie = undefined;
+  e.pe?.clear();
+  e.pe = undefined;
+}
+function setPendingError(e, t, n) {
+  if (!t) {
+    e.le = null;
+    return;
+  }
+  if (n instanceof NotReadyError && n.source === t) {
+    e.le = n;
+    return;
+  }
+  const i = e.le;
+  if (!(i instanceof NotReadyError) || i.source !== t) {
+    e.le = new NotReadyError(t);
+  }
+}
+function forEachDependent(e, t) {
+  for (let n = e.I; n !== null; n = n.p) t(n.h);
+  for (let n = e.A; n !== null; n = n.N) {
+    for (let e = n.I; e !== null; e = e.p) t(e.h);
+  }
+}
+function settlePendingSource(e) {
+  let t = false;
+  const n = new Set();
+  const settle = i => {
+    if (n.has(i) || !removePendingSource(i, e)) return;
+    n.add(i);
+    i.Ee = clock;
+    const r = i.Ie ?? i.pe?.values().next().value;
+    if (r) {
+      setPendingError(i, r);
+      updatePendingSignal(i);
+    } else {
+      i.Se &= ~STATUS_PENDING;
+      setPendingError(i);
+      updatePendingSignal(i);
+      if (i.he) {
+        if (i.W === EFFECT_TRACKED) {
+          const e = i;
+          if (!e.H) {
+            e.H = true;
+            e.F.enqueue(EFFECT_USER, e.M);
+          }
+        } else {
+          const e = i.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+          if (e.P > i.o) e.P = i.o;
+          insertIntoHeap(i, e);
+        }
+        t = true;
+      }
+      i.he = false;
+    }
+    forEachDependent(i, settle);
+  };
+  forEachDependent(e, settle);
+  if (t) schedule();
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
   const r = i && untrack(() => t[Symbol.asyncIterator]);
-  const o = !r && i && untrack(() => typeof t.then === "function");
-  if (!o && !r) {
-    e._e = null;
+  const s = !r && i && untrack(() => typeof t.then === "function");
+  if (!s && !r) {
+    e.Ae = null;
     return t;
   }
-  e._e = t;
-  let s;
+  e.Ae = t;
+  let o;
   const handleError = n => {
-    if (e._e !== t) return;
-    globalQueue.initTransition(e.ne);
+    if (e.Ae !== t) return;
+    globalQueue.initTransition(resolveTransition(e));
     notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.J = clock;
+    e.Ee = clock;
   };
   const asyncWrite = (i, r) => {
-    if (e._e !== t) return;
+    if (e.Ae !== t) return;
     if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(e.ne);
+    globalQueue.initTransition(resolveTransition(e));
     clearStatus(e);
-    const o = resolveLane(e);
-    if (o) o.U.delete(e);
-    if (e.Te !== undefined) {
-      if (e.Te !== undefined && e.Te !== NOT_PENDING) e.le = i;else {
-        e.fe = i;
+    const s = resolveLane(e);
+    if (s) s.k.delete(e);
+    if (e.ee !== undefined) {
+      if (e.ee !== undefined && e.ee !== NOT_PENDING) e.X = i;else {
+        e.J = i;
         insertSubs(e);
       }
-      e.J = clock;
-    } else if (o) {
-      const t = e.fe;
-      const n = e.Ie;
+      e.Ee = clock;
+    } else if (s) {
+      const t = e.J;
+      const n = e.Ne;
       if (!n || !n(i, t)) {
-        e.fe = i;
-        e.J = clock;
-        if (e.pe) {
-          setSignal(e.pe, i);
+        e.J = i;
+        e.Ee = clock;
+        if (e.Pe) {
+          setSignal(e.Pe, i);
         }
         insertSubs(e, true);
       }
     } else {
       setSignal(e, () => i);
     }
+    settlePendingSource(e);
     schedule();
     flush();
     r?.();
   };
-  if (o) {
+  if (s) {
     let n = false,
       i = true;
     t.then(e => {
       if (i) {
-        s = e;
+        o = e;
         n = true;
       } else asyncWrite(e);
     }, e => {
@@ -604,7 +752,7 @@ function handleAsync(e, t, n) {
     });
     i = false;
     if (!n) {
-      globalQueue.initTransition(e.ne);
+      globalQueue.initTransition(resolveTransition(e));
       throw new NotReadyError(context);
     }
   }
@@ -628,7 +776,7 @@ function handleAsync(e, t, n) {
       });
       r = false;
       if (t && !e.done) {
-        s = e.value;
+        o = e.value;
         i = true;
         return iterate();
       }
@@ -636,75 +784,126 @@ function handleAsync(e, t, n) {
     };
     const r = iterate();
     if (!i && !r) {
-      globalQueue.initTransition(e.ne);
+      globalQueue.initTransition(resolveTransition(e));
       throw new NotReadyError(context);
     }
   }
-  return s;
+  return o;
 }
-function clearStatus(e) {
-  e.Ee = e.Ee & STATUS_UNINITIALIZED;
-  e.q = null;
+function clearStatus(e, t = false) {
+  clearPendingSources(e);
+  e.he = false;
+  e.Se = t ? 0 : e.Se & STATUS_UNINITIALIZED;
+  setPendingError(e);
   updatePendingSignal(e);
-  e.he?.();
+  e.ge?.();
 }
 function notifyStatus(e, t, n, i, r) {
   if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError)) n = new StatusError(e, n);
-  const o = n instanceof NotReadyError && n.source === e;
-  const s = t === STATUS_PENDING && e.Te !== undefined && !o;
-  const u = s && hasActiveOverride(e);
+  const s = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
+  const o = s === e;
+  const u = t === STATUS_PENDING && e.ee !== undefined && !o;
+  const c = u && hasActiveOverride(e);
   if (!i) {
-    e.Ee = t | (t !== STATUS_ERROR ? e.Ee & STATUS_UNINITIALIZED : 0);
-    e.q = n;
+    if (t === STATUS_PENDING && s) {
+      addPendingSource(e, s);
+      e.Se = STATUS_PENDING | e.Se & STATUS_UNINITIALIZED;
+      setPendingError(e, s, n);
+    } else {
+      clearPendingSources(e);
+      e.Se = t | (t !== STATUS_ERROR ? e.Se & STATUS_UNINITIALIZED : 0);
+      e.le = n;
+    }
     updatePendingSignal(e);
   }
   if (r && !i) {
     assignOrMergeLane(e, r);
   }
-  if (u && activeTransition && n instanceof NotReadyError) {
-    const e = n.source;
-    if (!activeTransition.X.includes(e)) {
-      activeTransition.X.push(e);
+  const a = i || c;
+  const f = i || u ? undefined : r;
+  if (e.ge) {
+    if (i && t === STATUS_PENDING) {
+      return;
     }
-  }
-  const c = i || u;
-  const a = i || s ? undefined : r;
-  if (e.he) {
-    if (c) {
-      e.he(t, n);
+    if (a) {
+      e.ge(t, n);
     } else {
-      e.he();
+      e.ge();
     }
     return;
   }
-  for (let i = e.I; i !== null; i = i.p) {
-    i.h.J = clock;
-    if (i.h.q !== n) {
-      !i.h.ne && globalQueue.M.push(i.h);
-      notifyStatus(i.h, t, n, c, a);
+  forEachDependent(e, e => {
+    e.Ee = clock;
+    if (t === STATUS_PENDING && s && e.Ie !== s && !e.pe?.has(s) || t !== STATUS_PENDING && (e.le !== n || e.Ie || e.pe)) {
+      if (!a && !e.K) globalQueue.se.push(e);
+      notifyStatus(e, t, n, a, f);
     }
+  });
+}
+let externalSourceConfig = null;
+function markDisposal(e) {
+  let t = e.Ce;
+  while (t) {
+    t.O |= REACTIVE_ZOMBIE;
+    if (t.O & REACTIVE_IN_HEAP) {
+      deleteFromHeap(t, dirtyQueue);
+      insertIntoHeap(t, zombieQueue);
+    }
+    markDisposal(t);
+    t = t.De;
   }
-  for (let i = e.A; i !== null; i = i.N) {
-    for (let e = i.I; e !== null; e = e.p) {
-      e.h.J = clock;
-      if (e.h.q !== n) {
-        !e.h.ne && globalQueue.M.push(e.h);
-        notifyStatus(e.h, t, n, c, a);
-      }
+}
+function disposeChildren(e, t = false, n) {
+  if (e.O & REACTIVE_DISPOSED) return;
+  if (t) e.O = REACTIVE_DISPOSED;
+  let i = n ? e.me : e.Ce;
+  while (i) {
+    const e = i.De;
+    if (i.C) {
+      const e = i;
+      deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.C;
+      do {
+        t = unlinkSubs(t);
+      } while (t !== null);
+      e.C = null;
+      e.ye = null;
+    }
+    disposeChildren(i, true);
+    i = e;
+  }
+  if (n) {
+    e.me = null;
+  } else {
+    e.Ce = null;
+    e.ve = 0;
+  }
+  runDisposal(e, n);
+}
+function runDisposal(e, t) {
+  let n = t ? e.we : e.be;
+  if (!n) return;
+  if (Array.isArray(n)) {
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      t.call(t);
     }
+  } else {
+    n.call(n);
   }
+  t ? e.we = null : e.be = null;
 }
 function unlinkSubs(e) {
   const t = e.m;
   const n = e.D;
   const i = e.p;
-  const r = e.Ae;
-  if (i !== null) i.Ae = r;else t.Ne = r;
+  const r = e.Ue;
+  if (i !== null) i.Ue = r;else t.ke = r;
   if (r !== null) r.p = i;else {
     t.I = i;
     if (i === null) {
-      t.ge?.();
-      t.L && !t.Pe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
+      t.Ge?.();
+      t.L && !t.xe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
     }
   }
   return n;
@@ -719,31 +918,31 @@ function unobserved(e) {
   disposeChildren(e, true);
 }
 function link(e, t) {
-  const n = t.Ce;
+  const n = t.ye;
   if (n !== null && n.m === e) return;
   let i = null;
   const r = t.O & REACTIVE_RECOMPUTING_DEPS;
   if (r) {
     i = n !== null ? n.D : t.C;
     if (i !== null && i.m === e) {
-      t.Ce = i;
+      t.ye = i;
       return;
     }
   }
-  const o = e.Ne;
-  if (o !== null && o.h === t && (!r || isValidLink(o, t))) return;
-  const s = t.Ce = e.Ne = {
+  const s = e.ke;
+  if (s !== null && s.h === t && (!r || isValidLink(s, t))) return;
+  const o = t.ye = e.ke = {
     m: e,
     h: t,
     D: i,
-    Ae: o,
+    Ue: s,
     p: null
   };
-  if (n !== null) n.D = s;else t.C = s;
-  if (o !== null) o.p = s;else e.I = s;
+  if (n !== null) n.D = o;else t.C = o;
+  if (s !== null) s.p = o;else e.I = o;
 }
 function isValidLink(e, t) {
-  const n = t.Ce;
+  const n = t.ye;
   if (n !== null) {
     let i = t.C;
     do {
@@ -754,91 +953,38 @@ function isValidLink(e, t) {
   }
   return false;
 }
-function markDisposal(e) {
-  let t = e.De;
-  while (t) {
-    t.O |= REACTIVE_ZOMBIE;
-    if (t.O & REACTIVE_IN_HEAP) {
-      deleteFromHeap(t, dirtyQueue);
-      insertIntoHeap(t, zombieQueue);
-    }
-    markDisposal(t);
-    t = t.ye;
-  }
-}
-function disposeChildren(e, t = false, n) {
-  if (e.O & REACTIVE_DISPOSED) return;
-  if (t) e.O = REACTIVE_DISPOSED;
-  let i = n ? e.ve : e.De;
-  while (i) {
-    const e = i.ye;
-    if (i.C) {
-      const e = i;
-      deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      let t = e.C;
-      do {
-        t = unlinkSubs(t);
-      } while (t !== null);
-      e.C = null;
-      e.Ce = null;
-    }
-    disposeChildren(i, true);
-    i = e;
-  }
-  if (n) {
-    e.ve = null;
-  } else {
-    e.De = null;
-    e.we = 0;
-  }
-  runDisposal(e, n);
-}
-function runDisposal(e, t) {
-  let n = t ? e.be : e.me;
-  if (!n) return;
-  if (Array.isArray(n)) {
-    for (let e = 0; e < n.length; e++) {
-      const t = n[e];
-      t.call(t);
-    }
-  } else {
-    n.call(n);
-  }
-  t ? e.be = null : e.me = null;
-}
-let externalSourceConfig = null;
-GlobalQueue.K = recompute;
-GlobalQueue.Y = disposeChildren;
+GlobalQueue.oe = recompute;
+GlobalQueue.ue = disposeChildren;
 let tracking = false;
 let stale = false;
 let context = null;
 let currentOptimisticLane = null;
 function recompute(e, t = false) {
-  const n = e.se;
+  const n = e.W;
   if (!t) {
-    if (e.ne && (!n || activeTransition) && activeTransition !== e.ne) globalQueue.initTransition(e.ne);
+    if (e.K && (!n || activeTransition) && activeTransition !== e.K) globalQueue.initTransition(e.K);
     deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (e.ne || n === EFFECT_TRACKED) disposeChildren(e);else {
+    if (e.K || n === EFFECT_TRACKED) disposeChildren(e);else {
       markDisposal(e);
-      e.be = e.me;
-      e.ve = e.De;
-      e.me = null;
-      e.De = null;
-      e.we = 0;
+      e.we = e.be;
+      e.me = e.Ce;
+      e.be = null;
+      e.Ce = null;
+      e.ve = 0;
     }
   }
   const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
-  const r = e.Te !== undefined && e.Te !== NOT_PENDING;
-  const o = !!(e.Ee & STATUS_PENDING);
-  const s = context;
+  const r = e.ee !== undefined && e.ee !== NOT_PENDING;
+  const s = !!(e.Se & STATUS_PENDING);
+  const o = context;
   context = e;
-  e.Ce = null;
+  e.ye = null;
   e.O = REACTIVE_RECOMPUTING_DEPS;
-  e.J = clock;
-  let u = e.le === NOT_PENDING ? e.fe : e.le;
+  e.Ee = clock;
+  let u = e.X === NOT_PENDING ? e.J : e.X;
   let c = e.o;
   let a = tracking;
-  let l = currentOptimisticLane;
+  let f = currentOptimisticLane;
   tracking = true;
   if (i) {
     const t = resolveLane(e);
@@ -846,60 +992,61 @@ function recompute(e, t = false) {
   }
   try {
     u = handleAsync(e, e.L(u));
-    clearStatus(e);
-    const t = resolveLane(e);
-    if (t) {
-      t.U.delete(e);
-      updatePendingSignal(t.de);
+    clearStatus(e, t);
+    const n = resolveLane(e);
+    if (n) {
+      n.k.delete(e);
+      updatePendingSignal(n.te);
     }
   } catch (t) {
     if (t instanceof NotReadyError && currentOptimisticLane) {
       const t = findLane(currentOptimisticLane);
-      if (t.de !== e) {
-        t.U.add(e);
-        e.ie = t;
-        updatePendingSignal(t.de);
+      if (t.te !== e) {
+        t.k.add(e);
+        e.q = t;
+        updatePendingSignal(t.te);
       }
     }
-    notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.ie : undefined);
+    if (t instanceof NotReadyError) e.he = true;
+    notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.q : undefined);
   } finally {
     tracking = a;
     e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
-    context = s;
+    context = o;
   }
-  if (!e.q) {
-    const s = e.Ce;
-    let a = s !== null ? s.D : e.C;
+  if (!e.le) {
+    const o = e.ye;
+    let a = o !== null ? o.D : e.C;
     if (a !== null) {
       do {
         a = unlinkSubs(a);
       } while (a !== null);
-      if (s !== null) s.D = null;else e.C = null;
+      if (o !== null) o.D = null;else e.C = null;
     }
-    const l = r ? e.Te : e.le === NOT_PENDING ? e.fe : e.le;
-    const f = !e.Ie || !e.Ie(l, u);
-    if (f) {
-      const s = r ? e.Te : undefined;
-      if (t || n && activeTransition !== e.ne || i) {
-        e.fe = u;
+    const f = r ? e.ee : e.X === NOT_PENDING ? e.J : e.X;
+    const l = !e.Ne || !e.Ne(f, u);
+    if (l) {
+      const o = r ? e.ee : undefined;
+      if (t || n && activeTransition !== e.K || i) {
+        e.J = u;
         if (r && i) {
-          e.Te = u;
-          e.le = u;
+          e.ee = u;
+          e.X = u;
         }
-      } else e.le = u;
-      if (r && !i && o && !e.Oe) e.Te = u;
-      if (!r || i || e.Te !== s) insertSubs(e, i || r);
+      } else e.X = u;
+      if (r && !i && s && !e._e) e.ee = u;
+      if (!r || i || e.ee !== o) insertSubs(e, i || r);
     } else if (r) {
-      e.le = u;
+      e.X = u;
     } else if (e.o != c) {
       for (let t = e.I; t !== null; t = t.p) {
         insertIntoHeapHeight(t.h, t.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
       }
     }
   }
-  currentOptimisticLane = l;
-  (!t || e.Ee & STATUS_PENDING) && !e.ne && !(activeTransition && r) && globalQueue.M.push(e);
-  e.ne && n && activeTransition !== e.ne && runInTransition(e.ne, () => recompute(e));
+  currentOptimisticLane = f;
+  (!t || e.Se & STATUS_PENDING) && !e.K && !(activeTransition && r) && globalQueue.se.push(e);
+  e.K && n && activeTransition !== e.K && runInTransition(e.K, () => recompute(e));
 }
 function updateIfNecessary(e) {
   if (e.O & REACTIVE_CHECK) {
@@ -914,7 +1061,7 @@ function updateIfNecessary(e) {
       }
     }
   }
-  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.q && e.J < clock && !e._e) {
+  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.le && e.Ee < clock && !e.Ae) {
     recompute(e);
   }
   e.O = REACTIVE_NONE | e.O & REACTIVE_SNAPSHOT_STALE;
@@ -924,47 +1071,47 @@ function computed(e, t, n) {
   const r = {
     id: n?.id ?? (context?.id ),
     Ve: i,
-    Ie: n?.equals != null ? n.equals : isEqual,
-    Ge: !!n?.pureWrite,
-    ge: n?.unobserved,
-    me: null,
-    ce: context?.ce ?? globalQueue,
+    Ne: n?.equals != null ? n.equals : isEqual,
+    fe: !!n?.pureWrite,
+    Ge: n?.unobserved,
+    be: null,
+    F: context?.F ?? globalQueue,
     Le: context?.Le ?? defaultContext,
-    we: 0,
+    ve: 0,
     L: e,
-    fe: t,
+    J: t,
     o: 0,
     A: null,
     S: undefined,
     T: null,
     C: null,
-    Ce: null,
+    ye: null,
     I: null,
-    Ne: null,
+    ke: null,
     i: context,
-    ye: null,
     De: null,
+    Ce: null,
     O: n?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-    Ee: STATUS_UNINITIALIZED,
-    J: clock,
-    le: NOT_PENDING,
-    be: null,
-    ve: null,
-    _e: null,
-    ne: null
+    Se: STATUS_UNINITIALIZED,
+    Ee: clock,
+    X: NOT_PENDING,
+    we: null,
+    me: null,
+    Ae: null,
+    K: null
   };
   r.T = r;
-  const o = context?.t ? context.u : context;
+  const s = context?.t ? context.u : context;
   if (context) {
-    const e = context.De;
+    const e = context.Ce;
     if (e === null) {
-      context.De = r;
+      context.Ce = r;
     } else {
-      r.ye = e;
-      context.De = r;
+      r.De = e;
+      context.Ce = r;
     }
   }
-  if (o) r.o = o.o + 1;
+  if (s) r.o = s.o + 1;
   !n?.lazy && recompute(r, true);
   return r;
 }
@@ -1006,41 +1153,45 @@ function read(e) {
       }
     }
   }
-  if (n.Ee & STATUS_PENDING) {
-    const i = n.q?.source;
-    if (i && !(i.Ee & STATUS_PENDING)) clearStatus(n);else if (t && true) {
+  if (n.Se & STATUS_PENDING) {
+    if (t && true) {
       if (currentOptimisticLane) {
-        const i = n.ie;
+        const i = n.q;
         const r = findLane(currentOptimisticLane);
         if (i && findLane(i) === r && !hasActiveOverride(n)) {
           if (!tracking && e !== t) link(e, t);
-          throw n.q;
+          throw n.le;
         }
       } else {
         if (!tracking && e !== t) link(e, t);
-        throw n.q;
+        throw n.le;
       }
-    } else if (!t && n.Ee & STATUS_UNINITIALIZED) {
-      throw n.q;
+    } else if (t && n !== e && n.Se & STATUS_UNINITIALIZED) {
+      if (!tracking && e !== t) link(e, t);
+      throw n.le;
+    } else if (!t && n.Se & STATUS_UNINITIALIZED) {
+      throw n.le;
     }
   }
-  if (e.L && e.Ee & STATUS_ERROR) {
-    if (e.J < clock) {
+  if (e.L && e.Se & STATUS_ERROR) {
+    if (e.Ee < clock) {
       recompute(e, true);
       return read(e);
-    } else throw e.q;
+    } else throw e.le;
+  }
+  if (e.ee !== undefined && e.ee !== NOT_PENDING) {
+    return e.ee;
   }
-  if (e.Te !== undefined && e.Te !== NOT_PENDING) return e.Te;
-  return !t || currentOptimisticLane !== null && (e.Te !== undefined || e.ie || n === e && stale || !!(n.Ee & STATUS_PENDING)) || e.le === NOT_PENDING || stale ? e.fe : e.le;
+  return !t || currentOptimisticLane !== null && (e.ee !== undefined || e.q || n === e && stale || !!(n.Se & STATUS_PENDING)) || e.X === NOT_PENDING || stale ? e.J : e.X;
 }
 function setSignal(e, t) {
-  if (e.ne && activeTransition !== e.ne) globalQueue.initTransition(e.ne);
-  const n = e.Te !== undefined && true;
-  const i = e.Te !== undefined && e.Te !== NOT_PENDING;
-  const r = n ? i ? e.Te : e.fe : e.le === NOT_PENDING ? e.fe : e.le;
+  if (e.K && activeTransition !== e.K) globalQueue.initTransition(e.K);
+  const n = e.ee !== undefined && true;
+  const i = e.ee !== undefined && e.ee !== NOT_PENDING;
+  const r = n ? i ? e.ee : e.J : e.X === NOT_PENDING ? e.J : e.X;
   if (typeof t === "function") t = t(r);
-  const o = !e.Ie || !e.Ie(r, t) || !!(e.Ee & STATUS_UNINITIALIZED);
-  if (!o) {
+  const s = !e.Ne || !e.Ne(r, t) || !!(e.Se & STATUS_UNINITIALIZED);
+  if (!s) {
     if (n && i && e.L) {
       insertSubs(e, true);
       schedule();
@@ -1048,57 +1199,64 @@ function setSignal(e, t) {
     return t;
   }
   if (n) {
-    const n = e.Te === NOT_PENDING;
-    if (!n && e.ne) globalQueue.initTransition(e.ne);
+    const n = e.ee === NOT_PENDING;
+    if (!n) globalQueue.initTransition(resolveTransition(e));
     if (n) {
-      e.le = e.fe;
-      globalQueue.$.push(e);
+      e.X = e.J;
+      globalQueue.Y.push(e);
     }
-    e.Oe = true;
+    e._e = true;
     const i = getOrCreateLane(e);
-    e.ie = i;
-    e.Te = t;
+    e.q = i;
+    e.ee = t;
   } else {
-    if (e.le === NOT_PENDING) globalQueue.M.push(e);
-    e.le = t;
+    if (e.X === NOT_PENDING) globalQueue.se.push(e);
+    e.X = t;
   }
   updatePendingSignal(e);
-  if (e.pe) {
-    setSignal(e.pe, t);
+  if (e.Pe) {
+    setSignal(e.Pe, t);
   }
-  e.J = clock;
+  e.Ee = clock;
   insertSubs(e, n);
   schedule();
   return t;
 }
 function computePendingState(e) {
   const t = e;
-  if (e.Te !== undefined && e.Te !== NOT_PENDING) {
-    if (t.Ee & STATUS_PENDING && !(t.Ee & STATUS_UNINITIALIZED)) return true;
-    if (e.Se) {
-      const t = e.ie ? findLane(e.ie) : null;
-      return !!(t && t.U.size > 0);
+  const n = e.V;
+  if (n && e.X !== NOT_PENDING) {
+    return !n.Ae && !(n.Se & STATUS_PENDING);
+  }
+  if (e.ee !== undefined && e.ee !== NOT_PENDING) {
+    if (t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
+    if (e.Re) {
+      const t = e.q ? findLane(e.q) : null;
+      return !!(t && t.k.size > 0);
     }
     return true;
   }
-  if (e.le !== NOT_PENDING && !(t.Ee & STATUS_UNINITIALIZED)) return true;
-  return !!(t.Ee & STATUS_PENDING && !(t.Ee & STATUS_UNINITIALIZED));
+  if (e.ee !== undefined && e.ee === NOT_PENDING && !e.Re) {
+    return false;
+  }
+  if (e.X !== NOT_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
+  return !!(t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED));
 }
 function updatePendingSignal(e) {
-  if (e.Fe) {
+  if (e.Qe) {
     const t = computePendingState(e);
-    const n = e.Fe;
+    const n = e.Qe;
     setSignal(n, t);
-    if (!t && n.ie) {
+    if (!t && n.q) {
       const t = resolveLane(e);
-      if (t && t.U.size > 0) {
-        const e = findLane(n.ie);
+      if (t && t.k.size > 0) {
+        const e = findLane(n.q);
         if (e !== t) {
           mergeLanes(t, e);
         }
       }
       signalLanes.delete(n);
-      n.ie = undefined;
+      n.q = undefined;
     }
   }
 }
@@ -1120,8 +1278,8 @@ function updatePath(e, t, n = 0) {
     r = e;
   if (n < t.length - 1) {
     i = t[n];
-    const o = typeof i;
-    const s = Array.isArray(e);
+    const s = typeof i;
+    const o = Array.isArray(e);
     if (Array.isArray(i)) {
       for (let r = 0; r < i.length; r++) {
         t[n] = i[r];
@@ -1129,7 +1287,7 @@ function updatePath(e, t, n = 0) {
       }
       t[n] = i;
       return;
-    } else if (s && o === "function") {
+    } else if (o && s === "function") {
       for (let r = 0; r < e.length; r++) {
         if (i(e[r], r)) {
           t[n] = r;
@@ -1138,13 +1296,13 @@ function updatePath(e, t, n = 0) {
       }
       t[n] = i;
       return;
-    } else if (s && o === "object") {
+    } else if (o && s === "object") {
       const {
         from: r = 0,
-        to: o = e.length - 1,
-        by: s = 1
+        to: s = e.length - 1,
+        by: o = 1
       } = i;
-      for (let i = r; i <= o; i += s) {
+      for (let i = r; i <= s; i += o) {
         t[n] = i;
         updatePath(e, t, n);
       }
@@ -1156,20 +1314,20 @@ function updatePath(e, t, n = 0) {
     }
     r = e[i];
   }
-  let o = t[t.length - 1];
-  if (typeof o === "function") {
-    o = o(r);
-    if (o === r) return;
+  let s = t[t.length - 1];
+  if (typeof s === "function") {
+    s = s(r);
+    if (s === r) return;
   }
-  if (i === undefined && o == undefined) return;
-  if (o === DELETE) {
+  if (i === undefined && s == undefined) return;
+  if (s === DELETE) {
     delete e[i];
-  } else if (i === undefined || isWrappable(r) && isWrappable(o) && !Array.isArray(o)) {
+  } else if (i === undefined || isWrappable(r) && isWrappable(s) && !Array.isArray(s)) {
     const t = i !== undefined ? e[i] : e;
-    const n = Object.keys(o);
-    for (let e = 0; e < n.length; e++) t[n[e]] = o[n[e]];
+    const n = Object.keys(s);
+    for (let e = 0; e < n.length; e++) t[n[e]] = s[n[e]];
   } else {
-    e[i] = o;
+    e[i] = s;
   }
 }
 Object.assign(function storePath(...e) {