@solidjs/signals 0.0.7 → 0.0.9

package/dist/dev.js

@@ -13,13 +13,21 @@ var ContextNotFoundError = class extends Error {
     );
   }
 };
+var EffectError = class extends Error {
+  constructor(effect, cause) {
+    super(`Uncaught error while running effect:
+
+  ${effect.toString()}
+` );
+    this.cause = cause;
+  }
+};
 
 // src/core/constants.ts
 var STATE_CLEAN = 0;
 var STATE_CHECK = 1;
 var STATE_DIRTY = 2;
-var STATE_UNINITIALIZED = 3;
-var STATE_DISPOSED = 4;
+var STATE_DISPOSED = 3;
 var EFFECT_PURE = 0;
 var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
@@ -228,6 +236,8 @@ var ERROR_OFFSET = 0;
 var ERROR_BIT = 1 << ERROR_OFFSET;
 var LOADING_OFFSET = 1;
 var LOADING_BIT = 1 << LOADING_OFFSET;
+var UNINITIALIZED_OFFSET = 2;
+var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
 var DEFAULT_FLAGS = ERROR_BIT;
 
 // src/core/core.ts
@@ -237,11 +247,15 @@ var newSources = null;
 var newSourcesIndex = 0;
 var newFlags = 0;
 var clock = 0;
-var syncResolve = false;
+var notStale = false;
 var updateCheck = null;
+var staleCheck = null;
 function getObserver() {
   return currentObserver;
 }
+function getClock() {
+  return clock;
+}
 function incrementClock() {
   clock++;
 }
@@ -250,6 +264,7 @@ var Computation = class extends Owner {
   _sources = null;
   _observers = null;
   _value;
+  _error;
   _compute;
   // Used in __DEV__ mode, hopefully removed in production
   _name;
@@ -261,13 +276,14 @@ var Computation = class extends Owner {
   _stateFlags = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   _handlerMask = DEFAULT_FLAGS;
-  _error = null;
   _loading = null;
   _time = -1;
+  _forceNotify = false;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
     this._compute = compute2;
-    this._state = compute2 ? STATE_UNINITIALIZED : STATE_CLEAN;
+    this._state = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this._stateFlags = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
     this._value = initialValue;
     this._name = options?.name ?? (this._compute ? "computed" : "signal");
     if (options?.equals !== void 0)
@@ -282,7 +298,7 @@ var Computation = class extends Owner {
       track(this);
     newFlags |= this._stateFlags & ~currentMask;
     if (this._stateFlags & ERROR_BIT) {
-      throw this._value;
+      throw this._error;
     } else {
       return this._value;
     }
@@ -302,9 +318,14 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (!syncResolve && this.loading()) {
+    if (this._compute && this._stateFlags & ERROR_BIT && this._time <= clock) {
+      update(this);
+    }
+    if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this.loading()) {
       throw new NotReadyError();
     }
+    if (staleCheck && this._stateFlags & LOADING_BIT)
+      staleCheck._value = true;
     return this._read();
   }
   /**
@@ -320,22 +341,14 @@ var Computation = class extends Owner {
     }
     return this._loading.read();
   }
-  /**
-   * Return true if the computation is the computation threw an error
-   * Triggers re-execution of the computation when the error state changes
-   */
-  error() {
-    if (this._error === null) {
-      this._error = errorState(this);
-    }
-    return this._error.read();
-  }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this._value) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this._state === STATE_UNINITIALIZED || this._equals === false || !this._equals(this._value, newValue));
-    if (valueChanged)
+    const valueChanged = newValue !== UNCHANGED && (!!(this._stateFlags & UNINITIALIZED_BIT) || this._equals === false || !this._equals(this._value, newValue));
+    if (valueChanged) {
       this._value = newValue;
+      this._error = void 0;
+    }
     const changedFlagsMask = this._stateFlags ^ flags, changedFlags = changedFlagsMask & flags;
     this._stateFlags = flags;
     this._time = clock + 1;
