@solidjs/signals 0.1.0 → 0.2.1

package/dist/prod.js

@@ -43,11 +43,11 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.H)
+  if (!globalQueue.I)
     queueMicrotask(flushSync);
 }
 var Queue = class {
-  H = false;
+  I = false;
   r = [[], [], []];
   D = [];
   created = clock;
@@ -76,9 +76,9 @@ var Queue = class {
       return true;
   }
   flush() {
-    if (this.H)
+    if (this.I)
       return;
-    this.H = true;
+    this.I = true;
     try {
       while (this.run(EFFECT_PURE)) {
       }
@@ -87,7 +87,7 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.H = false;
+      this.I = false;
     }
   }
   addChild(child) {
@@ -236,19 +236,19 @@ var Owner = class {
     let head = self ? this.t || this.s : this, current = this.n, next = null;
     while (current && current.s === this) {
       current.dispose(true);
-      current.A();
+      current.z();
       next = current.n;
       current.n = null;
       current = next;
     }
     if (self)
-      this.A();
+      this.z();
     if (current)
       current.t = !self ? this : this.t;
     if (head)
       head.n = current;
   }
-  A() {
+  z() {
     if (this.t)
       this.t.n = null;
     this.s = null;
@@ -349,11 +349,11 @@ function getObserver() {
 }
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
-  f = null;
-  d = null;
-  b;
+  b = null;
+  c = null;
+  e;
   E;
-  u;
+  A;
   // Used in __DEV__ mode, hopefully removed in production
   Z;
   // Using false is an optimization as an alternative to _equals: () => false
@@ -361,37 +361,37 @@ var Computation = class extends Owner {
   N = isEqual;
   U;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  c = 0;
+  d = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   O = DEFAULT_FLAGS;
   P = null;
-  z = -1;
-  I = false;
+  x = -1;
+  J = false;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
-    this.u = compute2;
+    this.A = compute2;
     this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.c = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.b = initialValue;
+    this.d = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.e = initialValue;
     if (options?.equals !== void 0)
       this.N = options.equals;
     if (options?.unobserved)
       this.U = options?.unobserved;
   }
   V() {
-    if (this.u) {
-      if (this.c & ERROR_BIT && this.z <= getClock())
+    if (this.A) {
+      if (this.d & ERROR_BIT && this.x <= getClock())
         update(this);
       else
         this.y();
     }
-    if (!this.u || this.f?.length)
+    if (!this.A || this.b?.length)
       track(this);
-    newFlags |= this.c & ~currentMask;
-    if (this.c & ERROR_BIT) {
+    newFlags |= this.d & ~currentMask;
+    if (this.d & ERROR_BIT) {
       throw this.E;
     } else {
-      return this.b;
+      return this.e;
     }
   }
   /**
@@ -409,14 +409,14 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (this.u && this.c & ERROR_BIT && this.z <= getClock()) {
+    if (this.A && this.d & ERROR_BIT && this.x <= getClock()) {
       update(this);
     }
-    if ((notStale || this.c & UNINITIALIZED_BIT) && this.loading()) {
+    if ((notStale || this.d & UNINITIALIZED_BIT) && this.loading()) {
       throw new NotReadyError();
     }
     if (staleCheck && this.loading())
-      staleCheck.b = true;
+      staleCheck.e = true;
     return this.V();
   }
   /**
@@ -434,37 +434,37 @@ var Computation = class extends Owner {
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
-    const newValue = !raw && typeof value === "function" ? value(this.b) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.c & UNINITIALIZED_BIT) || this.N === false || !this.N(this.b, newValue));
+    const newValue = !raw && typeof value === "function" ? value(this.e) : value;
+    const valueChanged = newValue !== UNCHANGED && (!!(this.d & UNINITIALIZED_BIT) || this.N === false || !this.N(this.e, newValue));
     if (valueChanged) {
-      this.b = newValue;
+      this.e = newValue;
       this.E = void 0;
     }
-    const changedFlagsMask = this.c ^ flags, changedFlags = changedFlagsMask & flags;
-    this.c = flags;
-    this.z = getClock() + 1;
-    if (this.d) {
-      for (let i = 0; i < this.d.length; i++) {
+    const changedFlagsMask = this.d ^ flags, changedFlags = changedFlagsMask & flags;
+    this.d = flags;
+    this.x = getClock() + 1;
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
         if (valueChanged) {
-          this.d[i].q(STATE_DIRTY);
+          this.c[i].q(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.d[i].W(changedFlagsMask, changedFlags);
+          this.c[i].W(changedFlagsMask, changedFlags);
         }
       }
     }
-    return this.b;
+    return this.e;
   }
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
   q(state, skipQueue) {
-    if (this.a >= state && !this.I)
+    if (this.a >= state && !this.J)
       return;
-    this.I = !!skipQueue;
+    this.J = !!skipQueue;
     this.a = state;
-    if (this.d) {
-      for (let i = 0; i < this.d.length; i++) {
-        this.d[i].q(STATE_CHECK, skipQueue);
+    if (this.c) {
+      for (let i = 0; i < this.c.length; i++) {
+        this.c[i].q(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -483,22 +483,22 @@ var Computation = class extends Owner {
     }
     if (this.a >= STATE_CHECK)
       return;
-    const prevFlags = this.c & mask;
+    const prevFlags = this.d & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
       this.q(STATE_CHECK);
     } else {
-      this.c ^= deltaFlags;
-      if (this.d) {
-        for (let i = 0; i < this.d.length; i++) {
-          this.d[i].W(mask, newFlags2);
+      this.d ^= deltaFlags;
+      if (this.c) {
+        for (let i = 0; i < this.c.length; i++) {
+          this.c[i].W(mask, newFlags2);
         }
       }
     }
   }
-  J(error) {
+  F(error) {
     this.E = error;
-    this.write(UNCHANGED, this.c & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+    this.write(UNCHANGED, this.d & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -516,9 +516,9 @@ var Computation = class extends Owner {
     }
     let observerFlags = 0;
     if (this.a === STATE_CHECK) {
-      for (let i = 0; i < this.f.length; i++) {
-        this.f[i].y();
-        observerFlags |= this.f[i].c;
+      for (let i = 0; i < this.b.length; i++) {
+        this.b[i].y();
+        observerFlags |= this.b[i].d;
         if (this.a === STATE_DIRTY) {
           break;
         }
@@ -534,12 +534,12 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  A() {
+  z() {
     if (this.a === STATE_DISPOSED)
       return;
-    if (this.f)
+    if (this.b)
       removeSourceObservers(this, 0);
-    super.A();
+    super.z();
   }
 };
 function loadingState(node) {
@@ -550,7 +550,7 @@ function loadingState(node) {
     () => {
       track(node);
       node.y();
-      return !!(node.c & LOADING_BIT);
+      return !!(node.d & LOADING_BIT);
     },
     options
   );
@@ -560,7 +560,7 @@ function loadingState(node) {
 }
 function track(computation) {
   if (currentObserver) {
-    if (!newSources && currentObserver.f && currentObserver.f[newSourcesIndex] === computation) {
+    if (!newSources && currentObserver.b && currentObserver.b[newSourcesIndex] === computation) {
       newSourcesIndex++;
     } else if (!newSources)
       newSources = [computation];
@@ -568,7 +568,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.b = computation.z > currentObserver.z;
+      updateCheck.e = computation.x > currentObserver.x;
     }
   }
 }
@@ -580,55 +580,55 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.u, node);
+    const result = compute(node, node.A, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.c & UNINITIALIZED_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.d & UNINITIALIZED_BIT);
     } else {
-      node.J(error);
+      node.F(error);
     }
   } finally {
     if (newSources) {
-      if (node.f)
+      if (node.b)
         removeSourceObservers(node, newSourcesIndex);
-      if (node.f && newSourcesIndex > 0) {
-        node.f.length = newSourcesIndex + newSources.length;
+      if (node.b && newSourcesIndex > 0) {
+        node.b.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          node.f[newSourcesIndex + i] = newSources[i];
+          node.b[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        node.f = newSources;
+        node.b = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < node.f.length; i++) {
-        source = node.f[i];
-        if (!source.d)
-          source.d = [node];
+      for (let i = newSourcesIndex; i < node.b.length; i++) {
+        source = node.b[i];
+        if (!source.c)
+          source.c = [node];
         else
-          source.d.push(node);
+          source.c.push(node);
       }
-    } else if (node.f && newSourcesIndex < node.f.length) {
+    } else if (node.b && newSourcesIndex < node.b.length) {
       removeSourceObservers(node, newSourcesIndex);
-      node.f.length = newSourcesIndex;
+      node.b.length = newSourcesIndex;
     }
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.z = getClock() + 1;
+    node.x = getClock() + 1;
     node.a = STATE_CLEAN;
   }
 }
 function removeSourceObservers(node, index) {
   let source;
   let swap;
-  for (let i = index; i < node.f.length; i++) {
-    source = node.f[i];
-    if (source.d) {
-      swap = source.d.indexOf(node);
-      source.d[swap] = source.d[source.d.length - 1];
-      source.d.pop();
-      if (!source.d.length)
+  for (let i = index; i < node.b.length; i++) {
+    source = node.b[i];
+    if (source.c) {
+      swap = source.c.indexOf(node);
+      source.c[swap] = source.c[source.c.length - 1];
+      source.c.pop();
+      if (!source.c.length)
         source.U?.();
     }
   }
@@ -643,32 +643,40 @@ function untrack(fn) {
 }
 function hasUpdated(fn) {
   const current = updateCheck;
-  updateCheck = { b: false };
+  updateCheck = { e: false };
   try {
     fn();
-    return updateCheck.b;
+    return updateCheck.e;
   } finally {
     updateCheck = current;
   }
 }
-function isStale(fn) {
+function isPending(fn, loadingValue) {
+  const argLength = arguments.length;
   const current = staleCheck;
-  staleCheck = { b: false };
+  staleCheck = { e: false };
   try {
     latest(fn);
-    return staleCheck.b;
-  } catch {
+    return staleCheck.e;
+  } catch (err) {
+    if (argLength > 1 && err instanceof NotReadyError)
+      return !!loadingValue;
+    throw err;
   } finally {
     staleCheck = current;
   }
-  return false;
 }
-function latest(fn) {
+function latest(fn, fallback) {
+  const argLength = arguments.length;
   const prevFlags = newFlags;
   const prevNotStale = notStale;
   notStale = false;
   try {
     return fn();
+  } catch (err) {
+    if (argLength > 1 && err instanceof NotReadyError)
+      return fallback;
+    throw err;
   } finally {
     newFlags = prevFlags;
     notStale = prevNotStale;
@@ -683,13 +691,53 @@ function catchError(fn) {
     return e;
   }
 }
+function runWithObserver(observer, run) {
+  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
+  newSources = null;
+  newSourcesIndex = observer.b ? observer.b.length : 0;
+  newFlags = 0;
+  try {
+    return compute(observer, run, observer);
+  } catch (error) {
+    if (error instanceof NotReadyError) {
+      observer.write(
+        UNCHANGED,
+        newFlags | LOADING_BIT | observer.d & UNINITIALIZED_BIT
+      );
+    } else {
+      observer.F(error);
+    }
+  } finally {
+    if (newSources) {
+      if (newSourcesIndex > 0) {
+        observer.b.length = newSourcesIndex + newSources.length;
+        for (let i = 0; i < newSources.length; i++) {
+          observer.b[newSourcesIndex + i] = newSources[i];
+        }
+      } else {
+        observer.b = newSources;
+      }
+      let source;
+      for (let i = newSourcesIndex; i < observer.b.length; i++) {
+        source = observer.b[i];
+        if (!source.c)
+          source.c = [observer];
+        else
+          source.c.push(observer);
+      }
+    }
+    newSources = prevSources;
+    newSourcesIndex = prevSourcesIndex;
+    newFlags = prevFlags;
+  }
+}
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
   currentMask = observer?.O ?? DEFAULT_FLAGS;
   notStale = true;
   try {
-    return fn(observer ? observer.b : void 0);
+    return fn(observer ? observer.e : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
@@ -712,32 +760,30 @@ var Effect = class extends Computation {
   B;
   Q = false;
   M;
-  w;
+  u;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this.K = effect;
     this.L = error;
     this.M = initialValue;
-    this.w = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.w === EFFECT_RENDER) {
-      this.u = (p) => getClock() > this.h.created ? latest(() => compute2(p)) : compute2(p);
-    }
-    if (!options?.defer) {
-      this.y();
-      this.w === EFFECT_USER ? this.h.enqueue(this.w, this) : this.T();
+    this.u = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.u === EFFECT_RENDER) {
+      this.A = (p) => getClock() > this.h.created ? latest(() => compute2(p)) : compute2(p);
     }
+    this.y();
+    !options?.defer && (this.u === EFFECT_USER ? this.h.enqueue(this.u, this) : this.T());
   }
   write(value, flags = 0) {
     if (this.a == STATE_DIRTY) {
-      const currentFlags = this.c;
-      this.c = flags;
-      if (this.w === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+      const currentFlags = this.d;
+      this.d = flags;
+      if (this.u === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
         this.h.R?.(this);
       }
     }
     if (value === UNCHANGED)
-      return this.b;
-    this.b = value;
+      return this.e;
+    this.e = value;
     this.Q = true;
     return value;
   }
@@ -745,16 +791,16 @@ var Effect = class extends Computation {
     if (this.a >= state || skipQueue)
       return;
     if (this.a === STATE_CLEAN)
-      this.h.enqueue(this.w, this);
+      this.h.enqueue(this.u, this);
     this.a = state;
   }
-  J(error) {
+  F(error) {
     this.B?.();
-    if (this.c & LOADING_BIT) {
-      this.c = 0;
+    if (this.d & LOADING_BIT) {
+      this.d = 0;
       this.h.R?.(this);
     }
-    if (this.w === EFFECT_USER) {
+    if (this.u === EFFECT_USER) {
       try {
         return this.L ? this.B = this.L(error) : console.error(new EffectError(this.K, error));
       } catch (e) {
@@ -763,7 +809,7 @@ var Effect = class extends Computation {
     }
     this.handleError(error);
   }
-  A() {
+  z() {
     if (this.a === STATE_DISPOSED)
       return;
     this.K = void 0;
@@ -771,17 +817,17 @@ var Effect = class extends Computation {
     this.L = void 0;
     this.B?.();
     this.B = void 0;
-    super.A();
+    super.z();
   }
   T() {
     if (this.Q && this.a !== STATE_DISPOSED) {
       this.B?.();
       try {
-        this.B = this.K(this.b, this.M);
+        this.B = this.K(this.e, this.M);
       } catch (e) {
         this.handleError(e);
       } finally {
-        this.M = this.b;
+        this.M = this.e;
         this.Q = false;
       }
     }
@@ -793,7 +839,7 @@ var EagerComputation = class extends Computation {
     !options?.defer && this.y();
   }
   q(state, skipQueue) {
-    if (this.a >= state && !this.I)
+    if (this.a >= state && !this.J)
       return;
     if (this.a === STATE_CLEAN && !skipQueue)
       this.h.enqueue(EFFECT_PURE, this);
@@ -805,7 +851,7 @@ var ProjectionComputation = class extends Computation {
     super(null, compute2);
   }
   q(state, skipQueue) {
-    if (this.a >= state && !this.I)
+    if (this.a >= state && !this.J)
       return;
     if (this.a === STATE_CLEAN && !skipQueue)
       this.h.enqueue(EFFECT_PURE, this);
@@ -815,7 +861,7 @@ var ProjectionComputation = class extends Computation {
 
 // src/core/suspense.ts
 var SuspenseQueue = class extends Queue {
-  e = /* @__PURE__ */ new Set();
+  f = /* @__PURE__ */ new Set();
   o = false;
   S = new Computation(false, null);
   run(type) {
@@ -824,15 +870,15 @@ var SuspenseQueue = class extends Queue {
     return super.run(type);
   }
   R(node) {
-    if (node.c & LOADING_BIT) {
-      this.e.add(node);
+    if (node.d & LOADING_BIT) {
+      this.f.add(node);
       if (!this.o) {
         this.o = true;
         this.S.write(true);
       }
     } else {
-      this.e.delete(node);
-      if (this.e.size === 0) {
+      this.f.delete(node);
+      if (this.f.size === 0) {
         this.o = false;
         this.S.write(false);
       }
@@ -841,13 +887,13 @@ var SuspenseQueue = class extends Queue {
 };
 var LiveComputation = class extends EagerComputation {
   write(value, flags = 0) {
-    const currentFlags = this.c;
+    const currentFlags = this.d;
     const dirty = this.a === STATE_DIRTY;
     super.write(value, flags);
     if (dirty && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
       this.h.R?.(this);
     }
-    return this.b;
+    return this.e;
   }
 };
 function createSuspense(fn, fallback) {
@@ -887,10 +933,10 @@ function createMemo(compute2, value, options) {
   return () => {
     if (node) {
       resolvedValue = node.wait();
-      if (!node.f?.length && node.n?.s !== node) {
+      if (!node.b?.length && node.n?.s !== node) {
         node.dispose();
         node = void 0;
-      } else if (!node.s && !node.d?.length) {
+      } else if (!node.s && !node.c?.length) {
         node.dispose();
         node.a = STATE_DIRTY;
       }
@@ -902,10 +948,10 @@ function createAsync(compute2, value, options) {
   let uninitialized = value === void 0;
   const lhs = new EagerComputation(
     {
-      b: value
+      e: value
     },
     (p) => {
-      const value2 = p?.b;
+      const value2 = p?.e;
       const source = compute2(value2);
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
@@ -914,13 +960,13 @@ function createAsync(compute2, value, options) {
           wait() {
             return source;
           },
-          b: source
+          e: source
         };
       }
       const signal = new Computation(value2, null, options);
       const w = signal.wait;
       signal.wait = function() {
-        if (signal.c & ERROR_BIT && signal.z <= getClock()) {
+        if (signal.d & ERROR_BIT && signal.x <= getClock()) {
           lhs.q(STATE_DIRTY);
           throw new NotReadyError();
         }
@@ -935,7 +981,7 @@ function createAsync(compute2, value, options) {
           },
           (error) => {
             uninitialized = true;
-            signal.J(error);
+            signal.F(error);
           }
         );
       } else {
@@ -964,13 +1010,13 @@ function createEffect(compute2, effect, error, value, options) {
     compute2,
     effect,
     error,
-    void 0
+    options
   );
 }
 function createRenderEffect(compute2, effect, value, options) {
   void new Effect(value, compute2, effect, void 0, {
     render: true,
-    ...void 0
+    ...options
   });
 }
 function createRoot(init) {
@@ -978,12 +1024,7 @@ function createRoot(init) {
   return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
 }
 function runWithOwner(owner, run) {
-  try {
-    return compute(owner, run, null);
-  } catch (error) {
-    owner?.handleError(error);
-    return void 0;
-  }
+  return compute(owner, run, null);
 }
 function createErrorBoundary(fn, fallback) {
   const owner = new Owner();
@@ -1011,7 +1052,7 @@ function createErrorBoundary(fn, fallback) {
     () => {
       const c = new Computation(void 0, fn);
       const f = new EagerComputation(void 0, () => flatten(c.read()), { defer: true });
-      f.J = function(error2) {
+      f.F = function(error2) {
         this.handleError(error2);
       };
       return f;
@@ -1028,7 +1069,7 @@ function createErrorBoundary(fn, fallback) {
       incrementClock();
       for (let node of nodes) {
         node.a = STATE_DIRTY;
-        node.h?.enqueue(node.w, node);
+        node.h?.enqueue(node.u, node);
       }
     });
   });
@@ -1050,19 +1091,6 @@ function resolve(fn) {
     });
   });
 }
-function createReaction(effect, error, options) {
-  const node = new Effect(void 0, () => {
-  }, effect, error, {
-    defer: true,
-    ...void 0
-  });
-  return (tracking) => {
-    node.u = tracking;
-    node.a = STATE_DIRTY;
-    node.y();
-    node.u = null;
-  };
-}
 
 // src/store/projection.ts
 function createProjection(fn, initialValue = {}) {
@@ -1209,7 +1237,7 @@ var proxyTraps = {
         return desc.get.call(receiver);
     }
     if (Writing.has(storeValue)) {
-      const value2 = tracked ? tracked.b : storeValue[property];
+      const value2 = tracked ? tracked.e : storeValue[property];
       return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
     let value = tracked ? nodes[property].read() : storeValue[property];
@@ -1548,13 +1576,13 @@ function omit(props, ...keys) {
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    F: new Owner(),
+    G: new Owner(),
     i: 0,
     X: list,
-    x: [],
-    G: map,
+    w: [],
+    H: map,
     g: [],
-    e: [],
+    f: [],
     C: keyFn,
     j: keyFn || options?.keyed === false ? [] : void 0,
     k: map.length > 1 ? [] : void 0,
@@ -1564,27 +1592,27 @@ function mapArray(list, map, options) {
 function updateKeyedMap() {
   const newItems = this.X() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.F, () => {
+  runWithOwner(this.G, () => {
     let i, j, mapper = this.j ? () => {
       this.j[j] = new Computation(newItems[j], null);
       this.k && (this.k[j] = new Computation(j, null));
-      return this.G(
+      return this.H(
         Computation.prototype.read.bind(this.j[j]),
         this.k ? Computation.prototype.read.bind(this.k[j]) : void 0
       );
     } : this.k ? () => {
       const item = newItems[j];
       this.k[j] = new Computation(j, null);
-      return this.G(() => item, Computation.prototype.read.bind(this.k[j]));
+      return this.H(() => item, Computation.prototype.read.bind(this.k[j]));
     } : () => {
       const item = newItems[j];
-      return this.G(() => item);
+      return this.H(() => item);
     };
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.F.dispose(false);
-        this.e = [];
-        this.x = [];
+        this.G.dispose(false);
+        this.f = [];
+        this.w = [];
         this.g = [];
         this.i = 0;
         this.j && (this.j = []);
@@ -1592,29 +1620,29 @@ function updateKeyedMap() {
       }
       if (this.o && !this.g[0]) {
         this.g[0] = compute(
-          this.e[0] = new Owner(),
+          this.f[0] = new Owner(),
           this.o,
           null
         );
       }
     } else if (this.i === 0) {
-      if (this.e[0])
-        this.e[0].dispose();
+      if (this.f[0])
+        this.f[0].dispose();
       this.g = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.x[j] = newItems[j];
-        this.g[j] = compute(this.e[j] = new Owner(), mapper, null);
+        this.w[j] = newItems[j];
+        this.g[j] = compute(this.f[j] = new Owner(), mapper, null);
       }
       this.i = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.j ? new Array(newLen) : void 0, tempIndexes = this.k ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.x[start] === newItems[start] || this.j && compare(this.C, this.x[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.w[start] === newItems[start] || this.j && compare(this.C, this.w[start], newItems[start])); start++) {
         if (this.j)
           this.j[start].write(newItems[start]);
       }
-      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.x[end] === newItems[newEnd] || this.j && compare(this.C, this.x[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.w[end] === newItems[newEnd] || this.j && compare(this.C, this.w[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.g[end];
-        tempNodes[newEnd] = this.e[end];
+        tempNodes[newEnd] = this.f[end];
         tempRows && (tempRows[newEnd] = this.j[end]);
         tempIndexes && (tempIndexes[newEnd] = this.k[end]);
       }
@@ -1628,23 +1656,23 @@ function updateKeyedMap() {
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.x[i];
+        item = this.w[i];
         key = this.C ? this.C(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.g[i];
-          tempNodes[j] = this.e[i];
+          tempNodes[j] = this.f[i];
           tempRows && (tempRows[j] = this.j[i]);
           tempIndexes && (tempIndexes[j] = this.k[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.e[i].dispose();
+          this.f[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
           this.g[j] = temp[j];
-          this.e[j] = tempNodes[j];
+          this.f[j] = tempNodes[j];
           if (tempRows) {
             this.j[j] = tempRows[j];
             this.j[j].write(newItems[j]);
@@ -1654,55 +1682,55 @@ function updateKeyedMap() {
             this.k[j].write(j);
           }
         } else {
-          this.g[j] = compute(this.e[j] = new Owner(), mapper, null);
+          this.g[j] = compute(this.f[j] = new Owner(), mapper, null);
         }
       }
       this.g = this.g.slice(0, this.i = newLen);
-      this.x = newItems.slice(0);
+      this.w = newItems.slice(0);
     }
   });
   return this.g;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    F: new Owner(),
+    G: new Owner(),
     i: 0,
     Y: count,
-    G: map,
-    e: [],
+    H: map,
+    f: [],
     g: [],
     o: options?.fallback
   });
 }
 function updateRepeat() {
   const newLen = this.Y();
-  runWithOwner(this.F, () => {
+  runWithOwner(this.G, () => {
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.F.dispose(false);
-        this.e = [];
+        this.G.dispose(false);
+        this.f = [];
         this.g = [];
         this.i = 0;
       }
       if (this.o && !this.g[0]) {
         this.g[0] = compute(
-          this.e[0] = new Owner(),
+          this.f[0] = new Owner(),
           this.o,
           null
         );
       }
     } else {
-      if (this.i === 0 && this.e[0])
-        this.e[0].dispose();
+      if (this.i === 0 && this.f[0])
+        this.f[0].dispose();
       for (let i = this.i; i < newLen; i++) {
         this.g[i] = compute(
-          this.e[i] = new Owner(),
-          () => this.G(i),
+          this.f[i] = new Owner(),
+          () => this.H(i),
           null
         );
       }
       for (let i = newLen; i < this.i; i++)
-        this.e[i].dispose();
+        this.f[i].dispose();
       this.g = this.g.slice(0, newLen);
       this.i = newLen;
     }
@@ -1713,4 +1741,4 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
-export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isStale, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithOwner, setContext, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, untrack, unwrap };