@solidjs/signals 0.2.4 → 0.3.0

package/dist/dev.js

@@ -75,8 +75,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)
@@ -138,6 +138,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 +170,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
@@ -162,13 +186,21 @@ var Owner = class {
   _context = defaultContext;
   _handlers = null;
   _queue = globalQueue;
-  constructor(signal = false) {
-    if (currentOwner && !signal)
+  _siblingCount = null;
+  _childCount = 0;
+  id = null;
+  constructor(id = null, skipAppend = false) {
+    this.id = id;
+    if (currentOwner && !skipAppend)
       currentOwner.append(this);
   }
   append(child) {
     child._parent = this;
     child._prevSibling = this;
+    if (this.id) {
+      child._siblingCount = this._nextSibling ? this._nextSibling._siblingCount + 1 : 0;
+      child.id = formatId(this.id, child._siblingCount);
+    }
     if (this._nextSibling)
       this._nextSibling._prevSibling = child;
     child._nextSibling = this._nextSibling;
@@ -223,6 +255,9 @@ var Owner = class {
     }
     this._disposal = null;
   }
+  addErrorHandler(handler) {
+    this._handlers = this._handlers ? [handler, ...this._handlers] : [handler];
+  }
   handleError(error) {
     if (!this._handlers)
       throw error;
@@ -238,6 +273,11 @@ var Owner = class {
     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) {
   return { id: Symbol(description), defaultValue };
@@ -316,11 +356,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 +377,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 +402,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 +490,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 +527,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 +620,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 +629,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 +659,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 +775,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 {
@@ -869,7 +875,7 @@ 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");
   }
@@ -882,52 +888,103 @@ var ProjectionComputation = class extends Computation {
   }
 };
 
-// src/core/suspense.ts
+// src/core/boundaries.ts
+function createBoundary(owner, fn, queue) {
+  if (queue) {
+    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 EagerComputation(void 0, () => flatten(c.wait()), { defer: true });
+    },
+    null
+  );
+}
+function createDecision(main, condition, fallback) {
+  const decision = new Computation(void 0, () => {
+    if (!condition.read()) {
+      const resolved = main.read();
+      if (!condition.read())
+        return resolved;
+    }
+    return fallback();
+  });
+  return decision.read.bind(decision);
+}
 var SuspenseQueue = class extends Queue {
   _nodes = /* @__PURE__ */ new Set();
-  _fallback = false;
-  _signal = new Computation(false, null);
+  _fallback = new Computation(false, null);
   run(type) {
-    if (type && this._fallback)
+    if (type && this._fallback.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);
-      }
+      if (this._nodes.size === 1)
+        this._fallback.write(true);
     } else {
       this._nodes.delete(node);
-      if (this._nodes.size === 0) {
-        this._fallback = false;
-        this._signal.write(false);
-      }
+      if (this._nodes.size === 0)
+        this._fallback.write(false);
     }
   }
 };
-var LiveComputation = class extends EagerComputation {
-  write(value, flags = 0) {
+function createSuspense(fn, fallback) {
+  const owner = new Owner();
+  const queue = new SuspenseQueue();
+  const tree = createBoundary(owner, fn, queue);
+  const ogWrite = tree.write;
+  tree.write = function(value, flags = 0) {
     const currentFlags = this._stateFlags;
     const dirty = this._state === STATE_DIRTY;
-    super.write(value, flags);
+    ogWrite.call(this, value, flags);
     if (dirty && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
       this._queue._update?.(this);
     }
     return this._value;
+  };
+  return createDecision(tree, queue._fallback, fallback);
+}
+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 });
   }
-};
-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);
+  owner.addErrorHandler(handler);
+  const tree = createBoundary(owner, fn);
+  tree._setError = tree.handleError;
+  return createDecision(
+    tree,
+    error,
+    () => fallback(error.read()._error, () => {
+      incrementClock();
+      for (let node of nodes) {
+        node._state = STATE_DIRTY;
+        node._queue?.enqueue(node._type, node);
+      }
+    })
+  );
 }
 
 // src/signals.ts