@@ -353,13 +366,14 @@ var Computation = class extends Owner {
   /**
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
-  _notify(state) {
-    if (this._state >= state)
+  _notify(state, skipQueue) {
+    if (this._state >= state && !this._forceNotify)
       return;
+    this._forceNotify = !!skipQueue;
     this._state = state;
     if (this._observers) {
       for (let i = 0; i < this._observers.length; i++) {
-        this._observers[i]._notify(STATE_CHECK);
+        this._observers[i]._notify(STATE_CHECK, skipQueue);
       }
     }
   }
@@ -392,7 +406,8 @@ var Computation = class extends Owner {
     }
   }
   _setError(error) {
-    this.write(error, this._stateFlags | ERROR_BIT);
+    this._error = error;
+    this.write(UNCHANGED, this._stateFlags & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
   }
   /**
    * This is the core part of the reactivity system, which makes sure that the values are updated
@@ -418,7 +433,7 @@ var Computation = class extends Owner {
         }
       }
     }
-    if (this._state === STATE_DIRTY || this._state === STATE_UNINITIALIZED) {
+    if (this._state === STATE_DIRTY) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
@@ -452,22 +467,6 @@ function loadingState(node) {
   setOwner(prevOwner);
   return computation;
 }
-function errorState(node) {
-  const prevOwner = setOwner(node._parent);
-  const options = { name: node._name ? `error ${node._name}` : "error" } ;
-  const computation = new Computation(
-    void 0,
-    () => {
-      track(node);
-      node._updateIfNecessary();
-      return !!(node._stateFlags & ERROR_BIT);
-    },
-    options
-  );
-  computation._handlerMask = ERROR_BIT;
-  setOwner(prevOwner);
-  return computation;
-}
 function track(computation) {
   if (currentObserver) {
     if (!newSources && currentObserver._sources && currentObserver._sources[newSourcesIndex] === computation) {
@@ -494,7 +493,7 @@ function update(node) {
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
-      node.write(UNCHANGED, newFlags | LOADING_BIT);
+      node.write(UNCHANGED, newFlags | LOADING_BIT | node._stateFlags & UNINITIALIZED_BIT);
     } else {
       node._setError(error);
     }
@@ -525,6 +524,7 @@ function update(node) {
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
+    node._time = clock + 1;
     node._state = STATE_CLEAN;
   }
 }
@@ -560,35 +560,50 @@ function hasUpdated(fn) {
     updateCheck = current;
   }
 }
-function isPending(fn) {
+function isStale(fn) {
+  const current = staleCheck;
+  staleCheck = { _value: false };
   try {
-    fn();
-    return false;
-  } catch (e) {
-    return e instanceof NotReadyError;
+    latest(fn);
+    return staleCheck._value;
+  } catch {
+  } finally {
+    staleCheck = current;
   }
+  return false;
 }
 function latest(fn) {
   const prevFlags = newFlags;
-  syncResolve = true;
+  const prevNotStale = notStale;
+  notStale = false;
   try {
     return fn();
-  } catch {
   } finally {
     newFlags = prevFlags;
-    syncResolve = false;
+    notStale = prevNotStale;
+  }
+}
+function catchError(fn) {
+  try {
+    fn();
+  } catch (e) {
+    if (e instanceof NotReadyError)
+      throw e;
+    return e;
   }
 }
-function compute(owner, compute2, observer) {
-  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask;
+function compute(owner, fn, observer) {
+  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
   currentMask = observer?._handlerMask ?? DEFAULT_FLAGS;
+  notStale = true;
   try {
-    return compute2(observer ? observer._value : void 0);
+    return fn(observer ? observer._value : void 0);
   } finally {
     setOwner(prevOwner);
     currentObserver = prevObserver;
     currentMask = prevMask;
+    notStale = prevNotStale;
   }
 }
 
@@ -636,7 +651,6 @@ var Queue = class {
     try {
       while (this.run(EFFECT_PURE)) {
       }
-      ;
       incrementClock();
       scheduled = false;
       this.run(EFFECT_RENDER);
@@ -655,22 +669,14 @@ var Queue = class {
   }
 };
 var globalQueue = new Queue();
-var globalTasks = [];
 function flushSync() {
   let count = 0;
   while (scheduled) {
     if (++count === 1e5)
       throw new Error("Potential Infinite Loop Detected.");
     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._queue || globalQueue;
@@ -704,26 +710,36 @@ function runEffectQueue(queue) {
 // src/core/effect.ts
 var Effect = class extends Computation {
   _effect;
+  _onerror;
+  _cleanup;
   _modified = false;
   _prevValue;
   _type;
   _queue;
-  constructor(initialValue, compute2, effect, options) {
+  constructor(initialValue, compute2, effect, error, options) {
     super(initialValue, compute2, options);
     this._effect = effect;
+    this._onerror = error;
     this._prevValue = initialValue;
     this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    if (this._type === EFFECT_RENDER) {
+      this._compute = (p) => latest(() => compute2(p));
+    }
     this._queue = getOwner()?._queue || globalQueue;
-    this._updateIfNecessary();
-    this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
+    if (!options?.defer) {
+      this._updateIfNecessary();
+      this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
+    }
     if (!this._parent)
       console.warn("Effects created outside a reactive context will never be disposed");
   }
   write(value, flags = 0) {
-    const currentFlags = this._stateFlags;
-    this._stateFlags = flags;
-    if (this._type === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this._queue._update?.(this);
+    if (this._state == STATE_DIRTY) {
+      const currentFlags = this._stateFlags;
+      this._stateFlags = flags;
+      if (this._type === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+        this._queue._update?.(this);
+      }
     }
     if (value === UNCHANGED)
       return this._value;
@@ -731,26 +747,49 @@ var Effect = class extends Computation {
     this._modified = true;
     return value;
   }
-  _notify(state) {
-    if (this._state >= state)
+  _notify(state, skipQueue) {
+    if (this._state >= state || skipQueue)
       return;
     if (this._state === STATE_CLEAN)
       this._queue.enqueue(this._type, this);
     this._state = state;
   }
   _setError(error) {
+    this._cleanup?.();
+    if (this._stateFlags & LOADING_BIT) {
+      this._stateFlags = 0;
+      this._queue._update?.(this);
+    }
+    if (this._type === EFFECT_USER) {
+      try {
+        return this._onerror ? this._cleanup = this._onerror(error) : console.error(new EffectError(this._effect, error));
+      } catch (e) {
+        error = e;
+      }
+    }
     this.handleError(error);
   }
   _disposeNode() {
+    if (this._state === STATE_DISPOSED)
+      return;
     this._effect = void 0;
     this._prevValue = void 0;
+    this._onerror = void 0;
+    this._cleanup?.();
+    this._cleanup = void 0;
     super._disposeNode();
   }
   _runEffect() {
     if (this._modified && this._state !== STATE_DISPOSED) {
-      this._effect(this._value, this._prevValue);
-      this._prevValue = this._value;
-      this._modified = false;
+      this._cleanup?.();
+      try {
+        this._cleanup = this._effect(this._value, this._prevValue);
+      } catch (e) {
+        this.handleError(e);
+      } finally {
+        this._prevValue = this._value;
+        this._modified = false;
+      }
     }
   }
 };
@@ -763,12 +802,28 @@ var EagerComputation = class extends Computation {
     if (!this._parent)
       console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
-  _notify(state) {
-    if (this._state >= state)
+  _notify(state, skipQueue) {
+    if (this._state >= state && !this._forceNotify)
       return;
-    if (this._state === STATE_CLEAN)
+    if (this._state === STATE_CLEAN && !skipQueue)
+      this._queue.enqueue(EFFECT_PURE, this);
+    super._notify(state, skipQueue);
+  }
+};
+var ProjectionComputation = class extends Computation {
+  _queue;
+  constructor(compute2) {
+    super(null, compute2);
+    this._queue = getOwner()?._queue || globalQueue;
+    if (!this._parent)
+      console.warn("Eager Computations created outside a reactive context will never be disposed");
+  }
+  _notify(state, skipQueue) {
+    if (this._state >= state && !this._forceNotify)
+      return;
+    if (this._state === STATE_CLEAN && !skipQueue)
       this._queue.enqueue(EFFECT_PURE, this);
-    super._notify(state);
+    super._notify(state, true);
   }
 };
 
@@ -787,13 +842,13 @@ var SuspenseQueue = class extends Queue {
       this._nodes.add(node);
       if (!this._fallback) {
         this._fallback = true;
-        queueTask(() => this._signal.write(true));
+        this._signal.write(true);
       }
     } else {
       this._nodes.delete(node);
       if (this._nodes.size === 0) {
         this._fallback = false;
-        queueTask(() => this._signal.write(false));
+        this._signal.write(false);
       }
     }
   }
@@ -850,13 +905,14 @@ function createMemo(compute2, value, options) {
         node = void 0;
       } else if (!node._parent && !node._observers?.length) {
         node.dispose();
-        node._state = STATE_UNINITIALIZED;
+        node._state = STATE_DIRTY;
       }
     }
     return resolvedValue;
   };
 }
 function createAsync(compute2, value, options) {
+  let uninitialized = value === void 0;
   const lhs = new EagerComputation(
     {
       _value: value
@@ -875,14 +931,24 @@ function createAsync(compute2, value, options) {
         };
       }
       const signal = new Computation(value2, null, options);
-      signal.write(UNCHANGED, LOADING_BIT);
+      const w = signal.wait;
+      signal.wait = function() {
+        if (signal._stateFlags & ERROR_BIT && signal._time <= getClock()) {
+          lhs._notify(STATE_DIRTY);
+          throw new NotReadyError();
+        }
+        return w.call(this);
+      };
+      signal.write(UNCHANGED, LOADING_BIT | (uninitialized ? UNINITIALIZED_BIT : 0));
       if (isPromise) {
         source.then(
           (value3) => {
+            uninitialized = false;
             signal.write(value3, 0, true);
           },
           (error) => {
-            signal.write(error, ERROR_BIT);
+            uninitialized = true;
+            signal._setError(error);
           }
         );
       } else {
@@ -905,16 +971,17 @@ function createAsync(compute2, value, options) {
   );
   return () => lhs.wait().wait();
 }
-function createEffect(compute2, effect, value, options) {
+function createEffect(compute2, effect, error, value, options) {
   void new Effect(
     value,
     compute2,
     effect,
+    error,
     { name: options?.name ?? "effect" } 
   );
 }
 function createRenderEffect(compute2, effect, value, options) {
-  void new Effect(value, compute2, effect, {
+  void new Effect(value, compute2, effect, void 0, {
     render: true,
     ...{ name: options?.name ?? "effect" } 
   });
@@ -962,6 +1029,62 @@ function createErrorBoundary(fn, fallback) {
   });
   return decision.read.bind(decision);
 }
+function resolve(fn) {
+  return new Promise((res, rej) => {
+    let node = new EagerComputation(void 0, () => {
+      try {
+        res(fn());
+      } catch (err) {
+        if (err instanceof NotReadyError)
+          throw err;
+        rej(err);
+      }
+      node.dispose(true);
+    });
+  });
+}
+function createReaction(effect, error, options) {
+  const node = new Effect(void 0, () => {
+  }, effect, error, {
+    defer: true,
+    ...{ name: options?.name ?? "reaction" } 
+  });
+  return (tracking) => {
+    node._compute = tracking;
+    node._state = STATE_DIRTY;
+    node._updateIfNecessary();
+    node._compute = null;
+  };
+}
+
+// src/store/projection.ts
+function createProjection(fn, initialValue = {}) {
+  const [store, setStore] = createStore(initialValue);
+  const node = new ProjectionComputation(() => {
+    setStore(fn);
+  });
+  const wrapped = /* @__PURE__ */ new WeakMap();
+  return wrap(store, node, wrapped);
+}
+function wrap(source, node, wrapped) {
+  if (wrapped.has(source))
+    return wrapped.get(source);
+  const wrap3 = new Proxy(source, {
+    get(target, property) {
+      node.read();
+      const v = target[property];
+      return isWrappable(v) ? wrap3(v, node, wrapped) : v;
+    },
+    set() {
+      throw new Error("Projections are readonly");
+    },
+    deleteProperty() {
+      throw new Error("Projections are readonly");
+    }
+  });
+  wrapped.set(source, wrap3);
+  return wrap3;
+}
 
 // src/store/store.ts
 var $RAW = Symbol("STORE_RAW" );
