@solidjs/signals 0.0.4 → 0.0.5

package/dist/prod.js

@@ -3,9 +3,7 @@ var NotReadyError = class extends Error {
 };
 var NoOwnerError = class extends Error {
   constructor() {
-    super(
-      ""
-    );
+    super("");
   }
 };
 var ContextNotFoundError = class extends Error {
@@ -16,11 +14,6 @@ var ContextNotFoundError = class extends Error {
   }
 };
 
-// src/utils.ts
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-
 // src/core/constants.ts
 var STATE_CLEAN = 0;
 var STATE_CHECK = 1;
@@ -32,6 +25,65 @@ var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
 var SUPPORTS_PROXY = typeof Proxy === "function";
 
+// 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;
 var defaultContext = {};
@@ -51,9 +103,9 @@ var Owner = class {
   m = null;
   p = null;
   a = STATE_CLEAN;
-  h = null;
-  n = defaultContext;
   i = null;
+  n = defaultContext;
+  j = null;
   e = null;
   constructor(signal = false) {
     if (currentOwner && !signal)
@@ -69,8 +121,8 @@ var Owner = class {
     if (child.n !== this.n) {
       child.n = { ...this.n, ...child.n };
     }
-    if (this.i) {
-      child.i = !child.i ? this.i : [...child.i, ...this.i];
+    if (this.j) {
+      child.j = !child.j ? this.j : [...child.j, ...this.j];
     }
     if (this.e)
       child.e = this.e;
@@ -99,30 +151,30 @@ var Owner = class {
     this.o = null;
     this.p = null;
     this.n = defaultContext;
-    this.i = null;
+    this.j = null;
     this.a = STATE_DISPOSED;
     this.emptyDisposal();
   }
   emptyDisposal() {
-    if (!this.h)
+    if (!this.i)
       return;
-    if (Array.isArray(this.h)) {
-      for (let i = 0; i < this.h.length; i++) {
-        const callable = this.h[i];
+    if (Array.isArray(this.i)) {
+      for (let i = 0; i < this.i.length; i++) {
+        const callable = this.i[i];
         callable.call(callable);
       }
     } else {
-      this.h.call(this.h);
+      this.i.call(this.i);
     }
-    this.h = null;
+    this.i = null;
   }
   handleError(error) {
-    if (!this.i)
+    if (!this.j)
       throw error;
-    let i = 0, len = this.i.length;
+    let i = 0, len = this.j.length;
     for (i = 0; i < len; i++) {
       try {
-        this.i[i](error);
+        this.j[i](error);
         break;
       } catch (e) {
         error = e;
@@ -161,12 +213,12 @@ function onCleanup(fn) {
   if (!currentOwner)
     return fn;
   const node = currentOwner;
-  if (!node.h) {
-    node.h = fn;
-  } else if (Array.isArray(node.h)) {
-    node.h.push(fn);
+  if (!node.i) {
+    node.i = fn;
+  } else if (Array.isArray(node.i)) {
+    node.i.push(fn);
   } else {
-    node.h = [node.h, fn];
+    node.i = [node.i, fn];
   }
   return fn;
 }
@@ -195,10 +247,10 @@ function incrementClock() {
 }
 var UNCHANGED = Symbol(0);
 var Computation = class extends Owner {
-  b = null;
   c = null;
+  b = null;
   d;
-  E;
+  B;
   // Used in __DEV__ mode, hopefully removed in production
   V;
   // Using false is an optimization as an alternative to _equals: () => false
@@ -206,15 +258,15 @@ var Computation = class extends Owner {
   F = isEqual;
   N;
   /** Whether the computation is an error or has ancestors that are unresolved */
-  j = 0;
+  f = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
-  A = DEFAULT_FLAGS;
+  C = DEFAULT_FLAGS;
   G = null;
   H = null;
   I = -1;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
-    this.E = compute2;
+    this.B = compute2;
     this.a = compute2 ? STATE_UNINITIALIZED : STATE_CLEAN;
     this.d = initialValue;
     if (options?.equals !== void 0)
@@ -223,12 +275,12 @@ var Computation = class extends Owner {
       this.N = options?.unobserved;
   }
   O() {
-    if (this.E)
+    if (this.B)
       this.s();
-    if (!this.b || this.b.length)
+    if (!this.B || this.c?.length)
       track(this);
-    newFlags |= this.j & ~currentMask;
-    if (this.j & ERROR_BIT) {
+    newFlags |= this.f & ~currentMask;
+    if (this.f & ERROR_BIT) {
       throw this.d;
     } else {
       return this.d;
@@ -283,15 +335,15 @@ var Computation = class extends Owner {
     const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this.a === STATE_UNINITIALIZED || this.F === false || !this.F(this.d, newValue));
     if (valueChanged)
       this.d = newValue;
-    const changedFlagsMask = this.j ^ flags, changedFlags = changedFlagsMask & flags;
-    this.j = flags;
+    const changedFlagsMask = this.f ^ flags, changedFlags = changedFlagsMask & flags;
+    this.f = flags;
     this.I = clock + 1;
-    if (this.c) {
-      for (let i = 0; i < this.c.length; i++) {
+    if (this.b) {
+      for (let i = 0; i < this.b.length; i++) {
         if (valueChanged) {
-          this.c[i].t(STATE_DIRTY);
+          this.b[i].t(STATE_DIRTY);
         } else if (changedFlagsMask) {
-          this.c[i].P(changedFlagsMask, changedFlags);
+          this.b[i].P(changedFlagsMask, changedFlags);
         }
       }
     }
@@ -304,9 +356,9 @@ var Computation = class extends Owner {
     if (this.a >= state)
       return;
     this.a = state;
-    if (this.c) {
-      for (let i = 0; i < this.c.length; i++) {
-        this.c[i].t(STATE_CHECK);
+    if (this.b) {
+      for (let i = 0; i < this.b.length; i++) {
+        this.b[i].t(STATE_CHECK);
       }
     }
   }
@@ -319,27 +371,27 @@ var Computation = class extends Owner {
   P(mask, newFlags2) {
     if (this.a >= STATE_DIRTY)
       return;
-    if (mask & this.A) {
+    if (mask & this.C) {
       this.t(STATE_DIRTY);
       return;
     }
     if (this.a >= STATE_CHECK)
       return;
-    const prevFlags = this.j & mask;
+    const prevFlags = this.f & mask;
     const deltaFlags = prevFlags ^ newFlags2;
     if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
       this.t(STATE_CHECK);
     } else {
-      this.j ^= deltaFlags;
-      if (this.c) {
-        for (let i = 0; i < this.c.length; i++) {
-          this.c[i].P(mask, newFlags2);
+      this.f ^= deltaFlags;
+      if (this.b) {
+        for (let i = 0; i < this.b.length; i++) {
+          this.b[i].P(mask, newFlags2);
         }
       }
     }
   }
   Q(error) {
-    this.write(error, this.j | ERROR_BIT);
+    this.write(error, this.f | ERROR_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -357,9 +409,9 @@ 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].s();
-        observerFlags |= this.b[i].j;
+      for (let i = 0; i < this.c.length; i++) {
+        this.c[i].s();
+        observerFlags |= this.c[i].f;
         if (this.a === STATE_DIRTY) {
           break;
         }
@@ -378,7 +430,7 @@ var Computation = class extends Owner {
   x() {
     if (this.a === STATE_DISPOSED)
       return;
-    if (this.b)
+    if (this.c)
       removeSourceObservers(this, 0);
     super.x();
   }
@@ -391,11 +443,11 @@ function loadingState(node) {
     () => {
       track(node);
       node.s();
-      return !!(node.j & LOADING_BIT);
+      return !!(node.f & LOADING_BIT);
     },
     options
   );
-  computation.A = ERROR_BIT | LOADING_BIT;
+  computation.C = ERROR_BIT | LOADING_BIT;
   setOwner(prevOwner);
   return computation;
 }
@@ -407,17 +459,17 @@ function errorState(node) {
     () => {
       track(node);
       node.s();
-      return !!(node.j & ERROR_BIT);
+      return !!(node.f & ERROR_BIT);
     },
     options
   );
-  computation.A = ERROR_BIT;
+  computation.C = ERROR_BIT;
   setOwner(prevOwner);
   return computation;
 }
 function track(computation) {
   if (currentObserver) {
-    if (!newSources && currentObserver.b && currentObserver.b[newSourcesIndex] === computation) {
+    if (!newSources && currentObserver.c && currentObserver.c[newSourcesIndex] === computation) {
       newSourcesIndex++;
     } else if (!newSources)
       newSources = [computation];
@@ -437,7 +489,7 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.E, node);
+    const result = compute(node, node.B, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
@@ -447,27 +499,27 @@ function update(node) {
     }
   } finally {
     if (newSources) {
-      if (node.b)
+      if (node.c)
         removeSourceObservers(node, newSourcesIndex);
-      if (node.b && newSourcesIndex > 0) {
-        node.b.length = newSourcesIndex + newSources.length;
+      if (node.c && newSourcesIndex > 0) {
+        node.c.length = newSourcesIndex + newSources.length;
         for (let i = 0; i < newSources.length; i++) {
-          node.b[newSourcesIndex + i] = newSources[i];
+          node.c[newSourcesIndex + i] = newSources[i];
         }
       } else {
-        node.b = newSources;
+        node.c = newSources;
       }
       let source;
-      for (let i = newSourcesIndex; i < node.b.length; i++) {
-        source = node.b[i];
-        if (!source.c)
-          source.c = [node];
+      for (let i = newSourcesIndex; i < node.c.length; i++) {
+        source = node.c[i];
+        if (!source.b)
+          source.b = [node];
         else
-          source.c.push(node);
+          source.b.push(node);
       }
-    } else if (node.b && newSourcesIndex < node.b.length) {
+    } else if (node.c && newSourcesIndex < node.c.length) {
       removeSourceObservers(node, newSourcesIndex);
-      node.b.length = newSourcesIndex;
+      node.c.length = newSourcesIndex;
     }
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
@@ -478,13 +530,13 @@ function update(node) {
 function removeSourceObservers(node, index) {
   let source;
   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)
+  for (let i = index; i < node.c.length; i++) {
+    source = node.c[i];
+    if (source.b) {
+      swap = source.b.indexOf(node);
+      source.b[swap] = source.b[source.b.length - 1];
+      source.b.pop();
+      if (!source.b.length)
         source.N?.();
     }
   }
@@ -529,7 +581,7 @@ function latest(fn) {
 function compute(owner, compute2, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask;
   currentObserver = observer;
-  currentMask = observer?.A ?? DEFAULT_FLAGS;
+  currentMask = observer?.C ?? DEFAULT_FLAGS;
   try {
     return compute2(observer ? observer.d : void 0);
   } finally {
@@ -545,11 +597,11 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.B)
+  if (!globalQueue.D)
     queueMicrotask(flushSync);
 }
 var Queue = class {
-  B = false;
+  D = false;
   u = [[], [], []];
   z = [];
   enqueue(type, node) {
@@ -574,9 +626,9 @@ var Queue = class {
     }
   }
   flush() {
-    if (this.B)
+    if (this.D)
       return;
-    this.B = true;
+    this.D = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
@@ -584,7 +636,7 @@ var Queue = class {
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.B = false;
+      this.D = false;
     }
   }
   addChild(child) {
@@ -597,11 +649,19 @@ var Queue = class {
   }
 };
 var globalQueue = new Queue();
+var globalTasks = [];
 function flushSync() {
   while (scheduled) {
     globalQueue.flush();
+    for (let i = 0; i < globalTasks.length; i++)
+      globalTasks[i]();
+    globalTasks.length = 0;
   }
 }
+function queueTask(fn) {
+  globalTasks.push(fn);
+  schedule();
+}
 function createBoundary(fn, queue) {
   const owner = new Owner();
   const parentQueue = owner.e || globalQueue;
@@ -636,23 +696,23 @@ function runEffectQueue(queue) {
 var Effect = class extends Computation {
   J;
   K = false;
-  C;
-  D;
+  E;
+  A;
   e;
   constructor(initialValue, compute2, effect, options) {
     super(initialValue, compute2, options);
     this.J = effect;
-    this.C = initialValue;
-    this.D = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    this.E = initialValue;
+    this.A = options?.render ? EFFECT_RENDER : EFFECT_USER;
     this.e = getOwner()?.e || globalQueue;
     this.s();
-    this.D === EFFECT_USER ? this.e.enqueue(this.D, this) : this.R();
+    this.A === EFFECT_USER ? this.e.enqueue(this.A, this) : this.R();
   }
   write(value, flags = 0) {
-    const currentFlags = this.j;
-    this.j = flags;
-    if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this.e.T?.(this);
+    const currentFlags = this.f;
+    this.f = flags;
+    if (this.A === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+      this.e.S?.(this);
     }
     if (value === UNCHANGED)
       return this.d;
@@ -664,7 +724,7 @@ var Effect = class extends Computation {
     if (this.a >= state)
       return;
     if (this.a === STATE_CLEAN)
-      this.e.enqueue(this.D, this);
+      this.e.enqueue(this.A, this);
     this.a = state;
   }
   Q(error) {
@@ -672,13 +732,13 @@ var Effect = class extends Computation {
   }
   x() {
     this.J = void 0;
-    this.C = void 0;
+    this.E = void 0;
     super.x();
   }
   R() {
     if (this.K && this.a !== STATE_DISPOSED) {
-      this.J(this.d, this.C);
-      this.C = this.d;
+      this.J(this.d, this.E);
+      this.E = this.d;
       this.K = false;
     }
   }
@@ -701,7 +761,7 @@ var EagerComputation = class extends Computation {
 
 // src/core/suspense.ts
 var SuspenseQueue = class extends Queue {
-  f = /* @__PURE__ */ new Set();
+  g = /* @__PURE__ */ new Set();
   q = false;
   L = new Computation(false, null);
   run(type) {
@@ -709,27 +769,40 @@ var SuspenseQueue = class extends Queue {
       return;
     super.run(type);
   }
-  T(node) {
-    if (node.j & LOADING_BIT) {
-      this.f.add(node);
+  S(node) {
+    if (node.f & LOADING_BIT) {
+      this.g.add(node);
       if (!this.q) {
         this.q = true;
-        queueMicrotask(() => this.L.write(true));
+        queueTask(() => this.L.write(true));
       }
     } else {
-      this.f.delete(node);
-      if (this.f.size === 0) {
+      this.g.delete(node);
+      if (this.g.size === 0) {
         this.q = false;
-        queueMicrotask(() => this.L.write(false));
+        queueTask(() => this.L.write(false));
       }
     }
   }
 };
+var LiveComputation = class extends EagerComputation {
+  write(value, flags = 0) {
+    const currentFlags = this.f;
+    super.write(value, flags);
+    if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+      this.e.S?.(this);
+    }
+    return this.d;
+  }
+};
 function createSuspense(fn, fallbackFn) {
   const queue = new SuspenseQueue();
-  const tree = createBoundary(fn, queue);
+  const tree = createBoundary(() => {
+    const child = new Computation(null, fn);
+    return new LiveComputation(null, () => flatten(child.wait()));
+  }, queue);
   const equality = new Computation(null, () => queue.L.read() || queue.q);
-  const comp = new Computation(null, () => equality.read() ? untrack(fallbackFn) : tree);
+  const comp = new Computation(null, () => equality.read() ? untrack(fallbackFn) : tree.read());
   return comp.read.bind(comp);
 }
 
@@ -759,10 +832,10 @@ function createMemo(compute2, value, options) {
   return () => {
     if (node) {
       resolvedValue = node.wait();
-      if (!node.b?.length) {
+      if (!node.c?.length && node.m?.o !== node) {
         node.dispose();
         node = void 0;
-      } else if (!node.o && !node.c?.length) {
+      } else if (!node.o && !node.b?.length) {
         node.dispose();
         node.a = STATE_UNINITIALIZED;
       }
@@ -793,7 +866,7 @@ function createAsync(compute2, value, options) {
       if (isPromise) {
         source.then(
           (value3) => {
-            signal.write(value3, 0);
+            signal.write(value3, 0, true);
           },
           (error) => {
             signal.write(error, ERROR_BIT);
@@ -807,7 +880,7 @@ function createAsync(compute2, value, options) {
             for await (let value3 of source) {
               if (abort)
                 return;
-              signal.write(value3, 0);
+              signal.write(value3, 0, true);
             }
           } catch (error) {
             signal.write(error, ERROR_BIT);
@@ -847,9 +920,9 @@ function runWithOwner(owner, run) {
 }
 function catchError(fn, handler) {
   const owner = new Owner();
-  owner.i = owner.i ? [handler, ...owner.i] : [handler];
+  owner.j = owner.j ? [handler, ...owner.j] : [handler];
   try {
-    compute(owner, fn, null);
+    return compute(owner, fn, null);
   } catch (error) {
     owner.handleError(error);
   }
@@ -1314,15 +1387,15 @@ function omit(props, ...keys) {
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return updateKeyedMap.bind({
-    S: new Owner(),
+    T: new Owner(),
     w: 0,
     U: list,
     r: [],
     M: map,
     k: [],
-    f: [],
+    g: [],
     y: keyFn,
-    g: keyFn || options?.keyed === false ? [] : void 0,
+    h: keyFn || options?.keyed === false ? [] : void 0,
     l: map.length > 1 ? [] : void 0,
     q: options?.fallback
   });
@@ -1330,12 +1403,12 @@ function mapArray(list, map, options) {
 function updateKeyedMap() {
   const newItems = this.U() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.S, () => {
-    let i, j, mapper = this.g ? () => {
-      this.g[j] = new Computation(newItems[j], null);
+  runWithOwner(this.T, () => {
+    let i, j, mapper = this.h ? () => {
+      this.h[j] = new Computation(newItems[j], null);
       this.l[j] = new Computation(j, null);
       return this.M(
-        Computation.prototype.read.bind(this.g[j]),
+        Computation.prototype.read.bind(this.h[j]),
         Computation.prototype.read.bind(this.l[j])
       );
     } : this.l ? () => {
@@ -1348,40 +1421,40 @@ function updateKeyedMap() {
     };
     if (newLen === 0) {
       if (this.w !== 0) {
-        this.S.dispose(false);
-        this.f = [];
+        this.T.dispose(false);
+        this.g = [];
         this.r = [];
         this.k = [];
         this.w = 0;
-        this.g && (this.g = []);
+        this.h && (this.h = []);
         this.l && (this.l = []);
       }
       if (this.q && !this.k[0]) {
         this.k[0] = compute(
-          this.f[0] = new Owner(),
+          this.g[0] = new Owner(),
           this.q,
           null
         );
       }
     } else if (this.w === 0) {
-      if (this.f[0])
-        this.f[0].dispose();
+      if (this.g[0])
+        this.g[0].dispose();
       this.k = new Array(newLen);
       for (j = 0; j < newLen; j++) {
         this.r[j] = newItems[j];
-        this.k[j] = compute(this.f[j] = new Owner(), mapper, null);
+        this.k[j] = compute(this.g[j] = new Owner(), mapper, null);
       }
       this.w = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.g ? new Array(newLen) : void 0, tempIndexes = this.l ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.w, newLen); start < end && (this.r[start] === newItems[start] || this.g && compare(this.y, this.r[start], newItems[start])); start++) {
-        if (this.g)
-          this.g[start].write(newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.h ? new Array(newLen) : void 0, tempIndexes = this.l ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.w, newLen); start < end && (this.r[start] === newItems[start] || this.h && compare(this.y, this.r[start], newItems[start])); start++) {
+        if (this.h)
+          this.h[start].write(newItems[start]);
       }
-      for (end = this.w - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.r[end] === newItems[newEnd] || this.g && compare(this.y, this.r[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.w - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.r[end] === newItems[newEnd] || this.h && compare(this.y, this.r[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.k[end];
-        tempNodes[newEnd] = this.f[end];
-        tempRows && (tempRows[newEnd] = this.g[end]);
+        tempNodes[newEnd] = this.g[end];
+        tempRows && (tempRows[newEnd] = this.h[end]);
         tempIndexes && (tempIndexes[newEnd] = this.l[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
@@ -1399,28 +1472,28 @@ function updateKeyedMap() {
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
           temp[j] = this.k[i];
-          tempNodes[j] = this.f[i];
-          tempRows && (tempRows[j] = this.g[i]);
+          tempNodes[j] = this.g[i];
+          tempRows && (tempRows[j] = this.h[i]);
           tempIndexes && (tempIndexes[j] = this.l[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.f[i].dispose();
+          this.g[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
           this.k[j] = temp[j];
-          this.f[j] = tempNodes[j];
+          this.g[j] = tempNodes[j];
           if (tempRows) {
-            this.g[j] = tempRows[j];
-            this.g[j].write(newItems[j]);
+            this.h[j] = tempRows[j];
+            this.h[j].write(newItems[j]);
           }
           if (tempIndexes) {
             this.l[j] = tempIndexes[j];
             this.l[j].write(j);
           }
         } else {
-          this.k[j] = compute(this.f[j] = new Owner(), mapper, null);
+          this.k[j] = compute(this.g[j] = new Owner(), mapper, null);
         }
       }
       this.k = this.k.slice(0, this.w = newLen);
@@ -1433,4 +1506,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, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };