@solidjs/signals 0.2.5 → 0.3.1

package/dist/dev.js

@@ -50,6 +50,7 @@ function schedule() {
     queueMicrotask(flushSync);
 }
 var Queue = class {
+  _parent = null;
   _running = false;
   _queues = [[], [], []];
   _children = [];
@@ -75,8 +76,8 @@ var Queue = class {
     for (let i = 0; i < this._children.length; i++) {
       rerun = this._children[i].run(type) || rerun;
     }
-    if (type === EFFECT_PURE && this._queues[type].length)
-      return true;
+    if (type === EFFECT_PURE)
+      return rerun || !!this._queues[type].length;
   }
   flush() {
     if (this._running)
@@ -95,12 +96,18 @@ var Queue = class {
   }
   addChild(child) {
     this._children.push(child);
+    child._parent = this;
   }
   removeChild(child) {
     const index = this._children.indexOf(child);
     if (index >= 0)
       this._children.splice(index, 1);
   }
+  notify(...args) {
+    if (this._parent)
+      return this._parent.notify(...args);
+    return false;
+  }
 };
 var globalQueue = new Queue();
 function flushSync() {
@@ -138,6 +145,26 @@ function runEffectQueue(queue) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
+function tryCatch(fn) {
+  try {
+    const v = fn();
+    if (v instanceof Promise) {
+      return v.then(
+        (v2) => [void 0, v2],
+        (e) => {
+          if (e instanceof NotReadyError)
+            throw e;
+          return [e];
+        }
+      );
+    }
+    return [void 0, v];
+  } catch (e) {
+    if (e instanceof NotReadyError)
+      throw e;
+    return [e];
+  }
+}
 
 // src/core/owner.ts
 var currentOwner = null;
@@ -150,6 +177,10 @@ function setOwner(owner) {
   currentOwner = owner;
   return out;
 }
+function formatId(prefix, id) {
+  const num = id.toString(36), len = num.length - 1;
+  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+}
 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
@@ -160,11 +191,16 @@ var Owner = class {
   _state = STATE_CLEAN;
   _disposal = null;
   _context = defaultContext;
-  _handlers = null;
   _queue = globalQueue;
-  constructor(signal = false) {
-    if (currentOwner && !signal)
-      currentOwner.append(this);
+  _childCount = 0;
+  id = null;
+  constructor(id = null, skipAppend = false) {
+    this.id = id;
+    if (currentOwner) {
+      if (!id && currentOwner.id)
+        this.id = currentOwner.getNextChildId();
+      !skipAppend && currentOwner.append(this);
+    }
   }
   append(child) {
     child._parent = this;
@@ -176,9 +212,6 @@ var Owner = class {
     if (child._context !== this._context) {
       child._context = { ...this._context, ...child._context };
     }
-    if (this._handlers) {
-      child._handlers = !child._handlers ? this._handlers : [...child._handlers, ...this._handlers];
-    }
     if (this._queue)
       child._queue = this._queue;
   }
@@ -193,6 +226,7 @@ var Owner = class {
       current._nextSibling = null;
       current = next;
     }
+    this._childCount = 0;
     if (self)
       this._disposeNode();
     if (current)
@@ -206,7 +240,6 @@ var Owner = class {
     this._parent = null;
     this._prevSibling = null;
     this._context = defaultContext;
-    this._handlers = null;
     this._state = STATE_DISPOSED;
     this.emptyDisposal();
   }
@@ -223,20 +256,10 @@ var Owner = class {
     }
     this._disposal = null;
   }
-  handleError(error) {
-    if (!this._handlers)
-      throw error;
-    let i = 0, len = this._handlers.length;
-    for (i = 0; i < len; i++) {
-      try {
-        this._handlers[i](error, this);
-        break;
-      } catch (e) {
-        error = e;
-      }
-    }
-    if (i === len)
-      throw error;
+  getNextChildId() {
+    if (this.id)
+      return formatId(this.id, this._childCount++);
+    throw new Error("Cannot get child id from owner without an id");
   }
 };
 function createContext(defaultValue, description) {
@@ -316,11 +339,10 @@ var Computation = class extends Owner {
   _stateFlags = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   _handlerMask = DEFAULT_FLAGS;
-  _loading = null;
   _time = -1;
   _forceNotify = false;
   constructor(initialValue, compute2, options) {
-    super(compute2 === null);
+    super(null, compute2 === null);
     this._compute = compute2;
     this._state = compute2 ? STATE_DIRTY : STATE_CLEAN;
     this._stateFlags = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
@@ -338,8 +360,7 @@ var Computation = class extends Owner {
       else
         this._updateIfNecessary();
     }
-    if (!this._compute || this._sources?.length)
-      track(this);
+    track(this);
     newFlags |= this._stateFlags & ~currentMask;
     if (this._stateFlags & ERROR_BIT) {
       throw this._error;
@@ -364,31 +385,22 @@ var Computation = class extends Owner {
   wait() {
     if (this._compute && this._stateFlags & ERROR_BIT && this._time <= getClock()) {
       update(this);
+    } else {
+      this._updateIfNecessary();
     }
-    if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this.loading()) {
+    track(this);
+    if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this._stateFlags & LOADING_BIT) {
       throw new NotReadyError();
     }
-    if (staleCheck && this.loading())
+    if (staleCheck && this._stateFlags & LOADING_BIT) {
       staleCheck._value = true;
-    return this._read();
-  }
-  /**
-   * Return true if the computation is the value is dependent on an unresolved promise
-   * Triggers re-execution of the computation when the loading state changes
-   *
-   * This is useful especially when effects want to re-execute when a computation's
-   * loading state changes
-   */
-  loading() {
-    if (this._loading === null) {
-      this._loading = loadingState(this);
     }
-    return this._loading.read();
+    return this._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 && (!!(this._stateFlags & UNINITIALIZED_BIT) || this._equals === false || !this._equals(this._value, newValue));
+    const valueChanged = newValue !== UNCHANGED && (!!(this._stateFlags & UNINITIALIZED_BIT) || this._stateFlags & LOADING_BIT & ~flags || this._equals === false || !this._equals(this._value, newValue));
     if (valueChanged) {
       this._value = newValue;
       this._error = void 0;
@@ -461,8 +473,11 @@ var Computation = class extends Owner {
    * This function will ensure that the value and states we read from the computation are up to date
    */
   _updateIfNecessary() {
+    if (!this._compute) {
+      return;
+    }
     if (this._state === STATE_DISPOSED) {
-      throw new Error("Tried to read a disposed computation");
+      return;
     }
     if (this._state === STATE_CLEAN) {
       return;
@@ -495,22 +510,6 @@ var Computation = class extends Owner {
     super._disposeNode();
   }
 };
-function loadingState(node) {
-  const prevOwner = setOwner(node._parent);
-  const options = { name: node._name ? `loading ${node._name}` : "loading" } ;
-  const computation = new Computation(
-    void 0,
-    () => {
-      track(node);
-      node._updateIfNecessary();
-      return !!(node._stateFlags & LOADING_BIT);
-    },
-    options
-  );
-  computation._handlerMask = ERROR_BIT | LOADING_BIT;
-  setOwner(prevOwner);
-  return computation;
-}
 function track(computation) {
   if (currentObserver) {
     if (!newSources && currentObserver._sources && currentObserver._sources[newSourcesIndex] === computation) {
@@ -604,8 +603,7 @@ function hasUpdated(fn) {
     updateCheck = current;
   }
 }
-function isPending(fn, loadingValue) {
-  const argLength = arguments.length;
+function pendingCheck(fn, loadingValue) {
   const current = staleCheck;
   staleCheck = { _value: false };
   try {
@@ -614,13 +612,20 @@ function isPending(fn, loadingValue) {
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
-    if (argLength > 1)
+    if (loadingValue !== void 0)
       return loadingValue;
     throw err;
   } finally {
     staleCheck = current;
   }
 }
+function isPending(fn, loadingValue) {
+  if (!currentObserver)
+    return pendingCheck(fn, loadingValue);
+  const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
+  c._handlerMask |= LOADING_BIT;
+  return c.read();
+}
 function latest(fn, fallback) {
   const argLength = arguments.length;
   const prevFlags = newFlags;
@@ -637,15 +642,6 @@ function latest(fn, fallback) {
     notStale = prevNotStale;
   }
 }
-function catchError(fn) {
-  try {
-    fn();
-  } catch (e) {
-    if (e instanceof NotReadyError)
-      throw e;
-    return e;
-  }
-}
 function runWithObserver(observer, run) {
   const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
   newSources = null;
@@ -762,13 +758,6 @@ function flattenArray(children, results = [], options) {
     throw notReady;
   return needsUnwrap;
 }
-function createBoundary(fn, queue) {
-  const owner = new Owner();
-  const parentQueue = owner._queue;
-  parentQueue.addChild(owner._queue = queue);
-  onCleanup(() => parentQueue.removeChild(owner._queue));
-  return compute(owner, fn, null);
-}
 
 // src/core/effect.ts
 var Effect = class extends Computation {
@@ -794,10 +783,10 @@ var Effect = class extends Computation {
   }
   write(value, flags = 0) {
     if (this._state == STATE_DIRTY) {
-      const currentFlags = this._stateFlags;
+      this._stateFlags;
       this._stateFlags = flags;
-      if (this._type === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-        this._queue._update?.(this);
+      if (this._type === EFFECT_RENDER) {
+        this._queue.notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
     if (value === UNCHANGED)
@@ -814,10 +803,9 @@ var Effect = class extends Computation {
     this._state = state;
   }
   _setError(error) {
+    this._error = error;
     this._cleanup?.();
-    if (this._stateFlags & LOADING_BIT) {
-      this._queue._update?.(this);
-    }
+    this._queue.notify(this, LOADING_BIT, 0);
     this._stateFlags = ERROR_BIT;
     if (this._type === EFFECT_USER) {
       try {
@@ -826,7 +814,8 @@ var Effect = class extends Computation {
         error = e;
       }
     }
-    this.handleError(error);
+    if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+      throw error;
   }
   _disposeNode() {
     if (this._state === STATE_DISPOSED)
@@ -844,7 +833,8 @@ var Effect = class extends Computation {
       try {
         this._cleanup = this._effect(this._value, this._prevValue);
       } catch (e) {
-        this.handleError(e);
+        if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+          throw e;
       } finally {
         this._prevValue = this._value;
         this._modified = false;
@@ -869,65 +859,144 @@ var EagerComputation = class extends Computation {
 };
 var ProjectionComputation = class extends Computation {
   constructor(compute2) {
-    super(null, compute2);
+    super(void 0, compute2);
     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)
+    if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
       this._queue.enqueue(EFFECT_PURE, this);
     super._notify(state, true);
+    this._forceNotify = !!skipQueue;
   }
 };
 
-// src/core/suspense.ts
-var SuspenseQueue = class extends Queue {
-  _nodes = /* @__PURE__ */ new Set();
-  _fallback = false;
-  _signal = new Computation(false, null);
+// src/core/boundaries.ts
+var BoundaryComputation = class extends EagerComputation {
+  _propagationMask;
+  constructor(compute2, propagationMask) {
+    super(void 0, compute2, { defer: true });
+    this._propagationMask = propagationMask;
+  }
+  write(value, flags) {
+    super.write(value, flags & ~this._propagationMask);
+    if (this._propagationMask & LOADING_BIT && !(this._stateFlags & UNINITIALIZED_BIT)) {
+      flags &= ~LOADING_BIT;
+    }
+    this._queue.notify(this, this._propagationMask, flags);
+    return this._value;
+  }
+};
+function createBoundChildren(owner, fn, queue, mask) {
+  const parentQueue = owner._queue;
+  parentQueue.addChild(owner._queue = queue);
+  onCleanup(() => parentQueue.removeChild(owner._queue));
+  return compute(
+    owner,
+    () => {
+      const c = new Computation(void 0, fn);
+      return new BoundaryComputation(() => flatten(c.wait()), mask);
+    },
+    null
+  );
+}
+var ConditionalQueue = class extends Queue {
+  _disabled;
+  _errorNodes = /* @__PURE__ */ new Set();
+  _pendingNodes = /* @__PURE__ */ new Set();
+  constructor(disabled) {
+    super();
+    this._disabled = disabled;
+  }
   run(type) {
-    if (type && this._fallback)
+    if (type && this._disabled.read())
       return;
     return super.run(type);
   }
-  _update(node) {
-    if (node._stateFlags & LOADING_BIT) {
-      this._nodes.add(node);
-      if (!this._fallback) {
-        this._fallback = true;
-        this._signal.write(true);
+  notify(node, type, flags) {
+    if (this._disabled.read()) {
+      if (type === LOADING_BIT) {
+        flags & LOADING_BIT ? this._pendingNodes.add(node) : this._pendingNodes.delete(node);
       }
-    } else {
-      this._nodes.delete(node);
-      if (this._nodes.size === 0) {
-        this._fallback = false;
-        this._signal.write(false);
+      if (type === ERROR_BIT) {
+        flags & ERROR_BIT ? this._errorNodes.add(node) : this._errorNodes.delete(node);
       }
+      return true;
     }
+    return super.notify(node, type, flags);
   }
 };
-var LiveComputation = class extends EagerComputation {
-  write(value, flags = 0) {
-    const currentFlags = this._stateFlags;
-    const dirty = this._state === STATE_DIRTY;
-    super.write(value, flags);
-    if (dirty && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
-      this._queue._update?.(this);
+var CollectionQueue = class extends Queue {
+  _collectionType;
+  _nodes = /* @__PURE__ */ new Set();
+  _disabled = new Computation(false, null);
+  constructor(type) {
+    super();
+    this._collectionType = type;
+  }
+  notify(node, type, flags) {
+    if (!(type & this._collectionType))
+      return super.notify(node, type, flags);
+    if (flags & this._collectionType) {
+      this._nodes.add(node);
+      if (this._nodes.size === 1)
+        this._disabled.write(true);
+    } else {
+      this._nodes.delete(node);
+      if (this._nodes.size === 0)
+        this._disabled.write(false);
     }
-    return this._value;
+    type &= ~this._collectionType;
+    return type ? super.notify(node, type, flags) : true;
   }
 };
+function createBoundary(fn, condition) {
+  const owner = new Owner();
+  const queue = new ConditionalQueue(new Computation(void 0, () => condition() === "hidden" /* HIDDEN */));
+  const tree = createBoundChildren(owner, fn, queue, 0);
+  new EagerComputation(void 0, () => {
+    const disabled = queue._disabled.read();
+    tree._propagationMask = disabled ? ERROR_BIT | LOADING_BIT : 0;
+    if (!disabled) {
+      queue._pendingNodes.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
+      queue._errorNodes.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue._pendingNodes.clear();
+      queue._errorNodes.clear();
+    }
+  });
+  return () => queue._disabled.read() ? void 0 : tree.read();
+}
+function createCollectionBoundary(type, fn, fallback) {
+  const owner = new Owner();
+  const queue = new CollectionQueue(type);
+  const tree = createBoundChildren(owner, fn, queue, type);
+  const decision = new Computation(void 0, () => {
+    if (!queue._disabled.read()) {
+      const resolved = tree.read();
+      if (!queue._disabled.read())
+        return resolved;
+    }
+    return fallback(queue);
+  });
+  return decision.read.bind(decision);
+}
 function createSuspense(fn, fallback) {
-  const queue = new SuspenseQueue();
-  const tree = createBoundary(() => {
-    const child = new Computation(null, fn);
-    return new LiveComputation(null, () => flatten(child.wait()));
-  }, queue);
-  const equality = new Computation(null, () => queue._signal.read() || queue._fallback);
-  const comp = new Computation(null, () => equality.read() ? fallback() : tree.read());
-  return comp.read.bind(comp);
+  return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
+}
+function createErrorBoundary(fn, fallback) {
+  return createCollectionBoundary(
+    ERROR_BIT,
+    fn,
+    (queue) => fallback(queue._nodes.values().next().value._error, () => {
+      incrementClock();
+      for (let node of queue._nodes) {
+        node._state = STATE_DIRTY;
+        node._queue?.enqueue(node._type, node);
+      }
+    })
+  );
 }
 
 // src/signals.ts
@@ -955,77 +1024,64 @@ function createMemo(compute2, value, options) {
   let resolvedValue;
   return () => {
     if (node) {
+      if (node._state === STATE_DISPOSED) {
+        node = void 0;
+        return resolvedValue;
+      }
       resolvedValue = node.wait();
       if (!node._sources?.length && node._nextSibling?._parent !== node) {
         node.dispose();
         node = void 0;
-      } else if (!node._parent && !node._observers?.length) {
-        node.dispose();
-        node._state = STATE_DIRTY;
       }
     }
     return resolvedValue;
   };
 }
 function createAsync(compute2, value, options) {
-  let uninitialized = value === void 0;
-  const lhs = new EagerComputation(
-    {
-      _value: value
-    },
+  const node = new EagerComputation(
+    value,
     (p) => {
-      const value2 = p?._value;
-      const source = compute2(value2);
+      const source = compute2(p);
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
       if (!isPromise && !iterator) {
-        return {
-          wait() {
-            return source;
-          },
-          _value: source
-        };
+        return source;
       }
-      const signal = new Computation(value2, null, iterator ? { ...options, equals: false } : options);
-      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));
+      let abort = false;
+      onCleanup(() => abort = true);
       if (isPromise) {
         source.then(
           (value3) => {
-            uninitialized = false;
-            signal.write(value3, 0, true);
+            if (abort)
+              return;
+            node.write(value3, 0, true);
           },
           (error) => {
-            uninitialized = true;
-            signal._setError(error);
+            if (abort)
+              return;
+            node._setError(error);
           }
         );
       } else {
-        let abort = false;
-        onCleanup(() => abort = true);
         (async () => {
           try {
             for await (let value3 of source) {
               if (abort)
                 return;
-              signal.write(value3, 0, true);
+              node.write(value3, 0, true);
             }
           } catch (error) {
-            signal.write(error, ERROR_BIT);
+            if (abort)
+              return;
+            node.write(error, ERROR_BIT);
           }
         })();
       }
-      return signal;
-    }
+      throw new NotReadyError();
+    },
+    options
   );
-  return () => lhs.wait().wait();
+  return node.wait.bind(node);
 }
 function createEffect(compute2, effect, error, value, options) {
   void new Effect(
@@ -1042,62 +1098,13 @@ function createRenderEffect(compute2, effect, value, options) {
     ...{ ...options, name: options?.name ?? "effect" } 
   });
 }
-function createRoot(init) {
-  const owner = new Owner();
+function createRoot(init, options) {
+  const owner = new Owner(options?.id);
   return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
 }
 function runWithOwner(owner, run) {
   return compute(owner, run, null);
 }
-function createErrorBoundary(fn, fallback) {
-  const owner = new Owner();
-  const error = new Computation(void 0, null);
-  const nodes = /* @__PURE__ */ new Set();
-  function handler(err, node) {
-    if (nodes.has(node))
-      return;
-    compute(
-      node,
-      () => onCleanup(() => {
-        nodes.delete(node);
-        if (!nodes.size)
-          error.write(void 0);
-      }),
-      null
-    );
-    nodes.add(node);
-    if (nodes.size === 1)
-      error.write({ _error: err });
-  }
-  owner._handlers = owner._handlers ? [handler, ...owner._handlers] : [handler];
-  const guarded = compute(
-    owner,
-    () => {
-      const c = new Computation(void 0, fn);
-      const f = new EagerComputation(void 0, () => flatten(c.read()), { defer: true });
-      f._setError = function(error2) {
-        this.handleError(error2);
-      };
-      return f;
-    },
-    null
-  );
-  const decision = new Computation(null, () => {
-    if (!error.read()) {
-      const resolved = guarded.read();
-      if (!error.read())
-        return resolved;
-    }
-    return fallback(error.read()._error, () => {
-      incrementClock();
-      for (let node of nodes) {
-        node._state = STATE_DIRTY;
-        node._queue?.enqueue(node._type, node);
-      }
-    });
-  });
-  return decision.read.bind(decision);
-}
 function resolve(fn) {
   return new Promise((res, rej) => {
     createRoot((dispose) => {
@@ -1243,7 +1250,7 @@ function ownKeys(target) {
   trackSelf(target);
   return Reflect.ownKeys(target[STORE_VALUE]);
 }
-var Writing = /* @__PURE__ */ new Set();
+var Writing = null;
 var proxyTraps = {
   get(target, property, receiver) {
     if (property === $TARGET)
@@ -1264,7 +1271,7 @@ var proxyTraps = {
       if (desc && desc.get)
         return desc.get.call(receiver);
     }
-    if (Writing.has(storeValue)) {
+    if (Writing?.has(storeValue)) {
       const value2 = tracked ? tracked._value : storeValue[property];
       return isWrappable(value2) ? (Writing.add(value2[$RAW] || value2), wrap2(value2)) : value2;
     }
@@ -1287,11 +1294,11 @@ var proxyTraps = {
     return has;
   },
   set(target, property, value) {
-    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
+    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, unwrap(value, false));
     return true;
   },
   deleteProperty(target, property) {
-    Writing.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
+    Writing?.has(target[STORE_VALUE]) && setProperty(target[STORE_VALUE], property, void 0, true);
     return true;
   },
   ownKeys,
@@ -1374,11 +1381,14 @@ function createStore(first, second) {
   const unwrappedStore = unwrap(store);
   let wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
+    const prevWriting = Writing;
+    Writing = /* @__PURE__ */ new Set();
+    Writing.add(unwrappedStore);
     try {
-      Writing.add(unwrappedStore);
       fn(wrappedStore);
     } finally {
       Writing.clear();
+      Writing = prevWriting;
     }
   };
   if (derived)
@@ -1848,4 +1858,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, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, untrack, unwrap };
+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, deep, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, tryCatch, untrack, unwrap };