@@ -955,77 +1012,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, 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 +1086,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) => {
@@ -1150,8 +1145,10 @@ function wrap(source, node, wrapped) {
 // src/store/store.ts
 var $RAW = Symbol("STORE_RAW" );
 var $TRACK = Symbol("STORE_TRACK" );
+var $DEEP = Symbol("STORE_DEEP" );
 var $TARGET = Symbol("STORE_TARGET" );
 var $PROXY = Symbol("STORE_PROXY" );
+var PARENTS = /* @__PURE__ */ new WeakMap();
 var STORE_VALUE = "v";
 var STORE_NODE = "n";
 var STORE_HAS = "h";
@@ -1174,11 +1171,11 @@ function wrap2(value) {
 function isWrappable(obj) {
   return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
 }
-function unwrap(item, deep = true, set) {
+function unwrap(item, deep2 = true, set) {
   let result, unwrapped, v, prop;
   if (result = item != null && item[$RAW])
     return result;
-  if (!deep)
+  if (!deep2)
     return item;
   if (!isWrappable(item) || set?.has(item))
     return item;
@@ -1188,11 +1185,11 @@ function unwrap(item, deep = true, set) {
   if (Array.isArray(item)) {
     for (let i = 0, l = item.length; i < l; i++) {
       v = item[i];
-      if ((unwrapped = unwrap(v, deep, set)) !== v)
+      if ((unwrapped = unwrap(v, deep2, set)) !== v)
         item[i] = unwrapped;
     }
   } else {
-    if (!deep)
+    if (!deep2)
       return item;
     const keys = Object.keys(item);
     for (let i = 0, l = keys.length; i < l; i++) {
@@ -1201,7 +1198,7 @@ function unwrap(item, deep = true, set) {
       if (desc.get)
         continue;
       v = item[prop];
-      if ((unwrapped = unwrap(v, deep, set)) !== v)
+      if ((unwrapped = unwrap(v, deep2, set)) !== v)
         item[prop] = unwrapped;
     }
   }
@@ -1234,8 +1231,8 @@ function proxyDescriptor(target, property) {
   desc.get = () => target[STORE_VALUE][$PROXY][property];
   return desc;
 }
-function trackSelf(target) {
-  getObserver() && getNode(getNodes(target, STORE_NODE), $TRACK, void 0, false).read();
+function trackSelf(target, symbol = $TRACK) {
+  getObserver() && getNode(getNodes(target, STORE_NODE), symbol, void 0, false).read();
 }
 function ownKeys(target) {
   trackSelf(target);
@@ -1250,8 +1247,8 @@ var proxyTraps = {
       return target[STORE_VALUE];
     if (property === $PROXY)
       return receiver;
-    if (property === $TRACK) {
-      trackSelf(target);
+    if (property === $TRACK || property === $DEEP) {
+      trackSelf(target, property);
       return receiver;
     }
     const nodes = getNodes(target, STORE_NODE);
@@ -1272,7 +1269,7 @@ 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) ? wrap2(value) : value).read();
+        return getNode(nodes, property, isWrappable(value) ? wrap2(value) : value).read();
       }
     }
     return isWrappable(value) ? wrap2(value) : value;
@@ -1307,6 +1304,13 @@ function setProperty(state, property, value, deleting = false) {
     delete state[property];
   else
     state[property] = value;
+  const wrappable = isWrappable(value);
+  if (isWrappable(prev)) {
+    const parents = PARENTS.get(prev);
+    parents && (parents instanceof Set ? parents.delete(state) : PARENTS.delete(prev));
+  }
+  if (recursivelyNotify(state) && wrappable)
+    recursivelyAddParent(value[$RAW] || value, state);
   const target = state[$PROXY]?.[$TARGET];
   if (!target)
     return;
@@ -1315,15 +1319,54 @@ function setProperty(state, property, value, deleting = false) {
   else
     target[STORE_HAS]?.[property]?.write(true);
   const nodes = getNodes(target, STORE_NODE);
-  let node;
-  if (node = nodes[property])
-    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);
+  nodes[property]?.write(wrappable ? wrap2(value) : value);
+  Array.isArray(state) && state.length !== len && nodes.length?.write(state.length);
+  nodes[$TRACK]?.write(void 0);
+}
+function recursivelyNotify(state) {
+  let target = state[$PROXY]?.[$TARGET];
+  let notified = false;
+  target && (getNodes(target, STORE_NODE)[$DEEP]?.write(void 0), notified = true);
+  const parents = PARENTS.get(state);
+  if (!parents)
+    return notified;
+  if (parents instanceof Set) {
+    for (let parent of parents)
+      notified = recursivelyNotify(parent) || notified;
+  } else
+    notified = recursivelyNotify(parents) || notified;
+  return notified;
+}
+function recursivelyAddParent(state, parent) {
+  if (parent) {
+    let parents = PARENTS.get(state);
+    if (!parents)
+      PARENTS.set(state, parent);
+    else if (parents !== parent) {
+      if (!(parents instanceof Set))
+        PARENTS.set(state, parents = /* @__PURE__ */ new Set([parents]));
+      else if (parents.has(parent))
+        return;
+      parents.add(parent);
+    } else
+      return;
+  }
+  if (Array.isArray(state)) {
+    for (let i = 0; i < state.length; i++) {
+      const item = state[i];
+      isWrappable(item) && recursivelyAddParent(item[$RAW] || item, state);
+    }
+  } else {
+    const keys = Object.keys(state);
+    for (let i = 0; i < keys.length; i++) {
+      const item = state[keys[i]];
+      isWrappable(item) && recursivelyAddParent(item[$RAW] || item, state);
+    }
+  }
 }
 function createStore(first, second) {
   const derived = typeof first === "function", store = derived ? second : first;
-  const unwrappedStore = unwrap(store, false);
+  const unwrappedStore = unwrap(store);
   let wrappedStore = wrap2(unwrappedStore);
   const setStore = (fn) => {
     try {
@@ -1337,6 +1380,10 @@ function createStore(first, second) {
     return wrapProjection(first, wrappedStore, setStore);
   return [wrappedStore, setStore];
 }
+function deep(store) {
+  recursivelyAddParent(store[$RAW] || store);
+  return store[$DEEP];
+}
 
 // src/store/reconcile.ts
 function applyState(next, state, keyFn) {
@@ -1796,4 +1843,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, 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, 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 };