@solidjs/signals 0.4.6 → 0.4.8

package/dist/prod.js

@@ -120,7 +120,7 @@ var Queue = class {
     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.e.length; i++) {
-      const og = this.e.find((c) => c.g === queue.e[i].g);
+      const og = this.e.find((c) => c.h === queue.e[i].h);
       if (og)
         og.merge(queue.e[i]);
       else
@@ -143,7 +143,7 @@ var Transition = class _Transition {
   s = /* @__PURE__ */ new Set();
   R = /* @__PURE__ */ new Set();
   W = /* @__PURE__ */ new Set();
-  I = false;
+  J = false;
   f = [[], []];
   u = /* @__PURE__ */ new Map();
   E = [];
@@ -219,7 +219,7 @@ var Transition = class _Transition {
     this.f[1].push.apply(this.f[1], queue.f[1]);
     this.E.push.apply(this.E, queue.E);
     for (let i = 0; i < queue.e.length; i++) {
-      const og = this.e.find((c) => c.g === queue.e[i].g);
+      const og = this.e.find((c) => c.h === queue.e[i].h);
       if (og)
         og.merge(queue.e[i]);
       else
@@ -234,9 +234,9 @@ var Transition = class _Transition {
       queueMicrotask(() => this.flush());
   }
   runTransition(fn, force = false) {
-    if (this.I) {
-      if (this.I instanceof _Transition)
-        return this.I.runTransition(fn, force);
+    if (this.J) {
+      if (this.J instanceof _Transition)
+        return this.J.runTransition(fn, force);
       if (!force)
         throw new Error("Transition already completed");
       fn();
@@ -260,12 +260,12 @@ var Transition = class _Transition {
     }
   }
   addOptimistic(fn) {
-    if (fn.l && fn.l !== this) {
-      mergeTransitions(fn.l, this);
-      ActiveTransition = fn.l;
+    if (fn.j && fn.j !== this) {
+      mergeTransitions(fn.j, this);
+      ActiveTransition = fn.j;
       return;
     }
-    fn.l = this;
+    fn.j = this;
     this.W.add(fn);
   }
 };
@@ -274,12 +274,12 @@ function transition(fn) {
   queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
 function cloneGraph(node) {
-  if (node.l) {
-    if (node.l !== ActiveTransition) {
-      mergeTransitions(node.l, ActiveTransition);
-      ActiveTransition = node.l;
+  if (node.j) {
+    if (node.j !== ActiveTransition) {
+      mergeTransitions(node.j, ActiveTransition);
+      ActiveTransition = node.j;
     }
-    return node.l.a.get(node);
+    return node.j.a.get(node);
   }
   const clone = Object.create(Object.getPrototypeOf(node));
   Object.assign(clone, node, {
@@ -287,10 +287,12 @@ function cloneGraph(node) {
     r: null,
     b: null,
     a: node.a ? [...node.a] : null,
-    g: node
+    h: node
   });
+  if (clone.F)
+    clone.g |= UNINITIALIZED_BIT;
   ActiveTransition.a.set(node, clone);
-  node.l = ActiveTransition;
+  node.j = ActiveTransition;
   if (node.a) {
     for (let i = 0; i < node.a.length; i++)
       node.a[i].b.push(clone);
@@ -298,7 +300,7 @@ function cloneGraph(node) {
   if (node.b) {
     clone.b = [];
     for (let i = 0, length = node.b.length; i < length; i++) {
-      !node.b[i].g && clone.b.push(cloneGraph(node.b[i]));
+      !node.b[i].h && clone.b.push(cloneGraph(node.b[i]));
     }
   }
   return clone;
@@ -311,7 +313,7 @@ function replaceSourceObservers(node, transition2) {
     transitionSource = transition2.a.get(node.a[i]);
     source = transitionSource || node.a[i];
     if (source.b && (swap = source.b.indexOf(node)) !== -1) {
-      source.b[swap] = transitionSource ? node.g : source.b[source.b.length - 1];
+      source.b[swap] = transitionSource ? node.h : source.b[source.b.length - 1];
       !transitionSource && source.b.pop();
     }
   }
@@ -319,15 +321,15 @@ function replaceSourceObservers(node, transition2) {
 function cloneQueue(queue, parent, clonedQueues) {
   const clone = Object.create(Object.getPrototypeOf(queue));
   Object.assign(clone, queue, {
-    g: queue,
+    h: queue,
     m: parent,
     e: [],
     enqueue(type, fn) {
       ActiveTransition?.enqueue(type, fn);
     },
     notify(node, type, flags) {
-      node = node.g || node;
-      if (!clone.F || type & LOADING_BIT) {
+      node = node.h || node;
+      if (!clone.G || type & LOADING_BIT) {
         type &= ~LOADING_BIT;
         ActiveTransition?.notify(node, LOADING_BIT, flags);
         if (!type)
@@ -344,7 +346,7 @@ function cloneQueue(queue, parent, clonedQueues) {
 }
 function resolveQueues(children) {
   for (const child of children) {
-    const og = child.g;
+    const og = child.h;
     if (og) {
       const clonedChildren = child.e;
       delete child.enqueue;
@@ -352,47 +354,49 @@ function resolveQueues(children) {
       delete child.m;
       delete child.e;
       Object.assign(og, child);
-      delete og.g;
+      delete og.h;
       resolveQueues(clonedChildren);
-    } else if (child.m.g) {
-      child.m.g.addChild(child);
+    } else if (child.m.h) {
+      child.m.h.addChild(child);
     }
   }
 }
 function mergeTransitions(t1, t2) {
   t2.a.forEach((value, key) => {
-    key.l = t1;
+    key.j = t1;
     t1.a.set(key, value);
   });
   t2.W.forEach((c) => {
-    c.l = t1;
+    c.j = t1;
     t1.W.add(c);
   });
   t2.R.forEach((p) => t1.R.add(p));
   t2.s.forEach((n) => t1.s.add(n));
   t1.merge(t2);
-  t2.I = t1;
+  t2.J = t1;
 }
 function finishTransition(transition2) {
-  if (transition2.I || transition2.X || transition2.R.size || transition2.s.size)
+  if (transition2.J || transition2.X || transition2.R.size || transition2.s.size)
     return;
   for (const [source, clone] of transition2.a) {
-    if (source === clone || source.l !== transition2)
+    if (source === clone || source.j !== transition2)
       continue;
     if (clone.a)
       replaceSourceObservers(clone, transition2);
-    source.dispose(false);
-    source.emptyDisposal();
-    Object.assign(source, clone);
-    delete source.g;
-    delete source.l;
+    if (!(clone.g === UNINITIALIZED_BIT)) {
+      source.dispose(false);
+      source.emptyDisposal();
+      Object.assign(source, clone);
+      delete source.h;
+    }
+    delete source.j;
   }
   globalQueue.f[0].push.apply(globalQueue.f[0], transition2.f[0]);
   globalQueue.f[1].push.apply(globalQueue.f[1], transition2.f[1]);
   resolveQueues(transition2.e);
-  transition2.I = true;
+  transition2.J = true;
   for (const reset of transition2.W) {
-    delete reset.l;
+    delete reset.j;
     reset();
   }
   globalQueue.flush();
@@ -419,7 +423,7 @@ var Owner = class {
   c = STATE_CLEAN;
   n = null;
   w = defaultContext;
-  k = globalQueue;
+  l = globalQueue;
   ea = 0;
   id = null;
   constructor(id = null, skipAppend = false) {
@@ -440,8 +444,8 @@ var Owner = class {
     if (child.w !== this.w) {
       child.w = { ...this.w, ...child.w };
     }
-    if (this.k)
-      child.k = this.k;
+    if (this.l)
+      child.l = this.l;
   }
   dispose(self = true) {
     if (this.c === STATE_DISPOSED)
@@ -449,20 +453,20 @@ var Owner = class {
     let head = self ? this.B || this.m : this, current = this.r, next = null;
     while (current && current.m === this) {
       current.dispose(true);
-      current.J();
+      current.K();
       next = current.r;
       current.r = null;
       current = next;
     }
     this.ea = 0;
     if (self)
-      this.J();
+      this.K();
     if (current)
       current.B = !self ? this : this.B;
     if (head)
       head.r = current;
   }
-  J() {
+  K() {
     if (this.B)
       this.B.r = null;
     this.m = null;
@@ -552,9 +556,9 @@ var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
   a = null;
   b = null;
-  j;
-  K;
+  k;
   L;
+  F;
   // Used in __DEV__ mode, hopefully removed in production
   ka;
   // Using false is an optimization as an alternative to _equals: () => false
@@ -563,19 +567,19 @@ var Computation = class extends Owner {
   da;
   ga = false;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  h = 0;
+  g = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   aa = DEFAULT_FLAGS;
   M = -1;
-  G = false;
-  l;
-  g;
+  H = false;
+  j;
+  h;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
-    this.L = compute2;
+    this.F = compute2;
     this.c = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.h = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.j = initialValue;
+    this.g = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.k = initialValue;
     if (options?.equals !== void 0)
       this.$ = options.equals;
     if (options?.pureWrite)
@@ -583,17 +587,17 @@ var Computation = class extends Owner {
     if (options?.unobserved)
       this.da = options?.unobserved;
     if (ActiveTransition) {
-      this.l = ActiveTransition;
+      this.j = ActiveTransition;
       ActiveTransition.a.set(this, this);
     }
   }
   fa() {
     track(this);
-    newFlags |= this.h & ~currentMask;
-    if (this.h & ERROR_BIT) {
-      throw this.K;
+    newFlags |= this.g & ~currentMask;
+    if (this.g & ERROR_BIT) {
+      throw this.L;
     } else {
-      return this.j;
+      return this.k;
     }
   }
   /**
@@ -601,16 +605,16 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.g && this.h & UNINITIALIZED_BIT)) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.h && this.g & UNINITIALIZED_BIT)) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.read();
     }
-    if (this.L) {
-      if (this.h & ERROR_BIT && this.M <= clock)
+    if (this.F) {
+      if (this.g & ERROR_BIT && this.M <= clock)
         update(this);
       else
-        this.H();
+        this.I();
     }
     return this.fa();
   }
@@ -622,42 +626,42 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.g && this.h & UNINITIALIZED_BIT)) {
+    if (ActiveTransition && (ActiveTransition.a.has(this) || !this.h && this.g & UNINITIALIZED_BIT)) {
       const clone = ActiveTransition.a.get(this) || cloneGraph(this);
       if (clone !== this)
         return clone.wait();
     }
-    if (this.L) {
-      if (this.h & ERROR_BIT && this.M <= clock)
+    if (this.F) {
+      if (this.g & ERROR_BIT && this.M <= clock)
         update(this);
       else
-        this.H();
+        this.I();
     }
-    if ((notStale || this.h & UNINITIALIZED_BIT) && this.h & LOADING_BIT) {
+    if ((notStale || this.g & UNINITIALIZED_BIT) && this.g & LOADING_BIT) {
       track(this);
       throw new NotReadyError();
     }
-    if (staleCheck && this.h & LOADING_BIT) {
-      staleCheck.j = true;
+    if (staleCheck && this.g & LOADING_BIT) {
+      staleCheck.k = true;
     }
     return this.fa();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
-    if (ActiveTransition && !this.g) {
+    if (ActiveTransition && !this.h) {
       const clone = cloneGraph(this);
       if (clone !== this)
         return clone.write(value, flags, raw);
     }
-    const newValue = !raw && typeof value === "function" ? value(this.j) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.h & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
-    this.$ === false || !this.$(this.j, newValue));
+    const newValue = !raw && typeof value === "function" ? value(this.k) : value;
+    const valueChanged = newValue !== UNCHANGED && (!!(this.g & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
+    this.$ === false || !this.$(this.k, newValue));
     if (valueChanged) {
-      this.j = newValue;
-      this.K = void 0;
+      this.k = newValue;
+      this.L = void 0;
     }
-    const changedFlagsMask = this.h ^ flags, changedFlags = changedFlagsMask & flags;
-    this.h = flags;
+    const changedFlagsMask = this.g ^ flags, changedFlags = changedFlagsMask & flags;
+    this.g = flags;
     this.M = clock + 1;
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
@@ -668,15 +672,15 @@ var Computation = class extends Owner {
         }
       }
     }
-    return this.j;
+    return this.k;
   }
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
   x(state, skipQueue) {
-    if (this.c >= state && !this.G)
+    if (this.c >= state && !this.H)
       return;
-    this.G = !!skipQueue;
+    this.H = !!skipQueue;
     this.c = state;
     if (this.b) {
       for (let i = 0; i < this.b.length; i++) {
@@ -699,12 +703,12 @@ var Computation = class extends Owner {
     }
     if (this.c >= STATE_CHECK)
       return;
-    const prevFlags = this.h & mask;
+    const prevFlags = this.g & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
       this.x(STATE_CHECK);
     } else {
-      this.h ^= deltaFlags;
+      this.g ^= deltaFlags;
       if (this.b) {
         for (let i = 0; i < this.b.length; i++) {
           this.b[i].Y(mask, newFlags2);
@@ -713,13 +717,13 @@ var Computation = class extends Owner {
     }
   }
   N(error) {
-    if (ActiveTransition && !this.g) {
+    if (ActiveTransition && !this.h) {
       const clone = cloneGraph(this);
       if (clone !== this)
         return clone.N(error);
     }
-    this.K = error;
-    this.write(UNCHANGED, this.h & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+    this.L = error;
+    this.write(UNCHANGED, this.g & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -728,8 +732,8 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  H() {
-    if (!this.L) {
+  I() {
+    if (!this.F) {
       return;
     }
     if (this.c === STATE_DISPOSED) {
@@ -742,8 +746,8 @@ var Computation = class extends Owner {
     if (this.c === STATE_CHECK) {
       for (let i = 0; i < this.a.length; i++) {
         const source = ActiveTransition && ActiveTransition.a.get(this.a[i]) || this.a[i];
-        source.H();
-        observerFlags |= source.h & ~UNINITIALIZED_BIT;
+        source.I();
+        observerFlags |= source.g & ~UNINITIALIZED_BIT;
         if (this.c === STATE_DIRTY) {
           break;
         }
@@ -759,17 +763,17 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  J() {
+  K() {
     if (this.c === STATE_DISPOSED)
       return;
     if (this.a)
       removeSourceObservers(this, 0);
-    super.J();
+    super.K();
   }
 };
 function track(computation) {
-  if (ActiveTransition && computation.g)
-    computation = computation.g;
+  if (ActiveTransition && computation.h)
+    computation = computation.h;
   if (currentObserver) {
     if (!newSources && currentObserver.a && currentObserver.a[newSourcesIndex] === computation) {
       newSourcesIndex++;
@@ -779,7 +783,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.j = computation.M > currentObserver.M;
+      updateCheck.k = computation.M > currentObserver.M;
     }
   }
 }
@@ -791,11 +795,11 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.L, node);
+    const result = compute(node, node.F, 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.g & UNINITIALIZED_BIT);
     } else {
       node.N(error);
     }
@@ -855,20 +859,20 @@ function untrack(fn) {
 }
 function hasUpdated(fn) {
   const current = updateCheck;
-  updateCheck = { j: false };
+  updateCheck = { k: false };
   try {
     fn();
-    return updateCheck.j;
+    return updateCheck.k;
   } finally {
     updateCheck = current;
   }
 }
 function pendingCheck(fn, loadingValue) {
   const current = staleCheck;
-  staleCheck = { j: false };
+  staleCheck = { k: false };
   try {
     latest(fn);
-    return staleCheck.j;
+    return staleCheck.k;
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
@@ -913,7 +917,7 @@ function runWithObserver(observer, run) {
     if (error instanceof NotReadyError) {
       observer.write(
         UNCHANGED,
-        newFlags | LOADING_BIT | observer.h & UNINITIALIZED_BIT
+        newFlags | LOADING_BIT | observer.g & UNINITIALIZED_BIT
       );
     } else {
       observer.N(error);
@@ -948,7 +952,7 @@ function compute(owner, fn, observer) {
   currentMask = observer?.aa ?? DEFAULT_FLAGS;
   notStale = true;
   try {
-    return fn.call(observer, observer ? observer.j : void 0);
+    return fn.call(observer, observer ? observer.k : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
@@ -972,36 +976,36 @@ var Effect = class extends Computation {
     this._ = initialValue;
     this.A = options?.render ? EFFECT_RENDER : EFFECT_USER;
     if (this.A === EFFECT_RENDER) {
-      this.L = function(p) {
-        return !this.g && clock > this.k.created && !(this.h & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+      this.F = function(p) {
+        return !this.h && clock > this.l.created && !(this.g & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
       };
     }
-    this.H();
-    !options?.defer && (this.A === EFFECT_USER ? this.k.enqueue(this.A, this.C.bind(this)) : this.C(this.A));
+    this.I();
+    !options?.defer && (this.A === EFFECT_USER ? this.l.enqueue(this.A, this.C.bind(this)) : this.C(this.A));
   }
   write(value, flags = 0) {
     if (this.c == STATE_DIRTY) {
-      this.h = flags;
+      this.g = flags;
       if (this.A === EFFECT_RENDER) {
-        this.k.notify(this, LOADING_BIT | ERROR_BIT, this.h);
+        this.l.notify(this, LOADING_BIT | ERROR_BIT, this.g);
       }
     }
     if (value === UNCHANGED)
-      return this.j;
-    this.j = value;
+      return this.k;
+    this.k = value;
     this.ca = true;
-    this.K = void 0;
+    this.L = void 0;
     return value;
   }
   x(state, skipQueue) {
     if (this.c >= state || skipQueue)
       return;
     if (this.c === STATE_CLEAN)
-      this.k.enqueue(this.A, this.C.bind(this));
+      this.l.enqueue(this.A, this.C.bind(this));
     this.c = state;
   }
   Y(mask, newFlags2) {
-    if (this.g) {
+    if (this.h) {
       if (this.c >= STATE_DIRTY)
         return;
       if (mask & 3) {
@@ -1012,9 +1016,9 @@ var Effect = class extends Computation {
     super.Y(mask, newFlags2);
   }
   N(error) {
-    this.K = error;
-    this.k.notify(this, LOADING_BIT, 0);
-    this.h = ERROR_BIT;
+    this.L = error;
+    this.l.notify(this, LOADING_BIT, 0);
+    this.g = ERROR_BIT;
     if (this.A === EFFECT_USER) {
       try {
         return this.Z ? this.Z(error, () => {
@@ -1025,10 +1029,10 @@ var Effect = class extends Computation {
         error = e;
       }
     }
-    if (!this.k.notify(this, ERROR_BIT, ERROR_BIT))
+    if (!this.l.notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
-  J() {
+  K() {
     if (this.c === STATE_DISPOSED)
       return;
     this.ba = void 0;
@@ -1036,21 +1040,21 @@ var Effect = class extends Computation {
     this.Z = void 0;
     this.O?.();
     this.O = void 0;
-    this.k.notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super.J();
+    this.l.notify(this, ERROR_BIT | LOADING_BIT, 0);
+    super.K();
   }
   C(type) {
     if (type) {
-      const effect = this.g || this;
+      const effect = this.h || this;
       if (effect.ca && effect.c !== STATE_DISPOSED) {
         effect.O?.();
         try {
-          effect.O = effect.ba(effect.j, effect._);
+          effect.O = effect.ba(effect.k, effect._);
         } catch (e) {
-          if (!effect.k.notify(effect, ERROR_BIT, ERROR_BIT))
+          if (!effect.l.notify(effect, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
-          effect._ = effect.j;
+          effect._ = effect.k;
           effect.ca = false;
         }
       }
@@ -1061,13 +1065,13 @@ var Effect = class extends Computation {
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.H();
+    !options?.defer && this.I();
   }
   x(state, skipQueue) {
-    if (this.c >= state && !this.G)
+    if (this.c >= state && !this.H)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.G))
-      this.k.enqueue(EFFECT_PURE, this.C.bind(this));
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.H))
+      this.l.enqueue(EFFECT_PURE, this.C.bind(this));
     super.x(state, skipQueue);
   }
   C() {
@@ -1080,12 +1084,12 @@ var FirewallComputation = class extends Computation {
     super(void 0, compute2);
   }
   x(state, skipQueue) {
-    if (this.c >= state && !this.G)
+    if (this.c >= state && !this.H)
       return;
-    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.G))
-      this.k.enqueue(EFFECT_PURE, this.C.bind(this));
+    if (!skipQueue && (this.c === STATE_CLEAN || this.c === STATE_CHECK && this.H))
+      this.l.enqueue(EFFECT_PURE, this.C.bind(this));
     super.x(state, true);
-    this.G = !!skipQueue;
+    this.H = !!skipQueue;
   }
   C() {
     this.c !== STATE_CLEAN && runTop(this);
@@ -1100,7 +1104,7 @@ function runTop(node) {
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     if (ancestors[i].c !== STATE_DISPOSED)
-      ancestors[i].H();
+      ancestors[i].I();
   }
 }
 
@@ -1234,7 +1238,7 @@ var storeTraps = {
         return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked.j : storeValue[property];
+      let value2 = tracked && (overridden || !proxySource) ? tracked.k : storeValue[property];
       value2 === $DELETED && (value2 = void 0);
       if (!isWrappable(value2))
         return value2;
@@ -1771,7 +1775,7 @@ function createMemo(compute2, value, options) {
         return resolvedValue;
       }
       resolvedValue = node.wait();
-      if (!node.a?.length && node.r?.m !== node && !(node.h & UNINITIALIZED_BIT)) {
+      if (!node.a?.length && node.r?.m !== node && !(node.g & UNINITIALIZED_BIT)) {
         node.dispose();
         node = void 0;
       }
@@ -1833,12 +1837,12 @@ function createAsync(compute2, value, options) {
   const read = node.wait.bind(node);
   read.refresh = () => {
     let n = node;
-    if (ActiveTransition && !node.g) {
+    if (ActiveTransition && !node.h) {
       n = cloneGraph(node);
     }
     n.c = STATE_DIRTY;
     refreshing = true;
-    n.H();
+    n.I();
   };
   return read;
 }
@@ -1906,7 +1910,7 @@ function createOptimistic(initial, compute2, key) {
       if (!ActiveTransition)
         throw new Error("createOptimistic can only be updated inside a transition");
       ActiveTransition.addOptimistic(reset2);
-      queueMicrotask(() => node.write(v));
+      queueMicrotask(() => reset2.j && node.write(v));
     };
     var write = write2;
     const node = new Computation(initial, null);
@@ -1937,7 +1941,7 @@ function createOptimistic(initial, compute2, key) {
       throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
     queueMicrotask(
-      () => setStore((s) => {
+      () => reset.j && setStore((s) => {
         lastChange = typeof v === "function" ? v(lastChange) : v;
         compute2(s.value, lastChange);
       })
@@ -2154,17 +2158,17 @@ var BoundaryComputation = class extends EagerComputation {
   }
   write(value, flags) {
     super.write(value, flags & ~this.U);
-    if (this.U & LOADING_BIT && !(this.h & UNINITIALIZED_BIT)) {
+    if (this.U & LOADING_BIT && !(this.g & UNINITIALIZED_BIT)) {
       flags &= ~LOADING_BIT;
     }
-    this.k.notify(this, this.U, flags);
-    return this.j;
+    this.l.notify(this, this.U, flags);
+    return this.k;
   }
 };
 function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.k;
-  parentQueue.addChild(owner.k = queue);
-  onCleanup(() => parentQueue.removeChild(owner.k));
+  const parentQueue = owner.l;
+  parentQueue.addChild(owner.l = queue);
+  onCleanup(() => parentQueue.removeChild(owner.l));
   return compute(
     owner,
     () => {
@@ -2215,12 +2219,12 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  F;
+  G;
   d = /* @__PURE__ */ new Set();
   t = new Computation(false, null, { pureWrite: true });
   constructor(type) {
     super();
-    this.F = type;
+    this.G = type;
   }
   run(type) {
     if (!type || this.t.read())
@@ -2230,9 +2234,9 @@ var CollectionQueue = class extends Queue {
   notify(node, type, flags) {
     if (ActiveTransition && ActiveTransition.u.has(this))
       return ActiveTransition.u.get(this).notify(node, type, flags);
-    if (!(type & this.F))
+    if (!(type & this.G))
       return super.notify(node, type, flags);
-    if (flags & this.F) {
+    if (flags & this.G) {
       this.d.add(node);
       if (this.d.size === 1)
         this.t.write(true);
@@ -2241,11 +2245,11 @@ var CollectionQueue = class extends Queue {
       if (this.d.size === 0)
         this.t.write(false);
     }
-    type &= ~this.F;
+    type &= ~this.G;
     return type ? super.notify(node, type, flags) : true;
   }
   merge(queue) {
-    queue.d.forEach((n) => this.notify(n, this.F, this.F));
+    queue.d.forEach((n) => this.notify(n, this.G, this.G));
     super.merge(queue);
   }
 };
@@ -2288,13 +2292,13 @@ function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(ERROR_BIT, fn, (queue) => {
     let node = queue.d.values().next().value;
     ActiveTransition && ActiveTransition.a.has(node) && (node = ActiveTransition.a.get(node));
-    return fallback(node.K, () => {
+    return fallback(node.L, () => {
       incrementClock();
       for (let node2 of queue.d) {
-        if (ActiveTransition && !node2.g)
+        if (ActiveTransition && !node2.h)
           node2 = cloneGraph(node2);
         node2.c = STATE_DIRTY;
-        node2.k?.enqueue(node2.A, node2.C.bind(node2));
+        node2.l?.enqueue(node2.A, node2.C.bind(node2));
       }
     });
   });