solid-js 1.9.11 → 2.0.0-beta.0

package/dist/server.cjs

@@ -1,813 +1,879 @@
 'use strict';
 
-const equalFn = (a, b) => a === b;
-const $PROXY = Symbol("solid-proxy");
-const $TRACK = Symbol("solid-track");
-const $DEVCOMP = Symbol("solid-dev-component");
-const DEV = undefined;
-const ERROR = Symbol("error");
-function castError(err) {
-  if (err instanceof Error) return err;
-  return new Error(typeof err === "string" ? err : "Unknown error", {
-    cause: err
-  });
-}
-function handleError(err, owner = Owner) {
-  const fns = owner && owner.context && owner.context[ERROR];
-  const error = castError(err);
-  if (!fns) throw error;
-  try {
-    for (const f of fns) f(error);
-  } catch (e) {
-    handleError(e, owner && owner.owner || null);
+var signals = require('@solidjs/signals');
+
+const sharedConfig = {
+  getNextContextId() {
+    const o = signals.getOwner();
+    if (!o) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
+    return signals.getNextChildId(o);
   }
-}
-const UNOWNED = {
-  context: null,
-  owner: null,
-  owned: null,
-  cleanups: null
 };
-let Owner = null;
-function createOwner() {
-  const o = {
-    owner: Owner,
-    context: Owner ? Owner.context : null,
-    owned: null,
-    cleanups: null
-  };
-  if (Owner) {
-    if (!Owner.owned) Owner.owned = [o];else Owner.owned.push(o);
-  }
-  return o;
-}
-function createRoot(fn, detachedOwner) {
-  const owner = Owner,
-    current = detachedOwner === undefined ? owner : detachedOwner,
-    root = fn.length === 0 ? UNOWNED : {
-      context: current ? current.context : null,
-      owner: current,
-      owned: null,
-      cleanups: null
-    };
-  Owner = root;
-  let result;
+
+let Observer = null;
+function runWithObserver(comp, fn) {
+  const prev = Observer;
+  Observer = comp;
   try {
-    result = fn(fn.length === 0 ? () => {} : () => cleanNode(root));
-  } catch (err) {
-    handleError(err);
+    return fn();
   } finally {
-    Owner = owner;
+    Observer = prev;
   }
-  return result;
 }
-function createSignal(value, options) {
-  return [() => value, v => {
-    return value = typeof v === "function" ? v(value) : v;
-  }];
+function getObserver() {
+  return Observer;
 }
-function createComputed(fn, value) {
-  Owner = createOwner();
-  try {
-    fn(value);
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
-  }
+function createSignal(first, second, third) {
+  if (typeof first === "function") {
+    const ssrSource = third?.ssrSource;
+    if (ssrSource === "initial" || ssrSource === "client") {
+      signals.createOwner();
+      let value = second;
+      return [() => value, v => {
+        return value = typeof v === "function" ? v(value) : v;
+      }];
+    }
+    const memoOpts = third?.deferStream || ssrSource ? {
+      deferStream: third?.deferStream,
+      ssrSource
+    } : undefined;
+    const memo = createMemo(p => {
+      let value = first(p ? p[0]() : second);
+      return [() => value, v => {
+        return value = typeof v === "function" ? v(value) : v;
+      }];
+    }, undefined, memoOpts);
+    return [() => memo()[0](), v => memo()[1](v)];
+  }
+  return [() => first, v => {
+    return first = typeof v === "function" ? v(first) : v;
+  }];
 }
-const createRenderEffect = createComputed;
-function createEffect(fn, value) {}
-function createReaction(fn) {
-  return fn => {
-    fn();
+function createMemo(compute, value, options) {
+  const ctx = sharedConfig.context;
+  const owner = signals.createOwner();
+  const comp = {
+    owner,
+    value: value,
+    compute: compute,
+    error: undefined,
+    computed: false,
+    disposed: false
   };
-}
-function createMemo(fn, value) {
-  Owner = createOwner();
-  let v;
-  try {
-    v = fn(value);
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
+  signals.runWithOwner(owner, () => signals.onCleanup(() => {
+    comp.disposed = true;
+  }));
+  function update() {
+    if (comp.disposed) return;
+    try {
+      comp.error = undefined;
+      const result = signals.runWithOwner(owner, () => runWithObserver(comp, () => comp.compute(comp.value)));
+      comp.computed = true;
+      processResult(comp, result, owner, ctx, options?.deferStream, options?.ssrSource);
+    } catch (err) {
+      if (err instanceof signals.NotReadyError) {
+        err.source?.then(() => update());
+      }
+      comp.error = err;
+      comp.computed = true;
+    }
+  }
+  const ssrSource = options?.ssrSource;
+  if (ssrSource === "initial" || ssrSource === "client") {
+    comp.computed = true;
+  } else if (!options?.lazy) {
+    update();
   }
-  return () => v;
-}
-function createDeferred(source) {
-  return source;
-}
-function createSelector(source, fn = equalFn) {
-  return k => fn(k, source());
-}
-function batch(fn) {
-  return fn();
-}
-const untrack = batch;
-function on(deps, fn, options = {}) {
-  const isArray = Array.isArray(deps);
-  const defer = options.defer;
   return () => {
-    if (defer) return undefined;
-    let value;
-    if (isArray) {
-      value = [];
-      for (let i = 0; i < deps.length; i++) value.push(deps[i]());
-    } else value = deps();
-    return fn(value);
+    if (!comp.computed) {
+      update();
+    }
+    if (comp.error) {
+      throw comp.error;
+    }
+    return comp.value;
   };
 }
-function onMount(fn) {}
-function onCleanup(fn) {
-  if (Owner) {
-    if (!Owner.cleanups) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
+function createDeepProxy(target, patches, basePath = []) {
+  const childProxies = new Map();
+  const handler = {
+    get(obj, key, receiver) {
+      if (Array.isArray(obj)) {
+        if (key === "shift") {
+          return function () {
+            if (obj.length === 0) return undefined;
+            const removed = obj[0];
+            Array.prototype.shift.call(obj);
+            childProxies.clear();
+            patches.push([[...basePath, 0]]);
+            return removed;
+          };
+        }
+        if (key === "unshift") {
+          return function (...items) {
+            const result = Array.prototype.unshift.apply(obj, items);
+            childProxies.clear();
+            for (let i = 0; i < items.length; i++) {
+              patches.push([[...basePath, i], items[i], 1]);
+            }
+            return result;
+          };
+        }
+        if (key === "splice") {
+          return function (start, deleteCount, ...items) {
+            const len = obj.length;
+            const s = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+            const d = deleteCount === undefined ? len - s : Math.min(Math.max(deleteCount, 0), len - s);
+            const removed = Array.prototype.splice.apply(obj, [s, d, ...items]);
+            childProxies.clear();
+            for (let i = 0; i < d; i++) patches.push([[...basePath, s]]);
+            for (let i = 0; i < items.length; i++) patches.push([[...basePath, s + i], items[i], 1]);
+            return removed;
+          };
+        }
+      }
+      const value = Reflect.get(obj, key, receiver);
+      if (value !== null && typeof value === "object" && typeof key !== "symbol") {
+        if (!childProxies.has(key)) {
+          childProxies.set(key, createDeepProxy(value, patches, [...basePath, key]));
+        }
+        return childProxies.get(key);
+      }
+      return value;
+    },
+    set(obj, key, value) {
+      childProxies.delete(key);
+      patches.push([[...basePath, key], value]);
+      return Reflect.set(obj, key, value);
+    },
+    deleteProperty(obj, key) {
+      childProxies.delete(key);
+      patches.push([[...basePath, key]]);
+      return Reflect.deleteProperty(obj, key);
+    }
+  };
+  return new Proxy(target, handler);
+}
+function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
+  if (comp.disposed) return;
+  const id = owner.id;
+  const uninitialized = comp.value === undefined;
+  if (result instanceof Promise) {
+    result.then(v => {
+      result.s = 1;
+      result.v = v;
+      if (comp.disposed) return;
+      comp.value = v;
+      comp.error = undefined;
+    }, () => {});
+    if (ctx?.async && ctx.serialize && id) ctx.serialize(id, result, deferStream);
+    if (uninitialized) {
+      comp.error = new signals.NotReadyError(result);
+    }
+    return;
+  }
+  const iterator = result?.[Symbol.asyncIterator];
+  if (typeof iterator === "function") {
+    const iter = iterator.call(result);
+    if (ssrSource === "hybrid") {
+      const promise = iter.next().then(v => {
+        promise.s = 1;
+        promise.v = v.value;
+        if (comp.disposed) return;
+        comp.value = v.value;
+        comp.error = undefined;
+      }, () => {});
+      if (ctx?.async && ctx.serialize && id) ctx.serialize(id, promise, deferStream);
+      if (uninitialized) {
+        comp.error = new signals.NotReadyError(promise);
+      }
+    } else {
+      const firstNext = iter.next();
+      const firstReady = firstNext.then(r => {
+        if (comp.disposed) return;
+        if (!r.done) {
+          comp.value = r.value;
+          comp.error = undefined;
+        }
+      }, () => {});
+      let servedFirst = false;
+      const tapped = {
+        [Symbol.asyncIterator]: () => ({
+          next() {
+            if (!servedFirst) {
+              servedFirst = true;
+              return firstNext.then(r => {
+                if (!r.done && !comp.disposed) comp.value = r.value;
+                return r;
+              });
+            }
+            return iter.next().then(r => r);
+          }
+        })
+      };
+      if (ctx?.async && ctx.serialize && id) ctx.serialize(id, tapped, deferStream);
+      if (uninitialized) {
+        comp.error = new signals.NotReadyError(firstReady);
+      }
+    }
+    return;
   }
-  return fn;
+  comp.value = result;
 }
-function cleanNode(node) {
-  if (node.owned) {
-    for (let i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
-    node.owned = null;
+function serverEffect(compute, effectFn, value, options) {
+  const ssrSource = options?.ssrSource;
+  if (ssrSource === "client" || ssrSource === "initial") {
+    signals.createOwner();
+    return;
   }
-  if (node.cleanups) {
-    for (let i = 0; i < node.cleanups.length; i++) node.cleanups[i]();
-    node.cleanups = null;
-  }
-}
-function catchError(fn, handler) {
-  const owner = createOwner();
-  owner.context = {
-    ...owner.context,
-    [ERROR]: [handler]
+  const ctx = sharedConfig.context;
+  const owner = signals.createOwner();
+  const comp = {
+    owner,
+    value: value,
+    compute: compute,
+    error: undefined,
+    computed: true,
+    disposed: false
   };
-  Owner = owner;
+  if (ssrSource) {
+    signals.runWithOwner(owner, () => signals.onCleanup(() => {
+      comp.disposed = true;
+    }));
+  }
   try {
-    return fn();
+    const result = signals.runWithOwner(owner, () => runWithObserver(comp, () => compute(value)));
+    if (ssrSource) {
+      processResult(comp, result, owner, ctx, options?.deferStream, ssrSource);
+    }
+    effectFn?.(ssrSource ? comp.value ?? result : result, value);
   } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
   }
 }
-function getListener() {
-  return null;
-}
-function createContext(defaultValue) {
-  const id = Symbol("context");
-  return {
-    id,
-    Provider: createProvider(id),
-    defaultValue
-  };
+function createEffect(compute, effect, value, options) {
+  serverEffect(compute, undefined, value, options);
 }
-function useContext(context) {
-  return Owner && Owner.context && Owner.context[context.id] !== undefined ? Owner.context[context.id] : context.defaultValue;
+function createRenderEffect(compute, effectFn, value, options) {
+  serverEffect(compute, effectFn, value, options);
 }
-function getOwner() {
-  return Owner;
+function createTrackedEffect(compute, options) {
+  const o = signals.getOwner();
+  if (o?.id != null) signals.getNextChildId(o);
 }
-function children(fn) {
-  const memo = createMemo(() => resolveChildren(fn()));
-  memo.toArray = () => {
-    const c = memo();
-    return Array.isArray(c) ? c : c != null ? [c] : [];
+function createReaction(effectFn, options) {
+  return tracking => {
+    tracking();
   };
-  return memo;
-}
-function runWithOwner(o, fn) {
-  const prev = Owner;
-  Owner = o;
-  try {
-    return fn();
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = prev;
-  }
 }
-function resolveChildren(children) {
-  if (typeof children === "function" && !children.length) return resolveChildren(children());
-  if (Array.isArray(children)) {
-    const results = [];
-    for (let i = 0; i < children.length; i++) {
-      const result = resolveChildren(children[i]);
-      Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+function createOptimistic(first, second, third) {
+  return createSignal(first, second, third);
+}
+function setProperty(state, property, value) {
+  if (state[property] === value) return;
+  if (value === undefined) {
+    delete state[property];
+  } else state[property] = value;
+}
+function createStore(first, second) {
+  if (typeof first === "function") {
+    const store = createProjection(first, second ?? {});
+    return [store, fn => fn(store)];
+  }
+  const state = first;
+  return [state, fn => fn(state)];
+}
+const createOptimisticStore = createStore;
+function createPendingProxy(state, source) {
+  let pending = true;
+  let readTarget = state;
+  const proxy = new Proxy(state, {
+    get(obj, key, receiver) {
+      if (pending && typeof key !== "symbol") {
+        throw new signals.NotReadyError(source);
+      }
+      return Reflect.get(readTarget, key);
     }
-    return results;
-  }
-  return children;
+  });
+  return [proxy, frozen => {
+    if (frozen) readTarget = frozen;
+    pending = false;
+  }];
 }
-function createProvider(id) {
-  return function provider(props) {
-    return createMemo(() => {
-      Owner.context = {
-        ...Owner.context,
-        [id]: props.value
+function createProjection(fn, initialValue = {}, options) {
+  const ctx = sharedConfig.context;
+  const owner = signals.createOwner();
+  const [state] = createStore(initialValue);
+  if (options?.ssrSource === "initial" || options?.ssrSource === "client") {
+    return state;
+  }
+  let disposed = false;
+  signals.runWithOwner(owner, () => signals.onCleanup(() => {
+    disposed = true;
+  }));
+  const ssrSource = options?.ssrSource;
+  const useProxy = ssrSource !== "hybrid";
+  const patches = [];
+  const draft = useProxy ? createDeepProxy(state, patches) : state;
+  const result = signals.runWithOwner(owner, () => fn(draft));
+  const iteratorFn = result?.[Symbol.asyncIterator];
+  if (typeof iteratorFn === "function") {
+    const iter = iteratorFn.call(result);
+    if (ssrSource === "hybrid") {
+      const promise = iter.next().then(r => {
+        promise.s = 1;
+        if (disposed) {
+          promise.v = state;
+          return;
+        }
+        if (r.value !== undefined && r.value !== state) {
+          Object.assign(state, r.value);
+        }
+        promise.v = state;
+        markReady();
+      }, () => {});
+      if (ctx?.async && !ctx.noHydrate && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
+      const [pending, markReady] = createPendingProxy(state, promise);
+      return pending;
+    } else {
+      const firstNext = iter.next();
+      const firstReady = firstNext.then(r => {
+        if (disposed) return;
+        patches.length = 0;
+        if (!r.done) {
+          if (r.value !== undefined && r.value !== draft) {
+            Object.assign(state, r.value);
+          }
+        }
+        markReady(JSON.parse(JSON.stringify(state)));
+      }, () => {
+        markReady();
+      });
+      let servedFirst = false;
+      const tapped = {
+        [Symbol.asyncIterator]: () => ({
+          next() {
+            if (!servedFirst) {
+              servedFirst = true;
+              return firstNext.then(r => {
+                if (!r.done && !disposed) return {
+                  done: false,
+                  value: state
+                };
+                return {
+                  done: r.done,
+                  value: undefined
+                };
+              });
+            }
+            return iter.next().then(r => {
+              if (disposed) return {
+                done: true,
+                value: undefined
+              };
+              const flushed = patches.splice(0);
+              if (!r.done) {
+                if (r.value !== undefined && r.value !== draft) {
+                  Object.assign(state, r.value);
+                }
+                return {
+                  done: false,
+                  value: flushed
+                };
+              }
+              return {
+                done: true,
+                value: undefined
+              };
+            });
+          }
+        })
       };
-      return children(() => props.children);
-    });
+      if (ctx?.async && !ctx.noHydrate && owner.id) ctx.serialize(owner.id, tapped, options?.deferStream);
+      const [pending, markReady] = createPendingProxy(state, firstReady);
+      return pending;
+    }
+  }
+  if (result instanceof Promise) {
+    const promise = result.then(v => {
+      promise.s = 1;
+      if (disposed) {
+        promise.v = state;
+        return;
+      }
+      if (v !== undefined && v !== state) {
+        Object.assign(state, v);
+      }
+      promise.v = state;
+      markReady();
+    }, () => {});
+    if (ctx?.async && !ctx.noHydrate && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
+    const [pending, markReady] = createPendingProxy(state, promise);
+    return pending;
+  }
+  if (result !== undefined && result !== state && result !== draft) {
+    Object.assign(state, result);
+  }
+  return state;
+}
+function reconcile(value) {
+  return state => {
+    if (!signals.isWrappable(state) || !signals.isWrappable(value)) return value;
+    const targetKeys = Object.keys(value);
+    const previousKeys = Object.keys(state);
+    for (let i = 0, len = targetKeys.length; i < len; i++) {
+      const key = targetKeys[i];
+      setProperty(state, key, value[key]);
+    }
+    for (let i = 0, len = previousKeys.length; i < len; i++) {
+      if (value[previousKeys[i]] === undefined) setProperty(state, previousKeys[i], undefined);
+    }
+    return state;
   };
 }
-function requestCallback(fn, options) {
-  return {
-    id: 0,
-    fn: () => {},
-    startTime: 0,
-    expirationTime: 0
-  };
+function deep(store) {
+  return store;
 }
 function mapArray(list, mapFn, options = {}) {
-  const items = list();
-  let s = [];
-  if (items && items.length) {
-    for (let i = 0, len = items.length; i < len; i++) s.push(mapFn(items[i], () => i));
-  } else if (options.fallback) s = [options.fallback()];
-  return () => s;
-}
-function indexArray(list, mapFn, options = {}) {
-  const items = list();
-  let s = [];
-  if (items && items.length) {
-    for (let i = 0, len = items.length; i < len; i++) s.push(mapFn(() => items[i], i));
-  } else if (options.fallback) s = [options.fallback()];
-  return () => s;
-}
-function observable(input) {
-  return {
-    subscribe(observer) {
-      if (!(observer instanceof Object) || observer == null) {
-        throw new TypeError("Expected the observer to be an object.");
-      }
-      const handler = typeof observer === "function" ? observer : observer.next && observer.next.bind(observer);
-      if (!handler) {
-        return {
-          unsubscribe() {}
-        };
-      }
-      const dispose = createRoot(disposer => {
-        createEffect(() => {
-          const v = input();
-          untrack(() => handler(v));
+  const root = signals.getOwner();
+  const id = signals.getNextChildId(root);
+  return () => {
+    const items = list();
+    let s = [];
+    if (items && items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        const o = signals.createOwner({
+          id: id + i
         });
-        return disposer;
-      });
-      if (getOwner()) onCleanup(dispose);
-      return {
-        unsubscribe() {
-          dispose();
-        }
-      };
-    },
-    [Symbol.observable || "@@observable"]() {
-      return this;
-    }
+        s.push(signals.runWithOwner(o, () => mapFn(() => items[i], () => i)));
+      }
+    } else if (options.fallback) s = [options.fallback()];
+    return s;
   };
 }
-function from(producer) {
-  const [s, set] = createSignal(undefined);
-  if ("subscribe" in producer) {
-    const unsub = producer.subscribe(v => set(() => v));
-    onCleanup(() => "unsubscribe" in unsub ? unsub.unsubscribe() : unsub());
-  } else {
-    const clean = producer(set);
-    onCleanup(clean);
-  }
-  return s;
-}
-function enableExternalSource(factory) {}
-function onError(fn) {
-  if (Owner) {
-    if (Owner.context === null || !Owner.context[ERROR]) {
-      Owner.context = {
-        ...Owner.context,
-        [ERROR]: [fn]
-      };
-      mutateContext(Owner, ERROR, [fn]);
-    } else Owner.context[ERROR].push(fn);
-  }
-}
-function mutateContext(o, key, value) {
-  if (o.owned) {
-    for (let i = 0; i < o.owned.length; i++) {
-      if (o.owned[i].context === o.context) mutateContext(o.owned[i], key, value);
-      if (!o.owned[i].context) {
-        o.owned[i].context = o.context;
-        mutateContext(o.owned[i], key, value);
-      } else if (!o.owned[i].context[key]) {
-        o.owned[i].context[key] = value;
-        mutateContext(o.owned[i], key, value);
+function repeat(count, mapFn, options = {}) {
+  const owner = signals.createOwner();
+  const len = count();
+  const offset = options.from?.() || 0;
+  let s = [];
+  if (len) {
+    signals.runWithOwner(owner, () => {
+      for (let i = 0; i < len; i++) {
+        const itemOwner = signals.createOwner();
+        s.push(signals.runWithOwner(itemOwner, () => mapFn(i + offset)));
       }
-    }
+    });
+  } else if (options.fallback) {
+    s = [signals.runWithOwner(owner, () => {
+      const fo = signals.createOwner();
+      return signals.runWithOwner(fo, () => options.fallback());
+    })];
   }
+  return () => s;
 }
-
-function escape(s, attr) {
-  const t = typeof s;
-  if (t !== "string") {
-    if (t === "function") return escape(s());
-    if (Array.isArray(s)) {
-      for (let i = 0; i < s.length; i++) s[i] = escape(s[i]);
-      return s;
-    }
-    return s;
-  }
-  const delim = "<";
-  const escDelim = "&lt;";
-  let iDelim = s.indexOf(delim);
-  let iAmp = s.indexOf("&");
-  if (iDelim < 0 && iAmp < 0) return s;
-  let left = 0,
-    out = "";
-  while (iDelim >= 0 && iAmp >= 0) {
-    if (iDelim < iAmp) {
-      if (left < iDelim) out += s.substring(left, iDelim);
-      out += escDelim;
-      left = iDelim + 1;
-      iDelim = s.indexOf(delim, left);
-    } else {
-      if (left < iAmp) out += s.substring(left, iAmp);
-      out += "&amp;";
-      left = iAmp + 1;
-      iAmp = s.indexOf("&", left);
-    }
-  }
-  if (iDelim >= 0) {
-    do {
-      if (left < iDelim) out += s.substring(left, iDelim);
-      out += escDelim;
-      left = iDelim + 1;
-      iDelim = s.indexOf(delim, left);
-    } while (iDelim >= 0);
-  } else while (iAmp >= 0) {
-    if (left < iAmp) out += s.substring(left, iAmp);
-    out += "&amp;";
-    left = iAmp + 1;
-    iAmp = s.indexOf("&", left);
-  }
-  return left < s.length ? out + s.substring(left) : out;
-}
-function resolveSSRNode(node) {
-  const t = typeof node;
-  if (t === "string") return node;
-  if (node == null || t === "boolean") return "";
-  if (Array.isArray(node)) {
-    let prev = {};
-    let mapped = "";
-    for (let i = 0, len = node.length; i < len; i++) {
-      if (typeof prev !== "object" && typeof node[i] !== "object") mapped += `<!--!$-->`;
-      mapped += resolveSSRNode(prev = node[i]);
+const ErrorContext = {
+  id: Symbol("ErrorContext"),
+  defaultValue: null
+};
+function createErrorBoundary(fn, fallback) {
+  const ctx = sharedConfig.context;
+  const owner = signals.createOwner();
+  const parent = signals.getOwner();
+  if (parent?.id != null) signals.getNextChildId(parent);
+  owner.id = owner.id + "0";
+  return signals.runWithOwner(owner, () => {
+    let result;
+    signals.setContext(ErrorContext, err => {
+      if (ctx && !ctx.noHydrate && owner.id) ctx.serialize(owner.id, err);
+      result = fallback(err, () => {});
+    });
+    try {
+      result = fn();
+    } catch (err) {
+      if (ctx && !ctx.noHydrate && owner.id) ctx.serialize(owner.id, err);
+      result = fallback(err, () => {});
     }
-    return mapped;
-  }
-  if (t === "object") return node.t;
-  if (t === "function") return resolveSSRNode(node());
-  return String(node);
+    return () => result;
+  });
 }
-const sharedConfig = {
-  context: undefined,
-  getContextId() {
-    if (!this.context) throw new Error(`getContextId cannot be used under non-hydrating context`);
-    return getContextId(this.context.count);
-  },
-  getNextContextId() {
-    if (!this.context) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
-    return getContextId(this.context.count++);
+function createLoadBoundary(fn, fallback) {
+  try {
+    const result = fn();
+    return () => result;
+  } catch (err) {
+    if (err instanceof signals.NotReadyError) {
+      return () => fallback();
+    }
+    throw err;
   }
-};
-function getContextId(count) {
-  const num = String(count),
-    len = num.length - 1;
-  return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
-}
-function setHydrateContext(context) {
-  sharedConfig.context = context;
 }
-function nextHydrateContext() {
-  return sharedConfig.context ? {
-    ...sharedConfig.context,
-    id: sharedConfig.getNextContextId(),
-    count: 0
-  } : undefined;
+function untrack(fn) {
+  return fn();
 }
-function createUniqueId() {
-  return sharedConfig.getNextContextId();
+function flush() {}
+function resolve(fn) {
+  throw new Error("resolve is not implemented on the server");
 }
-function createComponent(Comp, props) {
-  if (sharedConfig.context && !sharedConfig.context.noHydrate) {
-    const c = sharedConfig.context;
-    setHydrateContext(nextHydrateContext());
-    const r = Comp(props || {});
-    setHydrateContext(c);
-    return r;
-  }
-  return Comp(props || {});
-}
-function mergeProps(...sources) {
-  const target = {};
-  for (let i = 0; i < sources.length; i++) {
-    let source = sources[i];
-    if (typeof source === "function") source = source();
-    if (source) {
-      const descriptors = Object.getOwnPropertyDescriptors(source);
-      for (const key in descriptors) {
-        if (key in target) continue;
-        Object.defineProperty(target, key, {
-          enumerable: true,
-          get() {
-            for (let i = sources.length - 1; i >= 0; i--) {
-              let v,
-                s = sources[i];
-              if (typeof s === "function") s = s();
-              v = (s || {})[key];
-              if (v !== undefined) return v;
-            }
-          }
-        });
-      }
+function isPending(fn, fallback) {
+  try {
+    fn();
+    return false;
+  } catch (err) {
+    if (err instanceof signals.NotReadyError && arguments.length > 1) {
+      return fallback;
     }
+    throw err;
   }
-  return target;
-}
-function splitProps(props, ...keys) {
-  const descriptors = Object.getOwnPropertyDescriptors(props),
-    split = k => {
-      const clone = {};
-      for (let i = 0; i < k.length; i++) {
-        const key = k[i];
-        if (descriptors[key]) {
-          Object.defineProperty(clone, key, descriptors[key]);
-          delete descriptors[key];
-        }
-      }
-      return clone;
-    };
-  return keys.map(split).concat(split(Object.keys(descriptors)));
 }
-function simpleMap(props, wrap) {
-  const list = props.each || [],
-    len = list.length,
-    fn = props.children;
-  if (len) {
-    let mapped = Array(len);
-    for (let i = 0; i < len; i++) mapped[i] = wrap(fn, list[i], i);
-    return mapped;
-  }
-  return props.fallback;
-}
-function For(props) {
-  return simpleMap(props, (fn, item, i) => fn(item, () => i));
+function latest(fn) {
+  return fn();
 }
-function Index(props) {
-  return simpleMap(props, (fn, item, i) => fn(() => item, i));
+function isRefreshing() {
+  return false;
 }
-function Show(props) {
-  let c;
-  return props.when ? typeof (c = props.children) === "function" ? c(props.keyed ? props.when : () => props.when) : c : props.fallback || "";
+function refresh(fn) {
+  return fn();
 }
-function Switch(props) {
-  let conditions = props.children;
-  Array.isArray(conditions) || (conditions = [conditions]);
-  for (let i = 0; i < conditions.length; i++) {
-    const w = conditions[i].when;
-    if (w) {
-      const c = conditions[i].children;
-      return typeof c === "function" ? c(conditions[i].keyed ? w : () => w) : c;
-    }
-  }
-  return props.fallback || "";
+function action(fn) {
+  return fn;
 }
-function Match(props) {
-  return props;
+function onSettled(callback) {
+  const o = signals.getOwner();
+  if (o?.id != null) signals.getNextChildId(o);
 }
-function resetErrorBoundaries() {}
-function ErrorBoundary(props) {
-  let error,
-    res,
-    clean,
-    sync = true;
-  const ctx = sharedConfig.context;
-  const id = sharedConfig.getContextId();
-  function displayFallback() {
-    cleanNode(clean);
-    ctx.serialize(id, error);
-    setHydrateContext({
-      ...ctx,
-      count: 0
+
+const $DEVCOMP = Symbol("solid-dev-component");
+function createContext(defaultValue, options) {
+  const id = Symbol(options && options.name || "");
+  function provider(props) {
+    return signals.createRoot(() => {
+      signals.setContext(provider, props.value);
+      return children(() => props.children);
     });
-    const f = props.fallback;
-    return typeof f === "function" && f.length ? f(error, () => {}) : f;
   }
-  createMemo(() => {
-    clean = Owner;
-    return catchError(() => res = props.children, err => {
-      error = err;
-      !sync && ctx.replace("e" + id, displayFallback);
-      sync = true;
-    });
+  provider.id = id;
+  provider.defaultValue = defaultValue;
+  return provider;
+}
+function useContext(context) {
+  return signals.getContext(context);
+}
+function children(fn) {
+  const c = createMemo(fn, undefined, {
+    lazy: true
   });
-  if (error) return displayFallback();
-  sync = false;
-  return {
-    t: `<!--!$e${id}-->${resolveSSRNode(escape(res))}<!--!$/e${id}-->`
+  const memo = createMemo(() => signals.flatten(c()), undefined, {
+    lazy: true
+  });
+  memo.toArray = () => {
+    const v = memo();
+    return Array.isArray(v) ? v : v != null ? [v] : [];
   };
+  return memo;
 }
-const SuspenseContext = createContext();
-let resourceContext = null;
-function createResource(source, fetcher, options = {}) {
-  if (typeof fetcher !== "function") {
-    options = fetcher || {};
-    fetcher = source;
-    source = true;
-  }
-  const contexts = new Set();
-  const id = sharedConfig.getNextContextId();
-  let resource = {};
-  let value = options.storage ? options.storage(options.initialValue)[0]() : options.initialValue;
-  let p;
-  let error;
-  if (sharedConfig.context.async && options.ssrLoadFrom !== "initial") {
-    resource = sharedConfig.context.resources[id] || (sharedConfig.context.resources[id] = {});
-    if (resource.ref) {
-      if (!resource.data && !resource.ref[0]._loading && !resource.ref[0].error) resource.ref[1].refetch();
-      return resource.ref;
-    }
-  }
-  const prepareResource = () => {
-    if (error) throw error;
-    const resolved = options.ssrLoadFrom !== "initial" && sharedConfig.context.async && "data" in sharedConfig.context.resources[id];
-    if (!resolved && resourceContext) resourceContext.push(id);
-    if (!resolved && read._loading) {
-      const ctx = useContext(SuspenseContext);
-      if (ctx) {
-        ctx.resources.set(id, read);
-        contexts.add(ctx);
-      }
-    }
-    return resolved;
-  };
-  const read = () => {
-    return prepareResource() ? sharedConfig.context.resources[id].data : value;
-  };
-  const loading = () => {
-    prepareResource();
-    return read._loading;
-  };
-  read._loading = false;
-  read.error = undefined;
-  read.state = "initialValue" in options ? "ready" : "unresolved";
-  Object.defineProperties(read, {
-    latest: {
-      get() {
-        return read();
-      }
-    },
-    loading: {
-      get() {
-        return loading();
-      }
-    }
-  });
-  function load() {
-    const ctx = sharedConfig.context;
-    if (!ctx.async) return read._loading = !!(typeof source === "function" ? source() : source);
-    if (ctx.resources && id in ctx.resources && "data" in ctx.resources[id]) {
-      value = ctx.resources[id].data;
-      return;
-    }
-    let lookup;
-    try {
-      resourceContext = [];
-      lookup = typeof source === "function" ? source() : source;
-      if (resourceContext.length) return;
-    } finally {
-      resourceContext = null;
-    }
-    if (!p) {
-      if (lookup == null || lookup === false) return;
-      p = fetcher(lookup, {
-        value
-      });
-    }
-    if (p != undefined && typeof p === "object" && "then" in p) {
-      read._loading = true;
-      read.state = "pending";
-      p = p.then(res => {
-        read._loading = false;
-        read.state = "ready";
-        ctx.resources[id].data = res;
-        p = null;
-        notifySuspense(contexts);
-        return res;
-      }).catch(err => {
-        read._loading = false;
-        read.state = "errored";
-        read.error = error = castError(err);
-        p = null;
-        notifySuspense(contexts);
-        throw error;
-      });
-      if (ctx.serialize) ctx.serialize(id, p, options.deferStream);
-      return p;
-    }
-    ctx.resources[id].data = p;
-    if (ctx.serialize) ctx.serialize(id, p);
-    p = null;
-    return ctx.resources[id].data;
-  }
-  if (options.ssrLoadFrom !== "initial") load();
-  const ref = [read, {
-    refetch: load,
-    mutate: v => value = v
-  }];
-  if (p) resource.ref = ref;
-  return ref;
+function ssrRunInScope(fn) {
+  return fn;
+}
+
+function enableHydration() {}
+function createComponent(Comp, props) {
+  return Comp(props || {});
 }
-function lazy(fn) {
+function lazy(fn, moduleUrl) {
   let p;
-  let load = id => {
+  let load = () => {
     if (!p) {
       p = fn();
-      p.then(mod => p.resolved = mod.default);
-      if (id) sharedConfig.context.lazy[id] = p;
+      p.then(mod => {
+        p.v = mod.default;
+      });
     }
     return p;
   };
-  const contexts = new Set();
   const wrap = props => {
-    const id = sharedConfig.context.id;
-    let ref = sharedConfig.context.lazy[id];
-    if (ref) p = ref;else load(id);
-    if (p.resolved) return p.resolved(props);
-    const ctx = useContext(SuspenseContext);
-    const track = {
-      _loading: true,
-      error: undefined
-    };
-    if (ctx) {
-      ctx.resources.set(id, track);
-      contexts.add(ctx);
+    if (!moduleUrl) {
+      throw new Error("lazy() used in SSR without a moduleUrl. " + "All lazy() components require a moduleUrl for correct hydration. " + "This is typically injected by the bundler plugin.");
+    }
+    if (!sharedConfig.context?.resolveAssets) {
+      throw new Error(`lazy() called with moduleUrl "${moduleUrl}" but no asset manifest is set. ` + "Pass a manifest option to renderToStream/renderToString.");
+    }
+    load();
+    const ctx = sharedConfig.context;
+    if (!ctx?.registerAsset || !ctx.resolveAssets) return;
+    const assets = ctx.resolveAssets(moduleUrl);
+    if (assets) {
+      for (let i = 0; i < assets.css.length; i++) ctx.registerAsset("style", assets.css[i]);
+      for (let i = 0; i < assets.js.length; i++) ctx.registerAsset("module", assets.js[i]);
+      ctx.registerModule?.(moduleUrl, assets.js[0]);
     }
-    if (sharedConfig.context.async) {
-      sharedConfig.context.block(p.then(() => {
-        track._loading = false;
-        notifySuspense(contexts);
+    if (ctx?.async) {
+      ctx.block(p.then(() => {
+        p.s = "success";
       }));
     }
-    return "";
+    return createMemo(() => {
+      if (!p.v) throw new signals.NotReadyError(p);
+      return p.v(props);
+    });
   };
   wrap.preload = load;
   return wrap;
 }
-function suspenseComplete(c) {
-  for (const r of c.resources.values()) {
-    if (r._loading) return false;
-  }
-  return true;
+function createUniqueId() {
+  return sharedConfig.getNextContextId();
+}
+
+function For(props) {
+  const options = "fallback" in props ? {
+    keyed: props.keyed,
+    fallback: () => props.fallback
+  } : {
+    keyed: props.keyed
+  };
+  return createMemo(mapArray(() => props.each, props.children, options));
 }
-function notifySuspense(contexts) {
-  for (const c of contexts) {
-    if (!suspenseComplete(c)) {
-      continue;
+function Repeat(props) {
+  const options = "fallback" in props ? {
+    fallback: () => props.fallback
+  } : {};
+  options.from = () => props.from;
+  return repeat(() => props.count, index => typeof props.children === "function" ? props.children(index) : props.children, options);
+}
+function Show(props) {
+  const o = signals.getOwner();
+  if (o?.id != null) {
+    signals.getNextChildId(o);
+    if (!props.keyed) signals.getNextChildId(o);
+  }
+  return createMemo(() => {
+    const when = props.when;
+    if (when) {
+      const child = props.children;
+      if (typeof child === "function" && child.length > 0) {
+        return child(() => when);
+      }
+      return child;
     }
-    c.completed();
-    contexts.delete(c);
-  }
+    return props.fallback;
+  });
 }
-function enableScheduling() {}
-function enableHydration() {}
-function startTransition(fn) {
-  fn();
+function Switch(props) {
+  const chs = children(() => props.children);
+  const o = signals.getOwner();
+  if (o?.id != null) signals.getNextChildId(o);
+  return createMemo(() => {
+    let conds = chs();
+    if (!Array.isArray(conds)) conds = [conds];
+    for (let i = 0; i < conds.length; i++) {
+      const w = conds[i].when;
+      if (w) {
+        const c = conds[i].children;
+        return typeof c === "function" && c.length > 0 ? c(() => w) : c;
+      }
+    }
+    return props.fallback;
+  });
 }
-function useTransition() {
-  return [() => false, fn => {
-    fn();
-  }];
+function Match(props) {
+  return props;
 }
-function SuspenseList(props) {
-  if (sharedConfig.context && !sharedConfig.context.noHydrate) {
-    const c = sharedConfig.context;
-    setHydrateContext(nextHydrateContext());
-    const result = props.children;
-    setHydrateContext(c);
-    return result;
+function Errored(props) {
+  return createErrorBoundary(() => props.children, (err, reset) => {
+    const f = props.fallback;
+    return typeof f === "function" && f.length ? f(err, reset) : f;
+  });
+}
+
+function ssrHandleError(err) {
+  if (err instanceof signals.NotReadyError) {
+    return err.source;
+  }
+  const handler = signals.getContext(ErrorContext);
+  if (handler) {
+    handler(err);
+    return;
   }
-  return props.children;
+  throw err;
 }
-function Suspense(props) {
-  let done;
+function Loading(props) {
   const ctx = sharedConfig.context;
-  const id = sharedConfig.getContextId();
-  const o = createOwner();
-  const value = ctx.suspense[id] || (ctx.suspense[id] = {
-    resources: new Map(),
-    completed: () => {
-      const res = runSuspense();
-      if (suspenseComplete(value)) {
-        done(resolveSSRNode(escape(res)));
+  if (!ctx) {
+    return createLoadBoundary(() => props.children, () => props.fallback);
+  }
+  const o = signals.createOwner();
+  const id = o.id;
+  o.id = id + "00";
+  let runPromise;
+  let serializeBuffer = [];
+  const origSerialize = ctx.serialize;
+  function runInitially() {
+    o.dispose(false);
+    serializeBuffer = [];
+    ctx.serialize = (id, p, deferStream) => {
+      serializeBuffer.push([id, p, deferStream]);
+    };
+    const prevBoundary = ctx._currentBoundaryId;
+    ctx._currentBoundaryId = id;
+    const result = signals.runWithOwner(o, () => {
+      try {
+        return ctx.resolve(props.children);
+      } catch (err) {
+        runPromise = ssrHandleError(err);
       }
-    }
-  });
-  function suspenseError(err) {
-    if (!done || !done(undefined, err)) {
-      runWithOwner(o.owner, () => {
-        throw err;
-      });
-    }
-  }
-  function runSuspense() {
-    setHydrateContext({
-      ...ctx,
-      count: 0
     });
-    cleanNode(o);
-    return runWithOwner(o, () => createComponent(SuspenseContext.Provider, {
-      value,
-      get children() {
-        return catchError(() => props.children, suspenseError);
-      }
-    }));
+    ctx._currentBoundaryId = prevBoundary;
+    ctx.serialize = origSerialize;
+    return result;
   }
-  const res = runSuspense();
-  if (suspenseComplete(value)) {
-    delete ctx.suspense[id];
-    return res;
+  let ret = runInitially();
+  if (!(runPromise || ret?.p?.length)) {
+    for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
+    serializeBuffer = [];
+    const modules = ctx.getBoundaryModules?.(id);
+    if (modules) ctx.serialize(id + "_assets", modules);
+    return ret;
   }
-  done = ctx.async ? ctx.registerFragment(id) : undefined;
-  return catchError(() => {
-    if (ctx.async) {
-      setHydrateContext({
-        ...ctx,
-        count: 0,
-        id: ctx.id + "0F",
-        noHydrate: true
-      });
-      const res = {
-        t: `<template id="pl-${id}"></template>${resolveSSRNode(escape(props.fallback))}<!--pl-${id}-->`
-      };
-      setHydrateContext(ctx);
-      return res;
-    }
-    setHydrateContext({
-      ...ctx,
-      count: 0,
-      id: ctx.id + "0F"
-    });
-    ctx.serialize(id, "$$f");
-    return props.fallback;
-  }, suspenseError);
+  const fallbackOwner = signals.createOwner({
+    id
+  });
+  signals.getNextChildId(fallbackOwner);
+  if (ctx.async) {
+    const done = ctx.registerFragment(id);
+    (async () => {
+      try {
+        while (runPromise) {
+          o.dispose(false);
+          await runPromise;
+          runPromise = undefined;
+          ret = runInitially();
+        }
+        for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
+        serializeBuffer = [];
+        while (ret.p.length) {
+          await Promise.all(ret.p);
+          ret = signals.runWithOwner(o, () => ctx.ssr(ret.t, ...ret.h));
+        }
+        done(ret.t[0]);
+      } catch (err) {
+        done(undefined, err);
+      }
+    })();
+    return signals.runWithOwner(fallbackOwner, () => ctx.ssr([`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`], ctx.escape(props.fallback)));
+  }
+  for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
+  serializeBuffer = [];
+  const modules = ctx.getBoundaryModules?.(id);
+  if (modules) ctx.serialize(id + "_assets", modules);
+  ctx.serialize(id, "$$f");
+  return signals.runWithOwner(fallbackOwner, () => props.fallback);
 }
 
+const DEV = undefined;
+
+Object.defineProperty(exports, "$PROXY", {
+  enumerable: true,
+  get: function () { return signals.$PROXY; }
+});
+Object.defineProperty(exports, "$TRACK", {
+  enumerable: true,
+  get: function () { return signals.$TRACK; }
+});
+Object.defineProperty(exports, "NotReadyError", {
+  enumerable: true,
+  get: function () { return signals.NotReadyError; }
+});
+Object.defineProperty(exports, "createOwner", {
+  enumerable: true,
+  get: function () { return signals.createOwner; }
+});
+Object.defineProperty(exports, "createRoot", {
+  enumerable: true,
+  get: function () { return signals.createRoot; }
+});
+Object.defineProperty(exports, "flatten", {
+  enumerable: true,
+  get: function () { return signals.flatten; }
+});
+Object.defineProperty(exports, "getNextChildId", {
+  enumerable: true,
+  get: function () { return signals.getNextChildId; }
+});
+Object.defineProperty(exports, "getOwner", {
+  enumerable: true,
+  get: function () { return signals.getOwner; }
+});
+Object.defineProperty(exports, "isEqual", {
+  enumerable: true,
+  get: function () { return signals.isEqual; }
+});
+Object.defineProperty(exports, "isWrappable", {
+  enumerable: true,
+  get: function () { return signals.isWrappable; }
+});
+Object.defineProperty(exports, "merge", {
+  enumerable: true,
+  get: function () { return signals.merge; }
+});
+Object.defineProperty(exports, "omit", {
+  enumerable: true,
+  get: function () { return signals.omit; }
+});
+Object.defineProperty(exports, "onCleanup", {
+  enumerable: true,
+  get: function () { return signals.onCleanup; }
+});
+Object.defineProperty(exports, "runWithOwner", {
+  enumerable: true,
+  get: function () { return signals.runWithOwner; }
+});
+Object.defineProperty(exports, "snapshot", {
+  enumerable: true,
+  get: function () { return signals.snapshot; }
+});
+Object.defineProperty(exports, "storePath", {
+  enumerable: true,
+  get: function () { return signals.storePath; }
+});
 exports.$DEVCOMP = $DEVCOMP;
-exports.$PROXY = $PROXY;
-exports.$TRACK = $TRACK;
 exports.DEV = DEV;
-exports.ErrorBoundary = ErrorBoundary;
+exports.Errored = Errored;
 exports.For = For;
-exports.Index = Index;
+exports.Loading = Loading;
 exports.Match = Match;
+exports.Repeat = Repeat;
 exports.Show = Show;
-exports.Suspense = Suspense;
-exports.SuspenseList = SuspenseList;
 exports.Switch = Switch;
-exports.batch = batch;
-exports.catchError = catchError;
+exports.action = action;
 exports.children = children;
 exports.createComponent = createComponent;
-exports.createComputed = createComputed;
 exports.createContext = createContext;
-exports.createDeferred = createDeferred;
+exports.createDeepProxy = createDeepProxy;
 exports.createEffect = createEffect;
 exports.createMemo = createMemo;
+exports.createOptimistic = createOptimistic;
+exports.createOptimisticStore = createOptimisticStore;
+exports.createProjection = createProjection;
 exports.createReaction = createReaction;
 exports.createRenderEffect = createRenderEffect;
-exports.createResource = createResource;
-exports.createRoot = createRoot;
-exports.createSelector = createSelector;
 exports.createSignal = createSignal;
+exports.createStore = createStore;
+exports.createTrackedEffect = createTrackedEffect;
 exports.createUniqueId = createUniqueId;
-exports.enableExternalSource = enableExternalSource;
+exports.deep = deep;
 exports.enableHydration = enableHydration;
-exports.enableScheduling = enableScheduling;
-exports.equalFn = equalFn;
-exports.from = from;
-exports.getListener = getListener;
-exports.getOwner = getOwner;
-exports.indexArray = indexArray;
+exports.flush = flush;
+exports.getObserver = getObserver;
+exports.isPending = isPending;
+exports.isRefreshing = isRefreshing;
+exports.latest = latest;
 exports.lazy = lazy;
 exports.mapArray = mapArray;
-exports.mergeProps = mergeProps;
-exports.observable = observable;
-exports.on = on;
-exports.onCleanup = onCleanup;
-exports.onError = onError;
-exports.onMount = onMount;
-exports.requestCallback = requestCallback;
-exports.resetErrorBoundaries = resetErrorBoundaries;
-exports.runWithOwner = runWithOwner;
+exports.onSettled = onSettled;
+exports.reconcile = reconcile;
+exports.refresh = refresh;
+exports.repeat = repeat;
+exports.resolve = resolve;
 exports.sharedConfig = sharedConfig;
-exports.splitProps = splitProps;
-exports.startTransition = startTransition;
+exports.ssrHandleError = ssrHandleError;
+exports.ssrRunInScope = ssrRunInScope;
 exports.untrack = untrack;
 exports.useContext = useContext;
-exports.useTransition = useTransition;