@solidjs/signals 0.2.2 → 0.2.4

package/dist/prod.js

@@ -43,42 +43,42 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.I)
+  if (!globalQueue.J)
     queueMicrotask(flushSync);
 }
 var Queue = class {
-  I = false;
-  r = [[], [], []];
-  D = [];
+  J = false;
+  s = [[], [], []];
+  F = [];
   created = clock;
   enqueue(type, node) {
-    this.r[0].push(node);
+    this.s[0].push(node);
     if (type)
-      this.r[type].push(node);
+      this.s[type].push(node);
     schedule();
   }
   run(type) {
-    if (this.r[type].length) {
+    if (this.s[type].length) {
       if (type === EFFECT_PURE) {
-        runPureQueue(this.r[type]);
-        this.r[type] = [];
+        runPureQueue(this.s[type]);
+        this.s[type] = [];
       } else {
-        const effects = this.r[type];
-        this.r[type] = [];
+        const effects = this.s[type];
+        this.s[type] = [];
         runEffectQueue(effects);
       }
     }
     let rerun = false;
-    for (let i = 0; i < this.D.length; i++) {
-      rerun = this.D[i].run(type) || rerun;
+    for (let i = 0; i < this.F.length; i++) {
+      rerun = this.F[i].run(type) || rerun;
     }
-    if (type === EFFECT_PURE && this.r[type].length)
+    if (type === EFFECT_PURE && this.s[type].length)
       return true;
   }
   flush() {
-    if (this.I)
+    if (this.J)
       return;
-    this.I = true;
+    this.J = true;
     try {
       while (this.run(EFFECT_PURE)) {
       }
@@ -87,16 +87,16 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.I = false;
+      this.J = false;
     }
   }
   addChild(child) {
-    this.D.push(child);
+    this.F.push(child);
   }
   removeChild(child) {
-    const index = this.D.indexOf(child);
+    const index = this.F.indexOf(child);
     if (index >= 0)
-      this.D.splice(index, 1);
+      this.F.splice(index, 1);
   }
 };
 var globalQueue = new Queue();
@@ -107,14 +107,14 @@ function flushSync() {
 }
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.s) {
+  for (let current = node; current !== null; current = current.t) {
     if (current.a !== STATE_CLEAN) {
       ancestors.push(current);
     }
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     if (ancestors[i].a !== STATE_DISPOSED)
-      ancestors[i].y();
+      ancestors[i].z();
   }
 }
 function runPureQueue(queue) {
@@ -125,67 +125,13 @@ function runPureQueue(queue) {
 }
 function runEffectQueue(queue) {
   for (let i = 0; i < queue.length; i++)
-    queue[i].T();
+    queue[i].U();
 }
 
 // src/core/utils.ts
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-function flatten(children, options) {
-  if (typeof children === "function" && !children.length) {
-    if (options?.doNotUnwrap)
-      return children;
-    do {
-      children = children();
-    } while (typeof children === "function" && !children.length);
-  }
-  if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
-    return;
-  if (Array.isArray(children)) {
-    let results = [];
-    if (flattenArray(children, results, options)) {
-      return () => {
-        let nested = [];
-        flattenArray(results, nested, { ...options, doNotUnwrap: false });
-        return nested;
-      };
-    }
-    return results;
-  }
-  return children;
-}
-function flattenArray(children, results = [], options) {
-  let notReady = null;
-  let needsUnwrap = false;
-  for (let i = 0; i < children.length; i++) {
-    try {
-      let child = children[i];
-      if (typeof child === "function" && !child.length) {
-        if (options?.doNotUnwrap) {
-          results.push(child);
-          needsUnwrap = true;
-          continue;
-        }
-        do {
-          child = child();
-        } while (typeof child === "function" && !child.length);
-      }
-      if (Array.isArray(child)) {
-        needsUnwrap = flattenArray(child, results, options);
-      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
-      } else
-        results.push(child);
-    } catch (e) {
-      if (!(e instanceof NotReadyError))
-        throw e;
-      notReady = e;
-    }
-  }
-  if (notReady)
-    throw notReady;
-  return needsUnwrap;
-}
 
 // src/core/owner.ts
 var currentOwner = null;
@@ -202,9 +148,9 @@ var Owner = class {
   // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
   // 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
-  s = null;
-  n = null;
   t = null;
+  n = null;
+  u = null;
   a = STATE_CLEAN;
   l = null;
   p = defaultContext;
@@ -215,10 +161,10 @@ var Owner = class {
       currentOwner.append(this);
   }
   append(child) {
-    child.s = this;
     child.t = this;
+    child.u = this;
     if (this.n)
-      this.n.t = child;
+      this.n.u = child;
     child.n = this.n;
     this.n = child;
     if (child.p !== this.p) {
@@ -233,26 +179,26 @@ var Owner = class {
   dispose(self = true) {
     if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.t || this.s : this, current = this.n, next = null;
-    while (current && current.s === this) {
+    let head = self ? this.u || this.t : this, current = this.n, next = null;
+    while (current && current.t === this) {
       current.dispose(true);
-      current.z();
+      current.A();
       next = current.n;
       current.n = null;
       current = next;
     }
     if (self)
-      this.z();
+      this.A();
     if (current)
-      current.t = !self ? this : this.t;
+      current.u = !self ? this : this.u;
     if (head)
       head.n = current;
   }
-  z() {
-    if (this.t)
-      this.t.n = null;
-    this.s = null;
+  A() {
+    if (this.u)
+      this.u.n = null;
     this.t = null;
+    this.u = null;
     this.p = defaultContext;
     this.m = null;
     this.a = STATE_DISPOSED;
@@ -350,48 +296,48 @@ function getObserver() {
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
   b = null;
-  c = null;
-  e;
-  E;
-  A;
+  e = null;
+  g;
+  G;
+  B;
   // Used in __DEV__ mode, hopefully removed in production
-  Z;
+  $;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  N = isEqual;
-  U;
+  O = isEqual;
+  V;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  d = 0;
+  f = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  O = DEFAULT_FLAGS;
-  P = null;
-  x = -1;
-  J = false;
+  P = DEFAULT_FLAGS;
+  Q = null;
+  y = -1;
+  K = false;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
-    this.A = compute2;
+    this.B = compute2;
     this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.d = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.e = initialValue;
+    this.f = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
+    this.g = initialValue;
     if (options?.equals !== void 0)
-      this.N = options.equals;
+      this.O = options.equals;
     if (options?.unobserved)
-      this.U = options?.unobserved;
+      this.V = options?.unobserved;
   }
-  V() {
-    if (this.A) {
-      if (this.d & ERROR_BIT && this.x <= getClock())
+  W() {
+    if (this.B) {
+      if (this.f & ERROR_BIT && this.y <= getClock())
         update(this);
       else
-        this.y();
+        this.z();
     }
-    if (!this.A || this.b?.length)
+    if (!this.B || this.b?.length)
       track(this);
-    newFlags |= this.d & ~currentMask;
-    if (this.d & ERROR_BIT) {
-      throw this.E;
+    newFlags |= this.f & ~currentMask;
+    if (this.f & ERROR_BIT) {
+      throw this.G;
     } else {
-      return this.e;
+      return this.g;
     }
   }
   /**
@@ -399,7 +345,7 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
-    return this.V();
+    return this.W();
   }
   /**
    * Return the current value of this computation
@@ -409,15 +355,15 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (this.A && this.d & ERROR_BIT && this.x <= getClock()) {
+    if (this.B && this.f & ERROR_BIT && this.y <= getClock()) {
       update(this);
     }
-    if ((notStale || this.d & UNINITIALIZED_BIT) && this.loading()) {
+    if ((notStale || this.f & UNINITIALIZED_BIT) && this.loading()) {
       throw new NotReadyError();
     }
     if (staleCheck && this.loading())
-      staleCheck.e = true;
-    return this.V();
+      staleCheck.g = true;
+    return this.W();
   }
   /**
    * Return true if the computation is the value is dependent on an unresolved promise
@@ -427,44 +373,44 @@ var Computation = class extends Owner {
    * loading state changes
    */
   loading() {
-    if (this.P === null) {
-      this.P = loadingState(this);
+    if (this.Q === null) {
+      this.Q = loadingState(this);
     }
-    return this.P.read();
+    return this.Q.read();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
-    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));
+    const newValue = !raw && typeof value === "function" ? value(this.g) : value;
+    const valueChanged = newValue !== UNCHANGED && (!!(this.f & UNINITIALIZED_BIT) || this.O === false || !this.O(this.g, newValue));
     if (valueChanged) {
-      this.e = newValue;
-      this.E = void 0;
-    }
-    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++) {
+      this.g = newValue;
+      this.G = void 0;
+    }
+    const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
+    this.f = flags;
+    this.y = getClock() + 1;
+    if (this.e) {
+      for (let i = 0; i < this.e.length; i++) {
         if (valueChanged) {
-          this.c[i].q(STATE_DIRTY);
+          this.e[i].q(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.c[i].W(changedFlagsMask, changedFlags);
+          this.e[i].X(changedFlagsMask, changedFlags);
         }
       }
     }
-    return this.e;
+    return this.g;
   }
   /**
    * 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.J)
+    if (this.a >= state && !this.K)
       return;
-    this.J = !!skipQueue;
+    this.K = !!skipQueue;
     this.a = state;
-    if (this.c) {
-      for (let i = 0; i < this.c.length; i++) {
-        this.c[i].q(STATE_CHECK, skipQueue);
+    if (this.e) {
+      for (let i = 0; i < this.e.length; i++) {
+        this.e[i].q(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -474,31 +420,31 @@ var Computation = class extends Owner {
    * @param mask A bitmask for which flag(s) were changed.
    * @param newFlags The source's new flags, masked to just the changed ones.
    */
-  W(mask, newFlags2) {
+  X(mask, newFlags2) {
     if (this.a >= STATE_DIRTY)
       return;
-    if (mask & this.O) {
+    if (mask & this.P) {
       this.q(STATE_DIRTY);
       return;
     }
     if (this.a >= STATE_CHECK)
       return;
-    const prevFlags = this.d & mask;
+    const prevFlags = this.f & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
       this.q(STATE_CHECK);
     } else {
-      this.d ^= deltaFlags;
-      if (this.c) {
-        for (let i = 0; i < this.c.length; i++) {
-          this.c[i].W(mask, newFlags2);
+      this.f ^= deltaFlags;
+      if (this.e) {
+        for (let i = 0; i < this.e.length; i++) {
+          this.e[i].X(mask, newFlags2);
         }
       }
     }
   }
-  F(error) {
-    this.E = error;
-    this.write(UNCHANGED, this.d & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
+  H(error) {
+    this.G = error;
+    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
@@ -507,7 +453,7 @@ var Computation = class extends Owner {
    *
    * This function will ensure that the value and states we read from the computation are up to date
    */
-  y() {
+  z() {
     if (this.a === STATE_DISPOSED) {
       throw new Error("Tried to read a disposed computation");
     }
@@ -517,8 +463,8 @@ var Computation = class extends Owner {
     let observerFlags = 0;
     if (this.a === STATE_CHECK) {
       for (let i = 0; i < this.b.length; i++) {
-        this.b[i].y();
-        observerFlags |= this.b[i].d;
+        this.b[i].z();
+        observerFlags |= this.b[i].f;
         if (this.a === STATE_DIRTY) {
           break;
         }
@@ -534,27 +480,27 @@ var Computation = class extends Owner {
   /**
    * Remove ourselves from the owner graph and the computation graph
    */
-  z() {
+  A() {
     if (this.a === STATE_DISPOSED)
       return;
     if (this.b)
       removeSourceObservers(this, 0);
-    super.z();
+    super.A();
   }
 };
 function loadingState(node) {
-  const prevOwner = setOwner(node.s);
+  const prevOwner = setOwner(node.t);
   const options = void 0;
   const computation = new Computation(
     void 0,
     () => {
       track(node);
-      node.y();
-      return !!(node.d & LOADING_BIT);
+      node.z();
+      return !!(node.f & LOADING_BIT);
     },
     options
   );
-  computation.O = ERROR_BIT | LOADING_BIT;
+  computation.P = ERROR_BIT | LOADING_BIT;
   setOwner(prevOwner);
   return computation;
 }
@@ -568,7 +514,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.e = computation.x > currentObserver.x;
+      updateCheck.g = computation.y > currentObserver.y;
     }
   }
 }
@@ -580,13 +526,13 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.A, node);
+    const result = compute(node, node.B, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.d & UNINITIALIZED_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node.f & UNINITIALIZED_BIT);
     } else {
-      node.F(error);
+      node.H(error);
     }
   } finally {
     if (newSources) {
@@ -603,10 +549,10 @@ function update(node) {
       let source;
       for (let i = newSourcesIndex; i < node.b.length; i++) {
         source = node.b[i];
-        if (!source.c)
-          source.c = [node];
+        if (!source.e)
+          source.e = [node];
         else
-          source.c.push(node);
+          source.e.push(node);
       }
     } else if (node.b && newSourcesIndex < node.b.length) {
       removeSourceObservers(node, newSourcesIndex);
@@ -615,7 +561,7 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node.x = getClock() + 1;
+    node.y = getClock() + 1;
     node.a = STATE_CLEAN;
   }
 }
@@ -624,12 +570,12 @@ function removeSourceObservers(node, index) {
   let swap;
   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?.();
+    if (source.e) {
+      swap = source.e.indexOf(node);
+      source.e[swap] = source.e[source.e.length - 1];
+      source.e.pop();
+      if (!source.e.length)
+        source.V?.();
     }
   }
 }
@@ -643,10 +589,10 @@ function untrack(fn) {
 }
 function hasUpdated(fn) {
   const current = updateCheck;
-  updateCheck = { e: false };
+  updateCheck = { g: false };
   try {
     fn();
-    return updateCheck.e;
+    return updateCheck.g;
   } finally {
     updateCheck = current;
   }
@@ -654,10 +600,10 @@ function hasUpdated(fn) {
 function isPending(fn, loadingValue) {
   const argLength = arguments.length;
   const current = staleCheck;
-  staleCheck = { e: false };
+  staleCheck = { g: false };
   try {
     latest(fn);
-    return staleCheck.e;
+    return staleCheck.g;
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
@@ -704,10 +650,10 @@ function runWithObserver(observer, run) {
     if (error instanceof NotReadyError) {
       observer.write(
         UNCHANGED,
-        newFlags | LOADING_BIT | observer.d & UNINITIALIZED_BIT
+        newFlags | LOADING_BIT | observer.f & UNINITIALIZED_BIT
       );
     } else {
-      observer.F(error);
+      observer.H(error);
     }
   } finally {
     if (newSources) {
@@ -722,10 +668,10 @@ function runWithObserver(observer, run) {
       let source;
       for (let i = newSourcesIndex; i < observer.b.length; i++) {
         source = observer.b[i];
-        if (!source.c)
-          source.c = [observer];
+        if (!source.e)
+          source.e = [observer];
         else
-          source.c.push(observer);
+          source.e.push(observer);
       }
     }
     newSources = prevSources;
@@ -736,10 +682,10 @@ function runWithObserver(observer, run) {
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
-  currentMask = observer?.O ?? DEFAULT_FLAGS;
+  currentMask = observer?.P ?? DEFAULT_FLAGS;
   notStale = true;
   try {
-    return fn(observer ? observer.e : void 0);
+    return fn(observer ? observer.g : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
@@ -747,6 +693,68 @@ function compute(owner, fn, observer) {
     notStale = prevNotStale;
   }
 }
+function flatten(children, options) {
+  try {
+    if (typeof children === "function" && !children.length) {
+      if (options?.doNotUnwrap)
+        return children;
+      do {
+        children = children();
+      } while (typeof children === "function" && !children.length);
+    }
+    if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
+      return;
+    if (Array.isArray(children)) {
+      let results = [];
+      if (flattenArray(children, results, options)) {
+        return () => {
+          let nested = [];
+          flattenArray(results, nested, { ...options, doNotUnwrap: false });
+          return nested;
+        };
+      }
+      return results;
+    }
+    return children;
+  } catch (e) {
+    if (options?.skipNonRendered && e instanceof NotReadyError) {
+      newFlags |= LOADING_BIT;
+      return void 0;
+    }
+    throw e;
+  }
+}
+function flattenArray(children, results = [], options) {
+  let notReady = null;
+  let needsUnwrap = false;
+  for (let i = 0; i < children.length; i++) {
+    try {
+      let child = children[i];
+      if (typeof child === "function" && !child.length) {
+        if (options?.doNotUnwrap) {
+          results.push(child);
+          needsUnwrap = true;
+          continue;
+        }
+        do {
+          child = child();
+        } while (typeof child === "function" && !child.length);
+      }
+      if (Array.isArray(child)) {
+        needsUnwrap = flattenArray(child, results, options);
+      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
+      } else
+        results.push(child);
+    } catch (e) {
+      if (!(e instanceof NotReadyError))
+        throw e;
+      notReady = e;
+    }
+  }
+  if (notReady)
+    throw notReady;
+  return needsUnwrap;
+}
 function createBoundary(fn, queue) {
   const owner = new Owner();
   const parentQueue = owner.h;
@@ -757,80 +765,80 @@ function createBoundary(fn, queue) {
 
 // src/core/effect.ts
 var Effect = class extends Computation {
-  K;
   L;
-  B;
-  Q = false;
   M;
-  u;
+  C;
+  R = false;
+  N;
+  w;
   constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
-    this.K = effect;
-    this.L = error;
-    this.M = initialValue;
-    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.L = effect;
+    this.M = error;
+    this.N = initialValue;
+    this.w = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this.w === EFFECT_RENDER) {
+      this.B = (p) => getClock() > this.h.created && !(this.f & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
-    this.y();
-    !options?.defer && (this.u === EFFECT_USER ? this.h.enqueue(this.u, this) : this.T());
+    this.z();
+    !options?.defer && (this.w === EFFECT_USER ? this.h.enqueue(this.w, this) : this.U());
   }
   write(value, flags = 0) {
     if (this.a == STATE_DIRTY) {
-      const currentFlags = this.d;
-      this.d = flags;
-      if (this.u === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-        this.h.R?.(this);
+      const currentFlags = this.f;
+      this.f = flags;
+      if (this.w === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+        this.h.S?.(this);
       }
     }
     if (value === UNCHANGED)
-      return this.e;
-    this.e = value;
-    this.Q = true;
+      return this.g;
+    this.g = value;
+    this.R = true;
     return value;
   }
   q(state, skipQueue) {
     if (this.a >= state || skipQueue)
       return;
     if (this.a === STATE_CLEAN)
-      this.h.enqueue(this.u, this);
+      this.h.enqueue(this.w, this);
     this.a = state;
   }
-  F(error) {
-    this.B?.();
-    if (this.d & LOADING_BIT) {
-      this.d = 0;
-      this.h.R?.(this);
+  H(error) {
+    this.C?.();
+    if (this.f & LOADING_BIT) {
+      this.h.S?.(this);
     }
-    if (this.u === EFFECT_USER) {
+    this.f = ERROR_BIT;
+    if (this.w === EFFECT_USER) {
       try {
-        return this.L ? this.B = this.L(error) : console.error(new EffectError(this.K, error));
+        return this.M ? this.C = this.M(error) : console.error(new EffectError(this.L, error));
       } catch (e) {
         error = e;
       }
     }
     this.handleError(error);
   }
-  z() {
+  A() {
     if (this.a === STATE_DISPOSED)
       return;
-    this.K = void 0;
-    this.M = void 0;
     this.L = void 0;
-    this.B?.();
-    this.B = void 0;
-    super.z();
+    this.N = void 0;
+    this.M = void 0;
+    this.C?.();
+    this.C = void 0;
+    super.A();
   }
-  T() {
-    if (this.Q && this.a !== STATE_DISPOSED) {
-      this.B?.();
+  U() {
+    if (this.R && this.a !== STATE_DISPOSED) {
+      this.C?.();
       try {
-        this.B = this.K(this.e, this.M);
+        this.C = this.L(this.g, this.N);
       } catch (e) {
         this.handleError(e);
       } finally {
-        this.M = this.e;
-        this.Q = false;
+        this.N = this.g;
+        this.R = false;
       }
     }
   }
@@ -838,10 +846,10 @@ var Effect = class extends Computation {
 var EagerComputation = class extends Computation {
   constructor(initialValue, compute2, options) {
     super(initialValue, compute2, options);
-    !options?.defer && this.y();
+    !options?.defer && this.z();
   }
   q(state, skipQueue) {
-    if (this.a >= state && !this.J)
+    if (this.a >= state && !this.K)
       return;
     if (this.a === STATE_CLEAN && !skipQueue)
       this.h.enqueue(EFFECT_PURE, this);
@@ -853,7 +861,7 @@ var ProjectionComputation = class extends Computation {
     super(null, compute2);
   }
   q(state, skipQueue) {
-    if (this.a >= state && !this.J)
+    if (this.a >= state && !this.K)
       return;
     if (this.a === STATE_CLEAN && !skipQueue)
       this.h.enqueue(EFFECT_PURE, this);
@@ -863,39 +871,39 @@ var ProjectionComputation = class extends Computation {
 
 // src/core/suspense.ts
 var SuspenseQueue = class extends Queue {
-  f = /* @__PURE__ */ new Set();
+  c = /* @__PURE__ */ new Set();
   o = false;
-  S = new Computation(false, null);
+  T = new Computation(false, null);
   run(type) {
     if (type && this.o)
       return;
     return super.run(type);
   }
-  R(node) {
-    if (node.d & LOADING_BIT) {
-      this.f.add(node);
+  S(node) {
+    if (node.f & LOADING_BIT) {
+      this.c.add(node);
       if (!this.o) {
         this.o = true;
-        this.S.write(true);
+        this.T.write(true);
       }
     } else {
-      this.f.delete(node);
-      if (this.f.size === 0) {
+      this.c.delete(node);
+      if (this.c.size === 0) {
         this.o = false;
-        this.S.write(false);
+        this.T.write(false);
       }
     }
   }
 };
 var LiveComputation = class extends EagerComputation {
   write(value, flags = 0) {
-    const currentFlags = this.d;
+    const currentFlags = this.f;
     const dirty = this.a === STATE_DIRTY;
     super.write(value, flags);
     if (dirty && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this.h.R?.(this);
+      this.h.S?.(this);
     }
-    return this.e;
+    return this.g;
   }
 };
 function createSuspense(fn, fallback) {
@@ -904,7 +912,7 @@ function createSuspense(fn, fallback) {
     const child = new Computation(null, fn);
     return new LiveComputation(null, () => flatten(child.wait()));
   }, queue);
-  const equality = new Computation(null, () => queue.S.read() || queue.o);
+  const equality = new Computation(null, () => queue.T.read() || queue.o);
   const comp = new Computation(null, () => equality.read() ? fallback() : tree.read());
   return comp.read.bind(comp);
 }
@@ -935,10 +943,10 @@ function createMemo(compute2, value, options) {
   return () => {
     if (node) {
       resolvedValue = node.wait();
-      if (!node.b?.length && node.n?.s !== node) {
+      if (!node.b?.length && node.n?.t !== node) {
         node.dispose();
         node = void 0;
-      } else if (!node.s && !node.c?.length) {
+      } else if (!node.t && !node.e?.length) {
         node.dispose();
         node.a = STATE_DIRTY;
       }
@@ -950,10 +958,10 @@ function createAsync(compute2, value, options) {
   let uninitialized = value === void 0;
   const lhs = new EagerComputation(
     {
-      e: value
+      g: value
     },
     (p) => {
-      const value2 = p?.e;
+      const value2 = p?.g;
       const source = compute2(value2);
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
@@ -962,13 +970,13 @@ function createAsync(compute2, value, options) {
           wait() {
             return source;
           },
-          e: source
+          g: source
         };
       }
       const signal = new Computation(value2, null, options);
       const w = signal.wait;
       signal.wait = function() {
-        if (signal.d & ERROR_BIT && signal.x <= getClock()) {
+        if (signal.f & ERROR_BIT && signal.y <= getClock()) {
           lhs.q(STATE_DIRTY);
           throw new NotReadyError();
         }
@@ -983,7 +991,7 @@ function createAsync(compute2, value, options) {
           },
           (error) => {
             uninitialized = true;
-            signal.F(error);
+            signal.H(error);
           }
         );
       } else {
@@ -1046,7 +1054,7 @@ function createErrorBoundary(fn, fallback) {
     );
     nodes.add(node);
     if (nodes.size === 1)
-      error.write({ E: err });
+      error.write({ G: err });
   }
   owner.m = owner.m ? [handler, ...owner.m] : [handler];
   const guarded = compute(
@@ -1054,7 +1062,7 @@ function createErrorBoundary(fn, fallback) {
     () => {
       const c = new Computation(void 0, fn);
       const f = new EagerComputation(void 0, () => flatten(c.read()), { defer: true });
-      f.F = function(error2) {
+      f.H = function(error2) {
         this.handleError(error2);
       };
       return f;
@@ -1067,11 +1075,11 @@ function createErrorBoundary(fn, fallback) {
       if (!error.read())
         return resolved;
     }
-    return fallback(error.read().E, () => {
+    return fallback(error.read().G, () => {
       incrementClock();
       for (let node of nodes) {
         node.a = STATE_DIRTY;
-        node.h?.enqueue(node.u, node);
+        node.h?.enqueue(node.w, node);
       }
     });
   });
@@ -1096,12 +1104,15 @@ function resolve(fn) {
 
 // src/store/projection.ts
 function createProjection(fn, initialValue = {}) {
-  const [store, setStore] = createStore(initialValue);
+  const [store] = createStore(fn, initialValue);
+  return store;
+}
+function wrapProjection(fn, store, setStore) {
   const node = new ProjectionComputation(() => {
     setStore(fn);
   });
   const wrapped = /* @__PURE__ */ new WeakMap();
-  return wrap(store, node, wrapped);
+  return [wrap(store, node, wrapped), setStore];
 }
 function wrap(source, node, wrapped) {
   if (wrapped.has(source))
@@ -1239,7 +1250,7 @@ var proxyTraps = {
         return desc.get.call(receiver);
     }
     if (Writing.has(storeValue)) {
-      const value2 = tracked ? tracked.e : storeValue[property];
+      const value2 = tracked ? tracked.g : storeValue[property];
       return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
     let value = tracked ? nodes[property].read() : storeValue[property];
@@ -1299,10 +1310,8 @@ function setProperty(state, property, value, deleting = false) {
 }
 function createStore(first, second) {
   const derived = typeof first === "function", store = derived ? second : first;
-  if (derived)
-    return createProjection(first, store);
   const unwrappedStore = unwrap(store, false);
-  const wrappedStore = wrap2(unwrappedStore);
+  let wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
     try {
       Writing.add(unwrappedStore);
@@ -1311,6 +1320,8 @@ function createStore(first, second) {
       Writing.clear();
     }
   };
+  if (derived)
+    return wrapProjection(first, wrappedStore, setStore);
   return [wrappedStore, setStore];
 }
 
@@ -1426,7 +1437,7 @@ function reconcile(value, key) {
   };
 }
 
-// src/store/utilities.ts
+// src/store/utils.ts
 function trueFn() {
   return true;
 }
@@ -1578,73 +1589,73 @@ function omit(props, ...keys) {
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    G: new Owner(),
+    I: new Owner(),
     i: 0,
-    X: list,
-    w: [],
-    H: map,
-    g: [],
-    f: [],
-    C: keyFn,
+    Y: list,
+    x: [],
+    D: map,
+    d: [],
+    c: [],
+    E: keyFn,
     j: keyFn || options?.keyed === false ? [] : void 0,
     k: map.length > 1 ? [] : void 0,
     o: options?.fallback
   });
 }
 function updateKeyedMap() {
-  const newItems = this.X() || [], newLen = newItems.length;
+  const newItems = this.Y() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.G, () => {
+  runWithOwner(this.I, () => {
     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.H(
+      return this.D(
         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.H(() => item, Computation.prototype.read.bind(this.k[j]));
+      return this.D(() => item, Computation.prototype.read.bind(this.k[j]));
     } : () => {
       const item = newItems[j];
-      return this.H(() => item);
+      return this.D(() => item);
     };
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.G.dispose(false);
-        this.f = [];
-        this.w = [];
-        this.g = [];
+        this.I.dispose(false);
+        this.c = [];
+        this.x = [];
+        this.d = [];
         this.i = 0;
         this.j && (this.j = []);
         this.k && (this.k = []);
       }
-      if (this.o && !this.g[0]) {
-        this.g[0] = compute(
-          this.f[0] = new Owner(),
+      if (this.o && !this.d[0]) {
+        this.d[0] = compute(
+          this.c[0] = new Owner(),
           this.o,
           null
         );
       }
     } else if (this.i === 0) {
-      if (this.f[0])
-        this.f[0].dispose();
-      this.g = new Array(newLen);
+      if (this.c[0])
+        this.c[0].dispose();
+      this.d = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.w[j] = newItems[j];
-        this.g[j] = compute(this.f[j] = new Owner(), mapper, null);
+        this.x[j] = newItems[j];
+        this.d[j] = compute(this.c[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.w[start] === newItems[start] || this.j && compare(this.C, this.w[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.i, newLen); start < end && (this.x[start] === newItems[start] || this.j && compare(this.E, this.x[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.w[end] === newItems[newEnd] || this.j && compare(this.C, this.w[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.g[end];
-        tempNodes[newEnd] = this.f[end];
+      for (end = this.i - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.x[end] === newItems[newEnd] || this.j && compare(this.E, this.x[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.d[end];
+        tempNodes[newEnd] = this.c[end];
         tempRows && (tempRows[newEnd] = this.j[end]);
         tempIndexes && (tempIndexes[newEnd] = this.k[end]);
       }
@@ -1652,29 +1663,29 @@ function updateKeyedMap() {
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.C ? this.C(item) : item;
+        key = this.E ? this.E(item) : item;
         i = newIndices.get(key);
         newIndicesNext[j] = i === void 0 ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.w[i];
-        key = this.C ? this.C(item) : item;
+        item = this.x[i];
+        key = this.E ? this.E(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.g[i];
-          tempNodes[j] = this.f[i];
+          temp[j] = this.d[i];
+          tempNodes[j] = this.c[i];
           tempRows && (tempRows[j] = this.j[i]);
           tempIndexes && (tempIndexes[j] = this.k[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.f[i].dispose();
+          this.c[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.g[j] = temp[j];
-          this.f[j] = tempNodes[j];
+          this.d[j] = temp[j];
+          this.c[j] = tempNodes[j];
           if (tempRows) {
             this.j[j] = tempRows[j];
             this.j[j].write(newItems[j]);
@@ -1684,60 +1695,89 @@ function updateKeyedMap() {
             this.k[j].write(j);
           }
         } else {
-          this.g[j] = compute(this.f[j] = new Owner(), mapper, null);
+          this.d[j] = compute(this.c[j] = new Owner(), mapper, null);
         }
       }
-      this.g = this.g.slice(0, this.i = newLen);
-      this.w = newItems.slice(0);
+      this.d = this.d.slice(0, this.i = newLen);
+      this.x = newItems.slice(0);
     }
   });
-  return this.g;
+  return this.d;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    G: new Owner(),
+    I: new Owner(),
     i: 0,
-    Y: count,
-    H: map,
-    f: [],
-    g: [],
+    r: 0,
+    Z: count,
+    D: map,
+    c: [],
+    d: [],
+    _: options?.from,
     o: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.Y();
-  runWithOwner(this.G, () => {
+  const newLen = this.Z();
+  const from = this._?.() || 0;
+  runWithOwner(this.I, () => {
     if (newLen === 0) {
       if (this.i !== 0) {
-        this.G.dispose(false);
-        this.f = [];
-        this.g = [];
+        this.I.dispose(false);
+        this.c = [];
+        this.d = [];
         this.i = 0;
       }
-      if (this.o && !this.g[0]) {
-        this.g[0] = compute(
-          this.f[0] = new Owner(),
+      if (this.o && !this.d[0]) {
+        this.d[0] = compute(
+          this.c[0] = new Owner(),
           this.o,
           null
         );
       }
-    } else {
-      if (this.i === 0 && this.f[0])
-        this.f[0].dispose();
-      for (let i = this.i; i < newLen; i++) {
-        this.g[i] = compute(
-          this.f[i] = new Owner(),
-          () => this.H(i),
+      return;
+    }
+    const to = from + newLen;
+    const prevTo = this.r + this.i;
+    if (this.i === 0 && this.c[0])
+      this.c[0].dispose();
+    for (let i = to; i < prevTo; i++)
+      this.c[i - this.r].dispose();
+    if (this.r < from) {
+      let i = this.r;
+      while (i < from && i < this.i)
+        this.c[i++].dispose();
+      this.c.splice(0, from - this.r);
+      this.d.splice(0, from - this.r);
+    } else if (this.r > from) {
+      let i = prevTo - this.r - 1;
+      let difference = this.r - from;
+      this.c.length = this.d.length = newLen;
+      while (i >= difference) {
+        this.c[i] = this.c[i - difference];
+        this.d[i] = this.d[i - difference];
+        i--;
+      }
+      for (let i2 = 0; i2 < difference; i2++) {
+        this.d[i2] = compute(
+          this.c[i2] = new Owner(),
+          () => this.D(i2 + from),
           null
         );
       }
-      for (let i = newLen; i < this.i; i++)
-        this.f[i].dispose();
-      this.g = this.g.slice(0, newLen);
-      this.i = newLen;
     }
+    for (let i = prevTo; i < to; i++) {
+      this.d[i - from] = compute(
+        this.c[i - from] = new Owner(),
+        () => this.D(i),
+        null
+      );
+    }
+    this.d = this.d.slice(0, newLen);
+    this.r = from;
+    this.i = newLen;
   });
-  return this.g;
+  return this.d;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;