@@ -971,7 +1094,7 @@ var $PROXY = Symbol("STORE_PROXY" );
 var STORE_VALUE = "v";
 var STORE_NODE = "n";
 var STORE_HAS = "h";
-function wrap(value) {
+function wrap2(value) {
   let p = value[$PROXY];
   if (!p) {
     let target;
@@ -1080,7 +1203,7 @@ var proxyTraps = {
     }
     if (Writing.has(storeValue)) {
       const value2 = tracked ? tracked._value : storeValue[property];
-      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap(value2)) : value2;
+      return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
     let value = tracked ? nodes[property].read() : storeValue[property];
     if (!tracked) {
@@ -1088,10 +1211,10 @@ var proxyTraps = {
         let proto;
         return !Array.isArray(storeValue) && (proto = Object.getPrototypeOf(storeValue)) && proto !== Object.prototype ? value.bind(storeValue) : value;
       } else if (getObserver()) {
-        value = getNode(nodes, property, isWrappable(value) ? wrap(value) : value).read();
+        value = getNode(nodes, property, isWrappable(value) ? wrap2(value) : value).read();
       }
     }
-    return isWrappable(value) ? wrap(value) : value;
+    return isWrappable(value) ? wrap2(value) : value;
   },
   has(target, property) {
     if (property === $RAW || property === $PROXY || property === $TRACK || property === "__proto__")
@@ -1133,13 +1256,16 @@ function setProperty(state, property, value, deleting = false) {
   const nodes = getNodes(target, STORE_NODE);
   let node;
   if (node = nodes[property])
-    node.write(isWrappable(value) ? wrap(value) : value);
+    node.write(isWrappable(value) ? wrap2(value) : value);
   Array.isArray(state) && state.length !== len && (node = nodes.length) && node.write(state.length);
   (node = nodes[$TRACK]) && node.write(void 0);
 }
 function createStore(first, second) {
-  const derived = typeof first === "function", store = derived ? second : first, unwrappedStore = unwrap(store, false);
-  const wrappedStore = wrap(unwrappedStore);
+  const derived = typeof first === "function", store = derived ? second : first;
+  if (derived)
+    return createProjection(first, store);
+  const unwrappedStore = unwrap(store, false);
+  const wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
     try {
       Writing.add(unwrappedStore);
@@ -1148,15 +1274,8 @@ function createStore(first, second) {
       Writing.clear();
     }
   };
-  if (derived) {
-    new EagerComputation(void 0, () => setStore(first));
-  }
   return [wrappedStore, setStore];
 }
-function createProjection(fn, initialValue = {}) {
-  const [store] = createStore(fn, initialValue);
-  return store;
-}
 
 // src/store/reconcile.ts
 function applyState(next, state, keyFn) {
@@ -1177,7 +1296,7 @@ function applyState(next, state, keyFn) {
     if (next.length && previous.length && next[0] && keyFn(next[0]) != null) {
       let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
       for (start = 0, end = Math.min(previous.length, next.length); start < end && (previous[start] === next[start] || previous[start] && next[start] && keyFn(previous[start]) === keyFn(next[start])); start++) {
-        applyState(next[start], wrap(previous[start]), keyFn);
+        applyState(next[start], wrap2(previous[start]), keyFn);
       }
       const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
       for (end = previous.length - 1, newEnd = next.length - 1; end >= start && newEnd >= start && (previous[end] === next[newEnd] || previous[end] && next[newEnd] && keyFn(previous[end]) === keyFn(next[newEnd])); end--, newEnd--) {
@@ -1186,11 +1305,11 @@ function applyState(next, state, keyFn) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          target[STORE_NODE][j]?.write(wrap(next[j]));
+          target[STORE_NODE][j]?.write(wrap2(next[j]));
         }
         for (; j < next.length; j++) {
           changed = true;
-          const wrapped = wrap(temp[j]);
+          const wrapped = wrap2(temp[j]);
           target[STORE_NODE][j]?.write(wrapped);
           applyState(next[j], wrapped, keyFn);
         }
@@ -1218,17 +1337,17 @@ function applyState(next, state, keyFn) {
       }
       for (j = start; j < next.length; j++) {
         if (j in temp) {
-          const wrapped = wrap(temp[j]);
+          const wrapped = wrap2(temp[j]);
           target[STORE_NODE][j]?.write(wrapped);
           applyState(next[j], wrapped, keyFn);
         } else
-          target[STORE_NODE][j]?.write(wrap(next[j]));
+          target[STORE_NODE][j]?.write(wrap2(next[j]));
       }
       if (start < next.length)
         changed = true;
     } else if (previous.length && next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
-        isWrappable(previous[i]) && applyState(next[i], wrap(previous[i]), keyFn);
+        isWrappable(previous[i]) && applyState(next[i], wrap2(previous[i]), keyFn);
       }
     }
     if (previous.length !== next.length) {
@@ -1248,9 +1367,9 @@ function applyState(next, state, keyFn) {
       if (previousValue === nextValue)
         continue;
       if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
-        node.write(isWrappable(nextValue) ? wrap(nextValue) : nextValue);
+        node.write(isWrappable(nextValue) ? wrap2(nextValue) : nextValue);
       else
-        applyState(nextValue, wrap(previousValue), keyFn);
+        applyState(nextValue, wrap2(previousValue), keyFn);
     }
   }
   if (nodes = target[STORE_HAS]) {
@@ -1537,8 +1656,54 @@ function updateKeyedMap() {
   });
   return this._mappings;
 }
+function repeat(count, map, options) {
+  return updateRepeat.bind({
+    _owner: new Owner(),
+    _len: 0,
+    _count: count,
+    _map: map,
+    _nodes: [],
+    _mappings: [],
+    _fallback: options?.fallback
+  });
+}
+function updateRepeat() {
+  const newLen = this._count();
+  runWithOwner(this._owner, () => {
+    if (newLen === 0) {
+      if (this._len !== 0) {
+        this._owner.dispose(false);
+        this._nodes = [];
+        this._mappings = [];
+        this._len = 0;
+      }
+      if (this._fallback && !this._mappings[0]) {
+        this._mappings[0] = compute(
+          this._nodes[0] = new Owner(),
+          this._fallback,
+          null
+        );
+      }
+    } else {
+      if (this._len === 0 && this._nodes[0])
+        this._nodes[0].dispose();
+      for (let i = this._len; i < newLen; i++) {
+        this._mappings[i] = compute(
+          this._nodes[i] = new Owner(),
+          () => this._map(i),
+          null
+        );
+      }
+      for (let i = newLen; i < this._len; i++)
+        this._nodes[i].dispose();
+      this._mappings = this._mappings.slice(0, newLen);
+      this._len = newLen;
+    }
+  });
+  return this._mappings;
+}
 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, 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, 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, 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 };