@solidjs/signals 0.6.1 → 0.6.2

package/dist/prod.js

@@ -45,7 +45,7 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.B)
+  if (!globalQueue.A)
     queueMicrotask(flush);
 }
 function notifyUnobserved() {
@@ -59,13 +59,11 @@ function notifyUnobserved() {
 var pureQueue = [];
 var Queue = class {
   k = null;
-  B = false;
+  A = false;
   g = [[], []];
   f = [];
   created = clock;
   enqueue(type, fn) {
-    if (ActiveTransition && ActiveTransition.p.has(this))
-      return ActiveTransition.p.get(this).enqueue(type, fn);
     pureQueue.push(fn);
     if (type)
       this.g[type - 1].push(fn);
@@ -86,9 +84,9 @@ var Queue = class {
     }
   }
   flush() {
-    if (this.B)
+    if (this.A)
       return;
-    this.B = true;
+    this.A = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -96,19 +94,19 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.B = false;
+      this.A = false;
       Unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
-    if (ActiveTransition && ActiveTransition.p.has(this))
-      return ActiveTransition.p.get(this).addChild(child);
+    if (ActiveTransition && ActiveTransition.r.has(this))
+      return ActiveTransition.r.get(this).addChild(child);
     this.f.push(child);
     child.k = this;
   }
   removeChild(child) {
-    if (ActiveTransition && ActiveTransition.p.has(this))
-      return ActiveTransition.p.get(this).removeChild(child);
+    if (ActiveTransition && ActiveTransition.r.has(this))
+      return ActiveTransition.r.get(this).removeChild(child);
     const index = this.f.indexOf(child);
     if (index >= 0) {
       this.f.splice(index, 1);
@@ -116,8 +114,6 @@ var Queue = class {
     }
   }
   notify(...args) {
-    if (ActiveTransition && ActiveTransition.p.has(this))
-      return ActiveTransition.p.get(this).notify(...args);
     if (this.k)
       return this.k.notify(...args);
     return false;
@@ -161,35 +157,35 @@ function runQueue(queue, type) {
 }
 var Transition = class _Transition {
   a = /* @__PURE__ */ new Map();
-  t = /* @__PURE__ */ new Set();
-  G = /* @__PURE__ */ new Set();
+  s = /* @__PURE__ */ new Set();
+  H = /* @__PURE__ */ new Set();
   W = /* @__PURE__ */ new Set();
-  w = false;
+  u = false;
   g = [[], []];
-  p = /* @__PURE__ */ new Map();
-  H = [];
+  r = /* @__PURE__ */ new Map();
+  I = [];
   f = [];
   k = null;
-  B = false;
+  A = false;
   X = false;
   e = globalQueue;
   created = clock;
   constructor() {
-    this.p.set(globalQueue, this);
+    this.r.set(globalQueue, this);
     for (const child of globalQueue.f) {
-      cloneQueue(child, this, this.p);
+      cloneQueue(child, this, this.r);
     }
   }
   enqueue(type, fn) {
-    this.H.push(fn);
+    this.I.push(fn);
     if (type)
       this.g[type - 1].push(fn);
     this.schedule();
   }
   run(type) {
     if (type === EFFECT_PURE) {
-      this.H.length && runQueue(this.H, type);
-      this.H = [];
+      this.I.length && runQueue(this.I, type);
+      this.I = [];
       return;
     } else if (this.g[type - 1].length) {
       const effects = this.g[type - 1];
@@ -201,9 +197,9 @@ var Transition = class _Transition {
     }
   }
   flush() {
-    if (this.B)
+    if (this.A)
       return;
-    this.B = true;
+    this.A = true;
     let currentTransition = ActiveTransition;
     ActiveTransition = this;
     try {
@@ -213,7 +209,7 @@ var Transition = class _Transition {
       ActiveTransition = currentTransition;
       finishTransition(this);
     } finally {
-      this.B = false;
+      this.A = false;
       ActiveTransition = currentTransition;
     }
   }
@@ -230,16 +226,16 @@ var Transition = class _Transition {
     if (!(type & LOADING_BIT))
       return false;
     if (flags & LOADING_BIT) {
-      this.t.add(node);
+      this.s.add(node);
     } else {
-      this.t.delete(node);
+      this.s.delete(node);
     }
     return true;
   }
   merge(queue) {
     this.g[0].push.apply(this.g[0], queue.g[0]);
     this.g[1].push.apply(this.g[1], queue.g[1]);
-    this.H.push.apply(this.H, queue.H);
+    this.I.push.apply(this.I, queue.I);
     for (let i = 0; i < queue.f.length; i++) {
       const og = this.f.find((c) => c.e === queue.f[i].e);
       if (og)
@@ -252,13 +248,13 @@ var Transition = class _Transition {
     if (this.X)
       return;
     this.X = true;
-    if (!this.B)
+    if (!this.A)
       queueMicrotask(() => this.flush());
   }
   runTransition(fn, force = false) {
-    if (this.w) {
-      if (this.w instanceof _Transition)
-        return this.w.runTransition(fn, force);
+    if (this.u) {
+      if (this.u instanceof _Transition)
+        return this.u.runTransition(fn, force);
       if (!force)
         throw new Error("Transition already completed");
       fn();
@@ -273,27 +269,29 @@ var Transition = class _Transition {
           let temp, value;
           while (!(temp = result.next(value)).done) {
             if (temp.value instanceof Promise) {
-              transition2.G.add(temp.value);
+              transition2.H.add(temp.value);
               try {
                 value = await temp.value;
               } finally {
-                while (transition2.w instanceof _Transition)
-                  transition2 = transition2.w;
-                transition2.G.delete(temp.value);
+                while (transition2.u instanceof _Transition)
+                  transition2 = transition2.u;
+                transition2.H.delete(temp.value);
               }
               ActiveTransition = transition2;
             } else
               value = temp.value;
           }
+          ActiveTransition = null;
           finishTransition(transition2);
         })();
       }
       if (result instanceof Promise) {
-        transition2.G.add(result);
+        transition2.H.add(result);
         result.finally(() => {
-          while (transition2.w instanceof _Transition)
-            transition2 = transition2.w;
-          transition2.G.delete(result);
+          while (transition2.u instanceof _Transition)
+            transition2 = transition2.u;
+          transition2.H.delete(result);
+          ActiveTransition = null;
           finishTransition(transition2);
         });
       }
@@ -327,8 +325,8 @@ function cloneGraph(node) {
   }
   const clone = Object.create(Object.getPrototypeOf(node));
   Object.assign(clone, node, {
-    o: null,
     n: null,
+    m: null,
     b: null,
     a: node.a ? [...node.a] : null,
     e: node
@@ -370,7 +368,7 @@ function cloneQueue(queue, parent, clonedQueues) {
     },
     notify(node, type, flags) {
       node = node.e || node;
-      if (!clone.I || type & LOADING_BIT) {
+      if (!clone.J || type & LOADING_BIT) {
         type &= ~LOADING_BIT;
         ActiveTransition?.notify(node, LOADING_BIT, flags);
         if (!type)
@@ -411,26 +409,30 @@ function mergeTransitions(t1, t2) {
     c.j = t1;
     t1.W.add(c);
   });
-  t2.G.forEach((p) => t1.G.add(p));
-  t2.t.forEach((n) => t1.t.add(n));
+  t2.H.forEach((p) => t1.H.add(p));
+  t2.s.forEach((n) => t1.s.add(n));
   t1.merge(t2);
-  t2.w = t1;
+  t2.u = t1;
 }
 function getTransitionSource(input) {
   return ActiveTransition && ActiveTransition.a.get(input) || input;
 }
+function getQueue(node) {
+  const transition2 = node.e?.j;
+  return transition2 && transition2.r.get(node.B) || node.B;
+}
 function initialDispose(node) {
-  let current = node.n;
+  let current = node.m;
   while (current !== null && current.k === node) {
     initialDispose(current);
     const clone = ActiveTransition.a.get(current);
     if (clone && !clone.Y)
       clone.dispose(true);
-    current = current.n;
+    current = current.m;
   }
 }
 function finishTransition(transition2) {
-  if (transition2.w || transition2.X || transition2.G.size || transition2.t.size)
+  if (transition2.u || transition2.X || transition2.H.size || transition2.s.size)
     return;
   globalQueue.g[0].push.apply(globalQueue.g[0], transition2.g[0]);
   globalQueue.g[1].push.apply(globalQueue.g[1], transition2.g[1]);
@@ -447,21 +449,21 @@ function finishTransition(transition2) {
       source.emptyDisposal();
       delete clone.Y;
     } else {
+      delete clone.m;
       delete clone.n;
-      delete clone.o;
     }
     Object.assign(source, clone);
     delete source.e;
-    let current = clone.n;
-    if (current?.x === clone)
-      current.x = source;
+    let current = clone.m;
+    if (current?.w === clone)
+      current.w = source;
     while (current?.k === clone) {
       current.k = source;
-      current = current.n;
+      current = current.m;
     }
     delete source.j;
   }
-  transition2.w = true;
+  transition2.u = true;
   for (const reset of transition2.W) {
     delete reset.j;
     reset();
@@ -485,12 +487,12 @@ 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;
-  n = null;
-  x = null;
+  m = null;
+  w = null;
   c = STATE_CLEAN;
-  o = null;
-  y = defaultContext;
-  m = globalQueue;
+  n = null;
+  x = defaultContext;
+  B = globalQueue;
   fa = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
@@ -501,58 +503,58 @@ var Owner = class {
   }
   append(child) {
     child.k = this;
-    child.x = this;
-    if (this.n)
-      this.n.x = child;
-    child.n = this.n;
-    this.n = child;
+    child.w = this;
+    if (this.m)
+      this.m.w = child;
+    child.m = this.m;
+    this.m = child;
     if (this.id != null && child.id == null)
       child.id = this.getNextChildId();
-    if (child.y !== this.y) {
-      child.y = { ...this.y, ...child.y };
+    if (child.x !== this.x) {
+      child.x = { ...this.x, ...child.x };
     }
-    if (this.m)
-      child.m = this.m;
+    if (this.B)
+      child.B = this.B;
   }
   dispose(self = true) {
     if (this.c === STATE_DISPOSED)
       return;
-    let head = self ? this.x || this.k : this, current = this.n, next = null;
+    let head = self ? this.w || this.k : this, current = this.m, next = null;
     while (current && current.k === this) {
       current.dispose(true);
-      next = current.n;
-      current.n = null;
+      next = current.m;
+      current.m = null;
       current = next;
     }
     this.fa = 0;
     if (self)
       this.R();
     if (current)
-      current.x = !self ? this : this.x;
+      current.w = !self ? this : this.w;
     if (head)
-      head.n = current;
+      head.m = current;
   }
   R() {
-    if (this.x)
-      this.x.n = null;
+    if (this.w)
+      this.w.m = null;
     this.k = null;
-    this.x = null;
-    this.y = defaultContext;
+    this.w = null;
+    this.x = defaultContext;
     this.c = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.o)
+    if (!this.n)
       return;
-    if (Array.isArray(this.o)) {
-      for (let i = 0; i < this.o.length; i++) {
-        const callable = this.o[i];
+    if (Array.isArray(this.n)) {
+      for (let i = 0; i < this.n.length; i++) {
+        const callable = this.n[i];
         callable.call(callable);
       }
     } else {
-      this.o.call(this.o);
+      this.n.call(this.n);
     }
-    this.o = null;
+    this.n = null;
   }
   getNextChildId() {
     if (this.id != null)
@@ -567,7 +569,7 @@ function getContext(context, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner.y[context.id] : context.defaultValue;
+  const value = hasContext(context, owner) ? owner.x[context.id] : context.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -577,24 +579,24 @@ function setContext(context, value, owner = currentOwner) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.y = {
-    ...owner.y,
+  owner.x = {
+    ...owner.x,
     [context.id]: isUndefined(value) ? context.defaultValue : value
   };
 }
 function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.y[context.id]);
+  return !isUndefined(owner?.x[context.id]);
 }
 function onCleanup(fn) {
   if (!currentOwner)
     return fn;
   const node = currentOwner;
-  if (!node.o) {
-    node.o = fn;
-  } else if (Array.isArray(node.o)) {
-    node.o.push(fn);
+  if (!node.n) {
+    node.n = fn;
+  } else if (Array.isArray(node.n)) {
+    node.n.push(fn);
   } else {
-    node.o = [node.o, fn];
+    node.n = [node.n, fn];
   }
   return fn;
 }
@@ -637,7 +639,7 @@ var Computation = class extends Owner {
   /** Which flags raised by sources are handled, vs. being passed through. */
   ba = DEFAULT_FLAGS;
   N = -1;
-  J = false;
+  D = false;
   j;
   e;
   constructor(initialValue, compute2, options) {
@@ -732,7 +734,7 @@ var Computation = class extends Owner {
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
         if (valueChanged) {
-          this.b[i].z(STATE_DIRTY);
+          this.b[i].y(STATE_DIRTY);
         } else if (changedFlagsMask) {
           this.b[i].Z(changedFlagsMask, changedFlags);
         }
@@ -743,14 +745,14 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  z(state, skipQueue) {
-    if (this.c >= state && !this.J)
+  y(state, skipQueue) {
+    if (this.c >= state && !this.D)
       return;
-    this.J = !!skipQueue;
+    this.D = !!skipQueue;
     this.c = state;
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
-        this.b[i].z(STATE_CHECK, skipQueue);
+        this.b[i].y(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -764,15 +766,15 @@ var Computation = class extends Owner {
     if (this.c >= STATE_DIRTY)
       return;
     if (mask & this.ba) {
-      this.z(STATE_DIRTY);
+      this.y(STATE_DIRTY);
       return;
     }
-    if (this.c >= STATE_CHECK)
+    if (this.c >= STATE_CHECK && !this.D)
       return;
     const prevFlags = this.h & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.z(STATE_CHECK);
+      this.y(STATE_CHECK);
     } else {
       this.h ^= deltaFlags;
       if (this.b) {
@@ -782,11 +784,11 @@ var Computation = class extends Owner {
       }
     }
   }
-  D(error) {
+  E(error) {
     if (ActiveTransition && !this.e) {
       const clone = cloneGraph(this);
       if (clone !== this)
-        return clone.D(error);
+        return clone.E(error);
     }
     this.L = error;
     this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
@@ -871,7 +873,7 @@ function update(node) {
     if (error instanceof NotReadyError) {
       node.write(UNCHANGED, newFlags | LOADING_BIT | node.h & UNINITIALIZED_BIT);
     } else {
-      node.D(error);
+      node.E(error);
     }
   } finally {
     if (newSources) {
@@ -975,7 +977,7 @@ function runWithObserver(observer, run) {
         newFlags | LOADING_BIT | observer.h & UNINITIALIZED_BIT
       );
     } else {
-      observer.D(error);
+      observer.E(error);
     }
   } finally {
     if (newSources) {
@@ -1032,17 +1034,17 @@ var Effect = class extends Computation {
     this.C = options?.render ? EFFECT_RENDER : EFFECT_USER;
     if (this.C === EFFECT_RENDER) {
       this.M = function(p) {
-        return !this.e && clock > this.m.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+        return !this.e && clock > this.B.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
     this.K();
-    !options?.defer && (this.C === EFFECT_USER ? this.m.enqueue(this.C, this.E.bind(this)) : this.E(this.C));
+    !options?.defer && (this.C === EFFECT_USER ? getQueue(this).enqueue(this.C, this.F.bind(this)) : this.F(this.C));
   }
   write(value, flags = 0) {
     if (this.c == STATE_DIRTY) {
       this.h = flags;
       if (this.C === EFFECT_RENDER) {
-        this.m.notify(this, LOADING_BIT | ERROR_BIT, this.h);
+        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.h);
       }
     }
     if (value === UNCHANGED)
@@ -1052,11 +1054,11 @@ var Effect = class extends Computation {
     this.L = void 0;
     return value;
   }
-  z(state, skipQueue) {
+  y(state, skipQueue) {
     if (this.c >= state || skipQueue)
       return;
     if (this.c === STATE_CLEAN)
-      this.m.enqueue(this.C, this.E.bind(this));
+      getQueue(this).enqueue(this.C, this.F.bind(this));
     this.c = state;
   }
   Z(mask, newFlags2) {
@@ -1064,15 +1066,15 @@ var Effect = class extends Computation {
       if (this.c >= STATE_DIRTY)
         return;
       if (mask & 3) {
-        this.z(STATE_DIRTY);
+        this.y(STATE_DIRTY);
         return;
       }
     }
     super.Z(mask, newFlags2);
   }
-  D(error) {
+  E(error) {
     this.L = error;
-    this.m.notify(this, LOADING_BIT, 0);
+    getQueue(this).notify(this, LOADING_BIT, 0);
     this.h = ERROR_BIT;
     if (this.C === EFFECT_USER) {
       try {
@@ -1084,7 +1086,7 @@ var Effect = class extends Computation {
         error = e;
       }
     }
-    if (!this.m.notify(this, ERROR_BIT, ERROR_BIT))
+    if (!getQueue(this).notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
   R() {
@@ -1095,10 +1097,10 @@ var Effect = class extends Computation {
     this._ = void 0;
     this.O?.();
     this.O = void 0;
-    this.m.notify(this, ERROR_BIT | LOADING_BIT, 0);
+    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
     super.R();
   }
-  E(type) {
+  F(type) {
     if (type) {
       const effect = this.e || this;
       if (effect.da && effect.c !== STATE_DISPOSED) {
@@ -1106,7 +1108,7 @@ var Effect = class extends Computation {
         try {
           effect.O = effect.ca(effect.l, effect.$);
         } catch (e) {
-          if (!effect.m.notify(effect, ERROR_BIT, ERROR_BIT))
+          if (!getQueue(effect).notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
           effect.$ = effect.l;
@@ -1122,14 +1124,14 @@ var EagerComputation = class extends Computation {
     super(initialValue, compute2, options);
     !options?.defer && this.K();
   }
-  z(state, skipQueue) {
-    if (this.c >= state && !this.J)
+  y(state, skipQueue) {
+    if (this.c >= state && !this.D)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.J))
-      this.m.enqueue(EFFECT_PURE, this.E.bind(this));
-    super.z(state, skipQueue);
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.D))
+      getQueue(this).enqueue(EFFECT_PURE, this.F.bind(this));
+    super.y(state, skipQueue);
   }
-  E() {
+  F() {
     this.c !== STATE_CLEAN && runTop(this);
   }
 };
@@ -1138,15 +1140,15 @@ var FirewallComputation = class extends Computation {
   constructor(compute2) {
     super(void 0, compute2);
   }
-  z(state, skipQueue) {
-    if (this.c >= state && !this.J)
+  y(state, skipQueue) {
+    if (this.c >= state && !this.D)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.J))
-      this.m.enqueue(EFFECT_PURE, this.E.bind(this));
-    super.z(state, true);
-    this.J = !!skipQueue;
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.D))
+      getQueue(this).enqueue(EFFECT_PURE, this.F.bind(this));
+    super.y(state, true);
+    this.D = !!skipQueue;
   }
-  E() {
+  F() {
     this.c !== STATE_CLEAN && runTop(this);
   }
 };
@@ -1853,7 +1855,7 @@ function createMemo(compute2, value, options) {
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!node.a?.length && node.n?.k !== node && !(node.h & UNINITIALIZED_BIT)) {
+      if (!node.a?.length && node.m?.k !== node && !(node.h & UNINITIALIZED_BIT)) {
         node.dispose();
         node = void 0;
       }
@@ -1891,8 +1893,8 @@ function createAsync(compute2, value, options) {
             if (abort)
               return;
             if (transition2)
-              return transition2.runTransition(() => node.D(error), true);
-            node.D(error);
+              return transition2.runTransition(() => node.E(error), true);
+            node.E(error);
           }
         );
       } else {
@@ -1913,10 +1915,10 @@ function createAsync(compute2, value, options) {
               return;
             if (transition2)
               return transition2.runTransition(() => {
-                node.D(error);
+                node.E(error);
                 transition2 = null;
               }, true);
-            node.D(error);
+            node.E(error);
           }
         })();
       }
@@ -2011,11 +2013,11 @@ function createOptimistic(first, second, options) {
   } else
     [store, setStore] = createStore(first);
   const reset = () => setStore(
-    (s) => reconcile(
-      { value: typeof first === "function" ? first(second) : first },
+    reconcile(
+      typeof first === "function" ? first(second) : first,
       options?.key || "id",
       options?.all
-    )(s)
+    )
   );
   function write(v) {
     if (!ActiveTransition)
@@ -2031,15 +2033,15 @@ function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
     S: new Owner(),
-    q: 0,
+    o: 0,
     ia: list,
-    F: [],
+    G: [],
     P: map,
     i: [],
     d: [],
     Q: keyFn,
-    r: keyFn || options?.keyed === false ? [] : void 0,
-    s: map.length > 1 ? [] : void 0,
+    p: keyFn || options?.keyed === false ? [] : void 0,
+    q: map.length > 1 ? [] : void 0,
     T: options?.fallback
   });
 }
@@ -2048,30 +2050,30 @@ function updateKeyedMap() {
   const newItems = this.ia() || [], newLen = newItems.length;
   newItems[$TRACK];
   runWithOwner(this.S, () => {
-    let i, j, mapper = this.r ? () => {
-      this.r[j] = new Computation(newItems[j], null, pureOptions);
-      this.s && (this.s[j] = new Computation(j, null, pureOptions));
+    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));
       return this.P(
-        Computation.prototype.read.bind(this.r[j]),
-        this.s ? Computation.prototype.read.bind(this.s[j]) : void 0
+        Computation.prototype.read.bind(this.p[j]),
+        this.q ? Computation.prototype.read.bind(this.q[j]) : void 0
       );
-    } : this.s ? () => {
+    } : this.q ? () => {
       const item = newItems[j];
-      this.s[j] = new Computation(j, null, pureOptions);
-      return this.P(() => item, Computation.prototype.read.bind(this.s[j]));
+      this.q[j] = new Computation(j, null, pureOptions);
+      return this.P(() => item, Computation.prototype.read.bind(this.q[j]));
     } : () => {
       const item = newItems[j];
       return this.P(() => item);
     };
     if (newLen === 0) {
-      if (this.q !== 0) {
+      if (this.o !== 0) {
         this.S.dispose(false);
         this.d = [];
-        this.F = [];
+        this.G = [];
         this.i = [];
-        this.q = 0;
-        this.r && (this.r = []);
-        this.s && (this.s = []);
+        this.o = 0;
+        this.p && (this.p = []);
+        this.q && (this.q = []);
       }
       if (this.T && !this.i[0]) {
         this.i[0] = compute(
@@ -2080,26 +2082,26 @@ function updateKeyedMap() {
           null
         );
       }
-    } else if (this.q === 0) {
+    } else if (this.o === 0) {
       if (this.d[0])
         this.d[0].dispose();
       this.i = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.F[j] = newItems[j];
+        this.G[j] = newItems[j];
         this.i[j] = compute(this.d[j] = new Owner(), mapper, null);
       }
-      this.q = newLen;
+      this.o = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.r ? new Array(newLen) : void 0, tempIndexes = this.s ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.q, newLen); start < end && (this.F[start] === newItems[start] || this.r && compare(this.Q, this.F[start], newItems[start])); start++) {
-        if (this.r)
-          this.r[start].write(newItems[start]);
+      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.G[start] === newItems[start] || this.p && compare(this.Q, this.G[start], newItems[start])); start++) {
+        if (this.p)
+          this.p[start].write(newItems[start]);
       }
-      for (end = this.q - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.r && compare(this.Q, this.F[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.o - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.G[end] === newItems[newEnd] || this.p && compare(this.Q, this.G[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.i[end];
         tempNodes[newEnd] = this.d[end];
-        tempRows && (tempRows[newEnd] = this.r[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.s[end]);
+        tempRows && (tempRows[newEnd] = this.p[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.q[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
@@ -2111,14 +2113,14 @@ function updateKeyedMap() {
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.F[i];
+        item = this.G[i];
         key = this.Q ? this.Q(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.i[i];
           tempNodes[j] = this.d[i];
-          tempRows && (tempRows[j] = this.r[i]);
-          tempIndexes && (tempIndexes[j] = this.s[i]);
+          tempRows && (tempRows[j] = this.p[i]);
+          tempIndexes && (tempIndexes[j] = this.q[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -2129,19 +2131,19 @@ function updateKeyedMap() {
           this.i[j] = temp[j];
           this.d[j] = tempNodes[j];
           if (tempRows) {
-            this.r[j] = tempRows[j];
-            this.r[j].write(newItems[j]);
+            this.p[j] = tempRows[j];
+            this.p[j].write(newItems[j]);
           }
           if (tempIndexes) {
-            this.s[j] = tempIndexes[j];
-            this.s[j].write(j);
+            this.q[j] = tempIndexes[j];
+            this.q[j].write(j);
           }
         } else {
           this.i[j] = compute(this.d[j] = new Owner(), mapper, null);
         }
       }
-      this.i = this.i.slice(0, this.q = newLen);
-      this.F = newItems.slice(0);
+      this.i = this.i.slice(0, this.o = newLen);
+      this.G = newItems.slice(0);
     }
   });
   return this.i;
@@ -2149,8 +2151,8 @@ function updateKeyedMap() {
 function repeat(count, map, options) {
   return updateRepeat.bind({
     S: new Owner(),
-    q: 0,
-    A: 0,
+    o: 0,
+    z: 0,
     ja: count,
     P: map,
     d: [],
@@ -2164,11 +2166,11 @@ function updateRepeat() {
   const from = this.ka?.() || 0;
   runWithOwner(this.S, () => {
     if (newLen === 0) {
-      if (this.q !== 0) {
+      if (this.o !== 0) {
         this.S.dispose(false);
         this.d = [];
         this.i = [];
-        this.q = 0;
+        this.o = 0;
       }
       if (this.T && !this.i[0]) {
         this.i[0] = compute(
@@ -2180,20 +2182,20 @@ function updateRepeat() {
       return;
     }
     const to = from + newLen;
-    const prevTo = this.A + this.q;
-    if (this.q === 0 && this.d[0])
+    const prevTo = this.z + this.o;
+    if (this.o === 0 && this.d[0])
       this.d[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.d[i - this.A].dispose();
-    if (this.A < from) {
-      let i = this.A;
-      while (i < from && i < this.q)
+      this.d[i - this.z].dispose();
+    if (this.z < from) {
+      let i = this.z;
+      while (i < from && i < this.o)
         this.d[i++].dispose();
-      this.d.splice(0, from - this.A);
-      this.i.splice(0, from - this.A);
-    } else if (this.A > from) {
-      let i = prevTo - this.A - 1;
-      let difference = this.A - from;
+      this.d.splice(0, from - this.z);
+      this.i.splice(0, from - this.z);
+    } else if (this.z > from) {
+      let i = prevTo - this.z - 1;
+      let difference = this.z - from;
       this.d.length = this.i.length = newLen;
       while (i >= difference) {
         this.d[i] = this.d[i - difference];
@@ -2216,8 +2218,8 @@ function updateRepeat() {
       );
     }
     this.i = this.i.slice(0, newLen);
-    this.A = from;
-    this.q = newLen;
+    this.z = from;
+    this.o = newLen;
   });
   return this.i;
 }
@@ -2237,14 +2239,14 @@ var BoundaryComputation = class extends EagerComputation {
     if (this.U & LOADING_BIT && !(this.h & UNINITIALIZED_BIT || ActiveTransition)) {
       flags &= ~LOADING_BIT;
     }
-    this.m.notify(this, this.U, flags);
+    getQueue(this).notify(this, this.U, flags);
     return this.l;
   }
 };
 function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.m;
-  parentQueue.addChild(owner.m = queue);
-  onCleanup(() => parentQueue.removeChild(owner.m));
+  const parentQueue = owner.B;
+  parentQueue.addChild(owner.B = queue);
+  onCleanup(() => parentQueue.removeChild(owner.B));
   return compute(
     owner,
     () => {
@@ -2255,27 +2257,27 @@ function createBoundChildren(owner, fn, queue, mask) {
   );
 }
 var ConditionalQueue = class extends Queue {
-  u;
+  t;
   V = /* @__PURE__ */ new Set();
-  t = /* @__PURE__ */ new Set();
+  s = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.u = disabled;
+    this.t = disabled;
   }
   run(type) {
-    if (!type || this.u.read())
+    if (!type || this.t.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition.p.has(this))
-      return ActiveTransition.p.get(this).notify(node, type, flags);
-    if (this.u.read()) {
+    if (ActiveTransition && ActiveTransition.r.has(this))
+      return ActiveTransition.r.get(this).notify(node, type, flags);
+    if (this.t.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
-          this.t.add(node);
+          this.s.add(node);
           type &= ~LOADING_BIT;
-        } else if (this.t.delete(node))
+        } else if (this.s.delete(node))
           type &= ~LOADING_BIT;
       }
       if (type & ERROR_BIT) {
@@ -2289,43 +2291,43 @@ var ConditionalQueue = class extends Queue {
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.t.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
+    queue.s.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
     queue.V.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
     super.merge(queue);
   }
 };
 var CollectionQueue = class extends Queue {
-  I;
+  J;
   d = /* @__PURE__ */ new Set();
-  u = new Computation(false, null, { pureWrite: true });
+  t = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.I = type;
+    this.J = type;
   }
   run(type) {
-    if (!type || this.u.read())
+    if (!type || this.t.read())
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition.p.has(this))
-      return ActiveTransition.p.get(this).notify(node, type, flags);
-    if (!(type & this.I))
+    if (ActiveTransition && ActiveTransition.r.has(this))
+      return ActiveTransition.r.get(this).notify(node, type, flags);
+    if (!(type & this.J))
       return super.notify(node, type, flags);
-    if (flags & this.I) {
+    if (flags & this.J) {
       this.d.add(node);
       if (this.d.size === 1)
-        this.u.write(true);
+        this.t.write(true);
     } else if (this.d.size > 0) {
       this.d.delete(node);
       if (this.d.size === 0)
-        this.u.write(false);
+        this.t.write(false);
     }
-    type &= ~this.I;
+    type &= ~this.J;
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.d.forEach((n) => this.notify(n, this.I, this.I));
+    queue.d.forEach((n) => this.notify(n, this.J, this.J));
     super.merge(queue);
   }
 };
@@ -2336,25 +2338,25 @@ function createBoundary(fn, condition) {
   );
   const tree = createBoundChildren(owner, fn, queue, 0);
   new EagerComputation(void 0, () => {
-    const disabled = queue.u.read();
+    const disabled = queue.t.read();
     tree.U = disabled ? ERROR_BIT | LOADING_BIT : 0;
     if (!disabled) {
-      queue.t.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue.s.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
       queue.V.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
-      queue.t.clear();
+      queue.s.clear();
       queue.V.clear();
     }
   });
-  return () => queue.u.read() ? void 0 : tree.read();
+  return () => queue.t.read() ? void 0 : tree.read();
 }
 function createCollectionBoundary(type, fn, fallback) {
   const owner = new Owner();
   const queue = new CollectionQueue(type);
   const tree = createBoundChildren(owner, fn, queue, type);
   const decision = new Computation(void 0, () => {
-    if (!queue.u.read()) {
+    if (!queue.t.read()) {
       const resolved = tree.read();
-      if (!untrack(() => queue.u.read()))
+      if (!untrack(() => queue.t.read()))
         return resolved;
     }
     return fallback(queue);
@@ -2373,7 +2375,7 @@ function createErrorBoundary(fn, fallback) {
         if (ActiveTransition && !node2.e)
           node2 = cloneGraph(node2);
         node2.c = STATE_DIRTY;
-        node2.m?.enqueue(node2.C, node2.E.bind(node2));
+        getQueue(node2).enqueue(node2.C, node2.F.bind(node2));
       }
     });
   });