@solidjs/signals 0.7.2 → 0.7.3

package/dist/node.cjs

@@ -63,13 +63,13 @@ var pureQueue = [];
 var Queue = class {
   k = null;
   C = false;
-  f = [[], []];
-  g = [];
+  g = [[], []];
+  h = [];
   created = clock;
   enqueue(type, fn) {
     pureQueue.push(fn);
     if (type)
-      this.f[type - 1].push(fn);
+      this.g[type - 1].push(fn);
     schedule();
   }
   run(type) {
@@ -77,13 +77,13 @@ var Queue = class {
       pureQueue.length && runQueue(pureQueue, type);
       pureQueue = [];
       return;
-    } else if (this.f[type - 1].length) {
-      const effects = this.f[type - 1];
-      this.f[type - 1] = [];
+    } else if (this.g[type - 1].length) {
+      const effects = this.g[type - 1];
+      this.g[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.g.length; i++) {
-      this.g[i].run(type);
+    for (let i = 0; i < this.h.length; i++) {
+      this.h[i].run(type);
     }
   }
   flush() {
@@ -104,15 +104,15 @@ var Queue = class {
   addChild(child) {
     if (ActiveTransition && ActiveTransition.J.has(this))
       return ActiveTransition.J.get(this).addChild(child);
-    this.g.push(child);
+    this.h.push(child);
     child.k = this;
   }
   removeChild(child) {
     if (ActiveTransition && ActiveTransition.J.has(this))
       return ActiveTransition.J.get(this).removeChild(child);
-    const index = this.g.indexOf(child);
+    const index = this.h.indexOf(child);
     if (index >= 0) {
-      this.g.splice(index, 1);
+      this.h.splice(index, 1);
       child.k = null;
     }
   }
@@ -122,14 +122,14 @@ var Queue = class {
     return false;
   }
   merge(queue) {
-    this.f[0].push.apply(this.f[0], queue.f[0]);
-    this.f[1].push.apply(this.f[1], queue.f[1]);
-    for (let i = 0; i < queue.g.length; i++) {
-      const og = this.g.find((c) => c.d === queue.g[i].d);
+    this.g[0].push.apply(this.g[0], queue.g[0]);
+    this.g[1].push.apply(this.g[1], queue.g[1]);
+    for (let i = 0; i < queue.h.length; i++) {
+      const og = this.h.find((c) => c.d === queue.h[i].d);
       if (og)
-        og.merge(queue.g[i]);
+        og.merge(queue.h[i]);
       else
-        this.addChild(queue.g[i]);
+        this.addChild(queue.h[i]);
     }
   }
 };
@@ -162,12 +162,12 @@ var Transition = class _Transition {
   a = /* @__PURE__ */ new Map();
   t = /* @__PURE__ */ new Set();
   K = /* @__PURE__ */ new Set();
-  r = /* @__PURE__ */ new Set();
+  m = /* @__PURE__ */ new Set();
   D = false;
-  f = [[], []];
+  g = [[], []];
   J = /* @__PURE__ */ new Map();
   G = [];
-  g = [];
+  h = [];
   k = null;
   C = false;
   Y = false;
@@ -175,14 +175,14 @@ var Transition = class _Transition {
   created = clock;
   constructor() {
     this.J.set(globalQueue, this);
-    for (const child of globalQueue.g) {
+    for (const child of globalQueue.h) {
       cloneQueue(child, this, this);
     }
   }
   enqueue(type, fn) {
     this.G.push(fn);
     if (type)
-      this.f[type - 1].push(fn);
+      this.g[type - 1].push(fn);
     this.schedule();
   }
   run(type) {
@@ -190,13 +190,13 @@ var Transition = class _Transition {
       this.G.length && runQueue(this.G, type);
       this.G = [];
       return;
-    } else if (this.f[type - 1].length) {
-      const effects = this.f[type - 1];
-      this.f[type - 1] = [];
+    } else if (this.g[type - 1].length) {
+      const effects = this.g[type - 1];
+      this.g[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.g.length; i++) {
-      this.g[i].run(type);
+    for (let i = 0; i < this.h.length; i++) {
+      this.h[i].run(type);
     }
   }
   flush() {
@@ -217,13 +217,13 @@ var Transition = class _Transition {
     }
   }
   addChild(child) {
-    this.g.push(child);
+    this.h.push(child);
     child.k = this;
   }
   removeChild(child) {
-    const index = this.g.indexOf(child);
+    const index = this.h.indexOf(child);
     if (index >= 0)
-      this.g.splice(index, 1);
+      this.h.splice(index, 1);
   }
   notify(node, type, flags) {
     if (!(type & LOADING_BIT))
@@ -236,18 +236,18 @@ var Transition = class _Transition {
     return true;
   }
   merge(queue) {
-    this.f[0].push.apply(this.f[0], queue.f[0]);
-    this.f[1].push.apply(this.f[1], queue.f[1]);
+    this.g[0].push.apply(this.g[0], queue.g[0]);
+    this.g[1].push.apply(this.g[1], queue.g[1]);
     this.G.push.apply(this.G, queue.G);
-    queue.f[0].length = 0;
-    queue.f[1].length = 0;
+    queue.g[0].length = 0;
+    queue.g[1].length = 0;
     queue.G.length = 0;
-    for (let i = 0; i < queue.g.length; i++) {
-      const og = this.g.find((c) => c.d === queue.g[i].d);
+    for (let i = 0; i < queue.h.length; i++) {
+      const og = this.h.find((c) => c.d === queue.h[i].d);
       if (og)
-        og.merge(queue.g[i]);
+        og.merge(queue.h[i]);
       else
-        this.addChild(queue.g[i]);
+        this.addChild(queue.h[i]);
     }
   }
   schedule() {
@@ -313,7 +313,7 @@ var Transition = class _Transition {
       return;
     }
     fn.j = this;
-    this.r.add(fn);
+    this.m.add(fn);
   }
 };
 function transition(fn) {
@@ -321,8 +321,10 @@ function transition(fn) {
   queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
 function cloneGraph(node) {
-  if (node.r)
+  if (node.m) {
+    ActiveTransition.addOptimistic(node.m);
     return node;
+  }
   if (node.j) {
     if (node.j !== ActiveTransition) {
       mergeTransitions(node.j, ActiveTransition);
@@ -332,8 +334,8 @@ function cloneGraph(node) {
   }
   const clone = Object.create(Object.getPrototypeOf(node));
   Object.assign(clone, node, {
+    o: null,
     n: null,
-    m: null,
     c: null,
     a: node.a ? [...node.a] : null,
     d: node
@@ -376,7 +378,7 @@ function cloneQueue(queue, parent, transition2) {
   Object.assign(clone, queue, {
     d: queue,
     k: parent,
-    g: [],
+    h: [],
     enqueue(type, fn) {
       transition2 = latestTransition(transition2);
       transition2.enqueue(type, fn);
@@ -393,9 +395,9 @@ function cloneQueue(queue, parent, transition2) {
       return queue.notify.call(this, node, type, flags);
     }
   });
-  parent.g.push(clone);
+  parent.h.push(clone);
   transition2.J.set(queue, clone);
-  for (const child of queue.g) {
+  for (const child of queue.h) {
     cloneQueue(child, clone, transition2);
   }
 }
@@ -403,11 +405,11 @@ function resolveQueues(children) {
   for (const child of children) {
     const og = child.d;
     if (og) {
-      const clonedChildren = child.g;
+      const clonedChildren = child.h;
       delete child.enqueue;
       delete child.notify;
       delete child.k;
-      delete child.g;
+      delete child.h;
       Object.assign(og, child);
       delete og.d;
       resolveQueues(clonedChildren);
@@ -421,9 +423,9 @@ function mergeTransitions(t1, t2) {
     key.j = t1;
     t1.a.set(key, value);
   });
-  t2.r.forEach((c) => {
+  t2.m.forEach((c) => {
     c.j = t1;
-    t1.r.add(c);
+    t1.m.add(c);
   });
   t2.K.forEach((p) => t1.K.add(p));
   t2.t.forEach((n) => t1.t.add(n));
@@ -439,21 +441,21 @@ function getQueue(node) {
   return transition2 && transition2.J.get(node.E) || node.E;
 }
 function initialDispose(node) {
-  let current = node.m;
+  let current = node.n;
   while (current !== null && current.k === node) {
     initialDispose(current);
     const clone = ActiveTransition.a.get(current);
     if (clone && !clone.Z)
       clone.dispose(true);
-    current = current.m;
+    current = current.n;
   }
 }
 function finishTransition(transition2) {
   if (transition2.D || transition2.Y || transition2.K.size || transition2.t.size)
     return;
-  globalQueue.f[0].push.apply(globalQueue.f[0], transition2.f[0]);
-  globalQueue.f[1].push.apply(globalQueue.f[1], transition2.f[1]);
-  resolveQueues(transition2.g);
+  globalQueue.g[0].push.apply(globalQueue.g[0], transition2.g[0]);
+  globalQueue.g[1].push.apply(globalQueue.g[1], transition2.g[1]);
+  resolveQueues(transition2.h);
   for (const [source, clone] of transition2.a) {
     if (source === clone || source.j !== transition2) {
       delete source.j;
@@ -466,22 +468,22 @@ function finishTransition(transition2) {
       source.emptyDisposal();
       delete clone.Z;
     } else {
-      delete clone.m;
       delete clone.n;
+      delete clone.o;
     }
     Object.assign(source, clone);
     delete source.d;
-    let current = clone.m;
+    let current = clone.n;
     if ((current == null ? void 0 : current.z) === clone)
       current.z = source;
     while ((current == null ? void 0 : current.k) === clone) {
       current.k = source;
-      current = current.m;
+      current = current.n;
     }
     delete source.j;
   }
   transition2.D = true;
-  for (const reset of transition2.r) {
+  for (const reset of transition2.m) {
     delete reset.j;
     reset();
   }
@@ -504,10 +506,10 @@ var Owner = class {
   // However, the children are actually added in reverse creation order
   // See comment at the top of the file for an example of the _nextSibling traversal
   k = null;
-  m = null;
+  n = null;
   z = null;
   b = STATE_CLEAN;
-  n = null;
+  o = null;
   A = defaultContext;
   E = globalQueue;
   fa = 0;
@@ -521,10 +523,10 @@ var Owner = class {
   append(child) {
     child.k = this;
     child.z = this;
-    if (this.m)
-      this.m.z = child;
-    child.m = this.m;
-    this.m = child;
+    if (this.n)
+      this.n.z = child;
+    child.n = this.n;
+    this.n = child;
     if (this.id != null && child.id == null)
       child.id = this.getNextChildId();
     if (child.A !== this.A) {
@@ -536,11 +538,11 @@ var Owner = class {
   dispose(self = true) {
     if (this.b === STATE_DISPOSED)
       return;
-    let head = self ? this.z || this.k : this, current = this.m, next = null;
+    let head = self ? this.z || this.k : this, current = this.n, next = null;
     while (current && current.k === this) {
       current.dispose(true);
-      next = current.m;
-      current.m = null;
+      next = current.n;
+      current.n = null;
       current = next;
     }
     this.fa = 0;
@@ -549,11 +551,11 @@ var Owner = class {
     if (current)
       current.z = !self ? this : this.z;
     if (head)
-      head.m = current;
+      head.n = current;
   }
   M() {
     if (this.z)
-      this.z.m = null;
+      this.z.n = null;
     this.k = null;
     this.z = null;
     this.A = defaultContext;
@@ -561,17 +563,17 @@ var Owner = class {
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.n)
+    if (!this.o)
       return;
-    if (Array.isArray(this.n)) {
-      for (let i = 0; i < this.n.length; i++) {
-        const callable = this.n[i];
+    if (Array.isArray(this.o)) {
+      for (let i = 0; i < this.o.length; i++) {
+        const callable = this.o[i];
         callable.call(callable);
       }
     } else {
-      this.n.call(this.n);
+      this.o.call(this.o);
     }
-    this.n = null;
+    this.o = null;
   }
   getNextChildId() {
     if (this.id != null)
@@ -608,12 +610,12 @@ function onCleanup(fn) {
   if (!currentOwner)
     return fn;
   const node = currentOwner;
-  if (!node.n) {
-    node.n = fn;
-  } else if (Array.isArray(node.n)) {
-    node.n.push(fn);
+  if (!node.o) {
+    node.o = fn;
+  } else if (Array.isArray(node.o)) {
+    node.o.push(fn);
   } else {
-    node.n = [node.n, fn];
+    node.o = [node.o, fn];
   }
   return fn;
 }
@@ -652,19 +654,19 @@ var Computation = class extends Owner {
   ea;
   ha = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  h = 0;
+  f = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   ba = DEFAULT_FLAGS;
   Q = -1;
   H = false;
   j;
   d;
-  r = false;
+  m;
   constructor(initialValue, compute2, options) {
     super(options == null ? void 0 : options.id, compute2 === null);
     this.P = compute2;
     this.b = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.h = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.f = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this.l = initialValue;
     if ((options == null ? void 0 : options.equals) !== void 0)
       this.aa = options.equals;
@@ -677,8 +679,8 @@ var Computation = class extends Owner {
   }
   ga() {
     track(this);
-    newFlags |= this.h & ~currentMask;
-    if (this.h & ERROR_BIT) {
+    newFlags |= this.f & ~currentMask;
+    if (this.f & ERROR_BIT) {
       throw this.O;
     } else {
       return this.l;
@@ -689,13 +691,13 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.f & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
     }
     if (this.P) {
-      if (this.h & ERROR_BIT && this.Q <= clock)
+      if (this.f & ERROR_BIT && this.Q <= clock)
         update(this);
       else
         this.F();
@@ -710,22 +712,22 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.h & (UNINITIALIZED_BIT | ERROR_BIT))) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.d && this.f & (UNINITIALIZED_BIT | ERROR_BIT))) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.wait();
     }
     if (this.P) {
-      if (this.h & ERROR_BIT && this.Q <= clock)
+      if (this.f & ERROR_BIT && this.Q <= clock)
         update(this);
       else
         this.F();
     }
-    if ((notStale || this.h & UNINITIALIZED_BIT) && this.h & LOADING_BIT) {
+    if ((notStale || this.f & UNINITIALIZED_BIT) && this.f & LOADING_BIT) {
       track(this);
       throw new NotReadyError();
     }
-    if (staleCheck && this.h & LOADING_BIT) {
+    if (staleCheck && this.f & LOADING_BIT) {
       staleCheck.l = true;
     }
     return this.ga();
@@ -738,16 +740,16 @@ var Computation = class extends Owner {
         return clone.write(value, flags, raw);
     }
     const newValue = !raw && typeof value === "function" ? value(this.l) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.h & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
     this.aa === false || !this.aa(this.l, newValue));
     if (valueChanged) {
       this.l = newValue;
       this.O = void 0;
     }
-    const changedFlagsMask = this.h ^ flags, changedFlags = changedFlagsMask & flags;
-    this.h = flags;
+    const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
+    this.f = flags;
     this.Q = clock + 1;
-    if (this.c && !(this.r && ActiveTransition)) {
+    if (this.c && !(this.m && ActiveTransition)) {
       for (let i = 0; i < this.c.length; i++) {
         if (valueChanged) {
           this.c[i].u(STATE_DIRTY);
@@ -766,7 +768,7 @@ var Computation = class extends Owner {
       return;
     this.H = !!skipQueue;
     this.b = state;
-    if (this.c && !(this.r && ActiveTransition)) {
+    if (this.c && !(this.m && ActiveTransition)) {
       for (let i = 0; i < this.c.length; i++) {
         this.c[i].u(STATE_CHECK, skipQueue);
       }
@@ -781,18 +783,18 @@ var Computation = class extends Owner {
   _(mask, newFlags2) {
     if (this.b >= STATE_DIRTY)
       return;
-    if (mask & this.ba || this.r && ActiveTransition) {
+    if (mask & this.ba || this.m && ActiveTransition) {
       this.u(STATE_DIRTY);
       return;
     }
     if (this.b >= STATE_CHECK && !this.H)
       return;
-    const prevFlags = this.h & mask;
+    const prevFlags = this.f & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
       this.u(STATE_CHECK);
     } else {
-      this.h ^= deltaFlags;
+      this.f ^= deltaFlags;
       if (this.c) {
         for (let i = 0; i < this.c.length; i++) {
           this.c[i]._(mask, newFlags2);
@@ -807,7 +809,7 @@ var Computation = class extends Owner {
         return clone.N(error);
     }
     this.O = error;
-    this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+    this.write(UNCHANGED, this.f & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -831,7 +833,7 @@ var Computation = class extends Owner {
       for (let i = 0; i < this.a.length; i++) {
         const source = getTransitionSource(this.a[i]);
         source.F();
-        observerFlags |= source.h & ~UNINITIALIZED_BIT;
+        observerFlags |= source.f & ~UNINITIALIZED_BIT;
         if (this.b === STATE_DIRTY) {
           break;
         }
@@ -887,7 +889,7 @@ function update(node) {
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.h & UNINITIALIZED_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.f & UNINITIALIZED_BIT);
     } else {
       node.N(error);
     }
@@ -961,7 +963,7 @@ function isPending(fn, loadingValue) {
     return pendingCheck(fn, loadingValue);
   const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
   c.ba |= LOADING_BIT;
-  return c.read();
+  return c.wait();
 }
 function latest(fn, fallback) {
   const argLength = arguments.length;
@@ -1010,7 +1012,7 @@ var Effect = class extends Computation {
     this.s = (options == null ? void 0 : options.render) ? EFFECT_RENDER : EFFECT_USER;
     if (this.s === EFFECT_RENDER) {
       this.P = function(p) {
-        return !this.d && clock > this.E.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+        return !this.d && clock > this.E.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
     this.F();
@@ -1018,9 +1020,9 @@ var Effect = class extends Computation {
   }
   write(value, flags = 0) {
     if (this.b == STATE_DIRTY) {
-      this.h = flags;
+      this.f = flags;
       if (this.s === EFFECT_RENDER) {
-        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
+        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.f);
       }
     }
     if (value === UNCHANGED)
@@ -1051,7 +1053,7 @@ var Effect = class extends Computation {
   N(error) {
     this.O = error;
     getQueue(this).notify(this, LOADING_BIT, 0);
-    this.h = ERROR_BIT;
+    this.f = ERROR_BIT;
     if (this.s === EFFECT_USER) {
       try {
         return this.$ ? this.$(error, () => {
@@ -1161,10 +1163,13 @@ var FirewallComputation = class extends Computation {
     this.H = !!skipQueue;
   }
   x() {
-    const prevFlags = this.h;
+    const prevFlags = this.f;
     this.b !== STATE_CLEAN && runTop(this);
-    if (ActiveTransition && this.r && this.h !== prevFlags)
-      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
+    if (ActiveTransition && this.m && (this.f !== prevFlags || this.f !== this.m.flags)) {
+      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.f);
+      this.m.flags = this.f;
+      this.f = prevFlags;
+    }
   }
 };
 function runTop(node) {
@@ -1215,7 +1220,7 @@ function createMemo(compute2, value, options) {
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!((_a = node.a) == null ? void 0 : _a.length) && ((_b = node.m) == null ? void 0 : _b.k) !== node && !(node.h & UNINITIALIZED_BIT)) {
+      if (!((_a = node.a) == null ? void 0 : _a.length) && ((_b = node.n) == null ? void 0 : _b.k) !== node && !(node.f & UNINITIALIZED_BIT)) {
         node.dispose();
         node = void 0;
       }
@@ -1363,18 +1368,17 @@ function resolve(fn) {
 function createOptimistic(first, second, third) {
   const node = typeof first === "function" ? new Computation(second, (prev) => {
     const res = first(prev);
-    if (reset.j)
+    if (node.m.j)
       return prev;
     return res;
   }, third) : new Computation(first, null, second);
-  node.r = true;
-  const reset = () => node.write(first);
+  node.m = () => node.write(first);
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
-    ActiveTransition.addOptimistic(reset);
+    ActiveTransition.addOptimistic(node.m);
     queueMicrotask(() => {
-      if (reset.j) {
+      if (node.m.j) {
         node.F();
         node.write(v);
       }
@@ -1865,7 +1869,6 @@ function createOptimisticStore(first, second, options) {
     return res;
   }, second, options) : createProjectionInternal(() => {
   }, first);
-  node.r = true;
   const reset = () => storeSetter(
     store,
     reconcile(
@@ -1880,6 +1883,7 @@ function createOptimisticStore(first, second, options) {
     ActiveTransition.addOptimistic(reset);
     queueMicrotask(() => reset.j && storeSetter(store, v));
   };
+  node.m = reset;
   return [store, write];
 }
 
@@ -2089,15 +2093,15 @@ function mapArray(list, map, options) {
   const keyFn = typeof (options == null ? void 0 : options.keyed) === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
     U: new Owner(),
-    o: 0,
+    p: 0,
     ia: list,
     I: [],
     R: map,
     i: [],
     e: [],
     S: keyFn,
-    p: keyFn || (options == null ? void 0 : options.keyed) === false ? [] : void 0,
-    q: map.length > 1 ? [] : void 0,
+    q: keyFn || (options == null ? void 0 : options.keyed) === false ? [] : void 0,
+    r: map.length > 1 ? [] : void 0,
     V: options == null ? void 0 : options.fallback
   });
 }
@@ -2106,30 +2110,30 @@ function updateKeyedMap() {
   const newItems = this.ia() || [], newLen = newItems.length;
   newItems[$TRACK];
   runWithOwner(this.U, () => {
-    let i, j, mapper = this.p ? () => {
-      this.p[j] = new Computation(newItems[j], null, pureOptions);
-      this.q && (this.q[j] = new Computation(j, null, pureOptions));
+    let i, j, mapper = this.q ? () => {
+      this.q[j] = new Computation(newItems[j], null, pureOptions);
+      this.r && (this.r[j] = new Computation(j, null, pureOptions));
       return this.R(
-        Computation.prototype.read.bind(this.p[j]),
-        this.q ? Computation.prototype.read.bind(this.q[j]) : void 0
+        Computation.prototype.read.bind(this.q[j]),
+        this.r ? Computation.prototype.read.bind(this.r[j]) : void 0
       );
-    } : this.q ? () => {
+    } : this.r ? () => {
       const item = newItems[j];
-      this.q[j] = new Computation(j, null, pureOptions);
-      return this.R(() => item, Computation.prototype.read.bind(this.q[j]));
+      this.r[j] = new Computation(j, null, pureOptions);
+      return this.R(() => item, Computation.prototype.read.bind(this.r[j]));
     } : () => {
       const item = newItems[j];
       return this.R(() => item);
     };
     if (newLen === 0) {
-      if (this.o !== 0) {
+      if (this.p !== 0) {
         this.U.dispose(false);
         this.e = [];
         this.I = [];
         this.i = [];
-        this.o = 0;
-        this.p && (this.p = []);
+        this.p = 0;
         this.q && (this.q = []);
+        this.r && (this.r = []);
       }
       if (this.V && !this.i[0]) {
         this.i[0] = compute(
@@ -2138,7 +2142,7 @@ function updateKeyedMap() {
           null
         );
       }
-    } else if (this.o === 0) {
+    } else if (this.p === 0) {
       if (this.e[0])
         this.e[0].dispose();
       this.i = new Array(newLen);
@@ -2146,18 +2150,18 @@ function updateKeyedMap() {
         this.I[j] = newItems[j];
         this.i[j] = compute(this.e[j] = new Owner(), mapper, null);
       }
-      this.o = newLen;
+      this.p = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.p ? new Array(newLen) : void 0, tempIndexes = this.q ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.o, newLen); start < end && (this.I[start] === newItems[start] || this.p && compare(this.S, this.I[start], newItems[start])); start++) {
-        if (this.p)
-          this.p[start].write(newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.q ? new Array(newLen) : void 0, tempIndexes = this.r ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.p, newLen); start < end && (this.I[start] === newItems[start] || this.q && compare(this.S, this.I[start], newItems[start])); start++) {
+        if (this.q)
+          this.q[start].write(newItems[start]);
       }
-      for (end = this.o - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.I[end] === newItems[newEnd] || this.p && compare(this.S, this.I[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.p - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.I[end] === newItems[newEnd] || this.q && compare(this.S, this.I[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.i[end];
         tempNodes[newEnd] = this.e[end];
-        tempRows && (tempRows[newEnd] = this.p[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.q[end]);
+        tempRows && (tempRows[newEnd] = this.q[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.r[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
@@ -2175,8 +2179,8 @@ function updateKeyedMap() {
         if (j !== void 0 && j !== -1) {
           temp[j] = this.i[i];
           tempNodes[j] = this.e[i];
-          tempRows && (tempRows[j] = this.p[i]);
-          tempIndexes && (tempIndexes[j] = this.q[i]);
+          tempRows && (tempRows[j] = this.q[i]);
+          tempIndexes && (tempIndexes[j] = this.r[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -2187,18 +2191,18 @@ function updateKeyedMap() {
           this.i[j] = temp[j];
           this.e[j] = tempNodes[j];
           if (tempRows) {
-            this.p[j] = tempRows[j];
-            this.p[j].write(newItems[j]);
+            this.q[j] = tempRows[j];
+            this.q[j].write(newItems[j]);
           }
           if (tempIndexes) {
-            this.q[j] = tempIndexes[j];
-            this.q[j].write(j);
+            this.r[j] = tempIndexes[j];
+            this.r[j].write(j);
           }
         } else {
           this.i[j] = compute(this.e[j] = new Owner(), mapper, null);
         }
       }
-      this.i = this.i.slice(0, this.o = newLen);
+      this.i = this.i.slice(0, this.p = newLen);
       this.I = newItems.slice(0);
     }
   });
@@ -2207,7 +2211,7 @@ function updateKeyedMap() {
 function repeat(count, map, options) {
   return updateRepeat.bind({
     U: new Owner(),
-    o: 0,
+    p: 0,
     B: 0,
     ja: count,
     R: map,
@@ -2223,11 +2227,11 @@ function updateRepeat() {
   const from = ((_a = this.ka) == null ? void 0 : _a.call(this)) || 0;
   runWithOwner(this.U, () => {
     if (newLen === 0) {
-      if (this.o !== 0) {
+      if (this.p !== 0) {
         this.U.dispose(false);
         this.e = [];
         this.i = [];
-        this.o = 0;
+        this.p = 0;
       }
       if (this.V && !this.i[0]) {
         this.i[0] = compute(
@@ -2239,14 +2243,14 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.B + this.o;
-    if (this.o === 0 && this.e[0])
+    const prevTo = this.B + this.p;
+    if (this.p === 0 && this.e[0])
       this.e[0].dispose();
     for (let i = to; i < prevTo; i++)
       this.e[i - this.B].dispose();
     if (this.B < from) {
       let i = this.B;
-      while (i < from && i < this.o)
+      while (i < from && i < this.p)
         this.e[i++].dispose();
       this.e.splice(0, from - this.B);
       this.i.splice(0, from - this.B);
@@ -2276,7 +2280,7 @@ function updateRepeat() {
     }
     this.i = this.i.slice(0, newLen);
     this.B = from;
-    this.o = newLen;
+    this.p = newLen;
   });
   return this.i;
 }
@@ -2293,7 +2297,7 @@ var BoundaryComputation = class extends EagerComputation {
   }
   write(value, flags) {
     super.write(value, flags & ~this.W);
-    if (this.W & LOADING_BIT && !(this.h & UNINITIALIZED_BIT || ActiveTransition)) {
+    if (this.W & LOADING_BIT && !(this.f & UNINITIALIZED_BIT || ActiveTransition)) {
       flags &= ~LOADING_BIT;
     }
     getQueue(this).notify(this, this.W, flags);