solid-js 2.0.0-experimental.2 → 2.0.0-experimental.4

package/dist/server.cjs

@@ -1,130 +1,129 @@
 '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);
-  }
-}
-const UNOWNED = {
-  context: null,
-  owner: null,
-  owned: null,
-  cleanups: null
-};
+var signals = require('@solidjs/signals');
+
 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) {
+let Observer = null;
+function createRoot(fn) {
   const owner = Owner,
-    current = detachedOwner === undefined ? owner : detachedOwner,
-    root = fn.length === 0 ? UNOWNED : {
-      context: current ? current.context : null,
-      owner: current,
+    root = {
+      context: owner ? owner.context : null,
+      owner: owner,
       owned: null,
       cleanups: null
     };
   Owner = root;
-  let result;
   try {
-    result = fn(fn.length === 0 ? () => {} : () => cleanNode(root));
-  } catch (err) {
-    handleError(err);
+    return fn(fn.length === 0 ? () => {} : () => cleanNode(root));
   } finally {
     Owner = owner;
   }
-  return result;
 }
-function createSignal(value, options) {
-  return [() => value, v => {
-    return value = typeof v === "function" ? v(value) : v;
+function createSignal(first, second, third) {
+  if (typeof first === "function") {
+    const memo = createMemo(p => {
+      let value = first(p ? p[0]() : second);
+      return [() => value, v => {
+        return value = typeof v === "function" ? v(first) : v;
+      }];
+    });
+    return [() => memo()[0](), v => memo()[1](v)];
+  }
+  return [() => first, v => {
+    return first = typeof v === "function" ? v(first) : v;
   }];
 }
-function createComputed(fn, value) {
+function createMemo(compute, value, options) {
   Owner = createOwner();
+  let v;
   try {
-    fn(value);
-  } catch (err) {
-    handleError(err);
+    v = compute(value);
   } finally {
     Owner = Owner.owner;
   }
+  return () => v;
 }
-const createRenderEffect = createComputed;
-function createEffect(fn, value) {}
-function createReaction(fn) {
-  return fn => {
-    fn();
-  };
-}
-function createMemo(fn, value) {
+function createRenderEffect(compute, effect, value, options) {
   Owner = createOwner();
-  let v;
   try {
-    v = fn(value);
+    effect(compute(value), value);
   } catch (err) {
-    handleError(err);
   } finally {
     Owner = Owner.owner;
   }
-  return () => v;
 }
-function createDeferred(source) {
-  return source;
+function createEffect(compute, effect, error, value, options) {}
+function createAsync() {
 }
-function createSelector(source, fn = equalFn) {
-  return k => fn(k, source());
+function isPending() {
 }
-function batch(fn) {
-  return fn();
+function latest() {
 }
-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);
-  };
+function resolve() {
+}
+function flushSync() {}
+function getObserver() {
+  return Observer;
+}
+function getOwner() {
+  return Owner;
+}
+function runWithOwner(o, fn) {
+  const prev = Owner;
+  Owner = o;
+  try {
+    return fn();
+  } finally {
+    Owner = prev;
+  }
+}
+function runWithObserver(o, fn) {
+  const prev = Observer;
+  Observer = o;
+  try {
+    return fn();
+  } finally {
+    Observer = prev;
+  }
+}
+function untrack(fn) {
+  return fn();
 }
-function onMount(fn) {}
 function onCleanup(fn) {
   if (Owner) {
     if (!Owner.cleanups) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
   }
   return fn;
 }
+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 repeat(count, mapFn, options = {}) {
+  const len = count();
+  const offset = options.from?.() || 0;
+  let s = [];
+  if (len) {
+    for (let i = 0; i < len; i++) s.push(mapFn(i + offset));
+  } else if (options.fallback) s = [options.fallback()];
+  return () => s;
+}
+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 cleanNode(node) {
   if (node.owned) {
     for (let i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
@@ -135,128 +134,45 @@ function cleanNode(node) {
     node.cleanups = null;
   }
 }
-function catchError(fn, handler) {
-  const owner = createOwner();
-  owner.context = {
-    ...owner.context,
-    [ERROR]: [handler]
-  };
-  Owner = owner;
-  try {
-    return fn();
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
-  }
-}
-function getListener() {
-  return null;
-}
+
+function onMount(fn) {}
 function createContext(defaultValue) {
   const id = Symbol("context");
-  return {
-    id,
-    Provider: createProvider(id),
-    defaultValue
-  };
+  const P = createProvider(id);
+  P.id = id;
+  P.defaultValue = defaultValue;
+  return P;
 }
 function useContext(context) {
-  return Owner && Owner.context && Owner.context[context.id] !== undefined ? Owner.context[context.id] : context.defaultValue;
-}
-function getOwner() {
-  return Owner;
+  const owner = getOwner();
+  return owner && owner.context && owner.context[context.id] !== undefined ? owner.context[context.id] : context.defaultValue;
 }
 function children(fn) {
-  const memo = createMemo(() => resolveChildren(fn()));
+  const children = createMemo(fn);
+  const memo = createMemo(() => signals.flatten(children()));
   memo.toArray = () => {
     const c = memo();
     return Array.isArray(c) ? c : c != null ? [c] : [];
   };
   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);
-    }
-    return results;
-  }
-  return children;
-}
 function createProvider(id) {
   return function provider(props) {
     return createMemo(() => {
-      Owner.context = {
-        ...Owner.context,
+      const owner = getOwner();
+      owner.context = {
+        ...owner.context,
         [id]: props.value
       };
       return children(() => props.children);
     });
   };
 }
-function requestCallback(fn, options) {
-  return {
-    id: 0,
-    fn: () => {},
-    startTime: 0,
-    expirationTime: 0
-  };
-}
-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));
-        });
-        return disposer;
-      });
-      if (getOwner()) onCleanup(dispose);
       return {
-        unsubscribe() {
-          dispose();
-        }
+        unsubscribe() {}
       };
     },
     [Symbol.observable || "@@observable"]() {
@@ -265,7 +181,9 @@ function observable(input) {
   };
 }
 function from(producer) {
-  const [s, set] = createSignal(undefined);
+  const [s, set] = createSignal(undefined, {
+    equals: false
+  });
   if ("subscribe" in producer) {
     const unsub = producer.subscribe(v => set(() => v));
     onCleanup(() => "unsubscribe" in unsub ? unsub.unsubscribe() : unsub());
@@ -275,95 +193,85 @@ function from(producer) {
   }
   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 isWrappable(obj) {
+  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
 }
-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 unwrap(item) {
+  return item;
+}
+function setProperty(state, property, value) {
+  if (state[property] === value) return;
+  if (value === undefined) {
+    delete state[property];
+  } else state[property] = value;
+}
+function createStore(state) {
+  function setStore(fn) {
+    fn(state);
   }
+  return [state, setStore];
 }
-
-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;
+function createProjection(fn, initialValue = {}) {
+  const [state] = createStore(initialValue);
+  fn(state);
+  return state;
+}
+function reconcile(value) {
+  return state => {
+    if (!isWrappable(state) || !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]);
     }
-    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);
+    for (let i = 0, len = previousKeys.length; i < len; i++) {
+      if (value[previousKeys[i]] === undefined) setProperty(state, previousKeys[i], undefined);
+    }
+    return state;
+  };
+}
+function merge(...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],
+                t = typeof s;
+              if (t === "function") s = s();
+              if (t === "object" && t !== null && key in s) return v;
+            }
+          }
+        });
+      }
     }
   }
-  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]);
+  return target;
+}
+function omit(props, ...keys) {
+  const descriptors = Object.getOwnPropertyDescriptors(props),
+    descriptorKeys = Object.keys(descriptors),
+    clone = {};
+  for (let i = 0; i < descriptorKeys.length; i++) {
+    const key = descriptorKeys[i];
+    if (keys.indexOf(key) === -1) {
+      Object.defineProperty(clone, key, descriptors[key]);
+      delete descriptors[key];
     }
-    return mapped;
   }
-  if (t === "object") return node.t;
-  if (t === "function") return resolveSSRNode(node());
-  return String(node);
+  return clone;
 }
+
 const sharedConfig = {
   context: undefined,
   getContextId() {
@@ -403,67 +311,20 @@ function createComponent(Comp, props) {
   }
   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;
-            }
-          }
-        });
-      }
-    }
-  }
-  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));
+  return mapArray(() => props.each, props.children, {
+    fallback: () => props.fallback
+  });
 }
-function Index(props) {
-  return simpleMap(props, (fn, item, i) => fn(() => item, i));
+function Repeat(props) {
+  return repeat(() => props.count, index => props.children(index), {
+    fallback: () => props.fallback,
+    from: () => props.from
+  });
 }
 function Show(props) {
   let c;
-  return props.when ? typeof (c = props.children) === "function" ? c(props.keyed ? props.when : () => props.when) : c : props.fallback || "";
+  return props.when ? typeof (c = props.children) === "function" ? c(() => props.when) : c : props.fallback || "";
 }
 function Switch(props) {
   let conditions = props.children;
@@ -472,7 +333,7 @@ function Switch(props) {
     const w = conditions[i].when;
     if (w) {
       const c = conditions[i].children;
-      return typeof c === "function" ? c(conditions[i].keyed ? w : () => w) : c;
+      return typeof c === "function" ? c(() => w) : c;
     }
   }
   return props.fallback || "";
@@ -480,348 +341,87 @@ function Switch(props) {
 function Match(props) {
   return props;
 }
-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 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;
-    });
-  });
-  if (error) return displayFallback();
-  sync = false;
-  return {
-    t: `<!--!$e${id}-->${resolveSSRNode(escape(res))}<!--!$/e${id}-->`
-  };
-}
-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 read = () => {
-    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 ? sharedConfig.context.resources[id].data : value;
-  };
-  read.loading = false;
-  read.error = undefined;
-  read.state = "initialValue" in options ? "ready" : "unresolved";
-  Object.defineProperty(read, "latest", {
-    get() {
-      return read();
-    }
-  });
-  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();
-  return resource.ref = [read, {
-    refetch: load,
-    mutate: v => value = v
-  }];
 }
 function lazy(fn) {
-  let p;
-  let load = id => {
-    if (!p) {
-      p = fn();
-      p.then(mod => p.resolved = mod.default);
-      if (id) sharedConfig.context.lazy[id] = p;
-    }
-    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 (sharedConfig.context.async) {
-      sharedConfig.context.block(p.then(() => {
-        track.loading = false;
-        notifySuspense(contexts);
-      }));
-    }
-    return "";
-  };
-  wrap.preload = load;
-  return wrap;
+  return {};
 }
-function suspenseComplete(c) {
-  for (const r of c.resources.values()) {
-    if (r.loading) return false;
-  }
-  return true;
-}
-function notifySuspense(contexts) {
-  for (const c of contexts) {
-    if (!suspenseComplete(c)) {
-      continue;
-    }
-    c.completed();
-    contexts.delete(c);
-  }
-}
-function enableScheduling() {}
 function enableHydration() {}
-function startTransition(fn) {
-  fn();
-}
-function useTransition() {
-  return [() => false, fn => {
-    fn();
-  }];
-}
-function SuspenseList(props) {
-  return props.children;
-}
 function Suspense(props) {
-  let done;
-  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)));
-      }
-    }
-  });
-  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);
-      }
-    }));
-  }
-  const res = runSuspense();
-  if (suspenseComplete(value)) {
-    delete ctx.suspense[id];
-    return res;
-  }
-  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);
 }
 
-function isWrappable(obj) {
-  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
-}
-function unwrap(item) {
-  return item;
-}
-function setProperty(state, property, value) {
-  if (state[property] === value) return;
-  if (value === undefined) {
-    delete state[property];
-  } else state[property] = value;
-}
-function createStore(state) {
-  function setStore(fn) {
-    fn(state);
-  }
-  return [state, setStore];
-}
-function reconcile(value) {
-  return state => {
-    if (!isWrappable(state) || !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;
-  };
-}
+const $DEVCOMP = Symbol("solid-dev-component");
+const DEV = undefined;
 
+Object.defineProperty(exports, "$PROXY", {
+  enumerable: true,
+  get: function () { return signals.$PROXY; }
+});
+Object.defineProperty(exports, "$RAW", {
+  enumerable: true,
+  get: function () { return signals.$RAW; }
+});
+Object.defineProperty(exports, "$TRACK", {
+  enumerable: true,
+  get: function () { return signals.$TRACK; }
+});
+Object.defineProperty(exports, "catchError", {
+  enumerable: true,
+  get: function () { return signals.catchError; }
+});
+Object.defineProperty(exports, "flatten", {
+  enumerable: true,
+  get: function () { return signals.flatten; }
+});
+Object.defineProperty(exports, "isEqual", {
+  enumerable: true,
+  get: function () { return signals.isEqual; }
+});
+Object.defineProperty(exports, "isWrappable", {
+  enumerable: true,
+  get: function () { return signals.isWrappable; }
+});
 exports.$DEVCOMP = $DEVCOMP;
-exports.$PROXY = $PROXY;
-exports.$TRACK = $TRACK;
 exports.DEV = DEV;
 exports.ErrorBoundary = ErrorBoundary;
 exports.For = For;
-exports.Index = Index;
 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.children = children;
+exports.createAsync = createAsync;
 exports.createComponent = createComponent;
 exports.createContext = createContext;
-exports.createDeferred = createDeferred;
 exports.createEffect = createEffect;
 exports.createMemo = createMemo;
-exports.createReaction = createReaction;
+exports.createProjection = createProjection;
 exports.createRenderEffect = createRenderEffect;
-exports.createResource = createResource;
 exports.createRoot = createRoot;
-exports.createSelector = createSelector;
 exports.createSignal = createSignal;
 exports.createStore = createStore;
 exports.createUniqueId = createUniqueId;
-exports.enableExternalSource = enableExternalSource;
 exports.enableHydration = enableHydration;
-exports.enableScheduling = enableScheduling;
-exports.equalFn = equalFn;
+exports.flushSync = flushSync;
 exports.from = from;
-exports.getListener = getListener;
+exports.getObserver = getObserver;
 exports.getOwner = getOwner;
-exports.indexArray = indexArray;
-exports.isWrappable = isWrappable;
+exports.isPending = isPending;
+exports.latest = latest;
 exports.lazy = lazy;
 exports.mapArray = mapArray;
-exports.mergeProps = mergeProps;
+exports.merge = merge;
 exports.observable = observable;
-exports.on = on;
+exports.omit = omit;
 exports.onCleanup = onCleanup;
-exports.onError = onError;
 exports.onMount = onMount;
 exports.reconcile = reconcile;
-exports.requestCallback = requestCallback;
-exports.resetErrorBoundaries = resetErrorBoundaries;
+exports.repeat = repeat;
+exports.resolve = resolve;
+exports.runWithObserver = runWithObserver;
 exports.runWithOwner = runWithOwner;
 exports.sharedConfig = sharedConfig;
-exports.splitProps = splitProps;
-exports.startTransition = startTransition;
 exports.untrack = untrack;
 exports.unwrap = unwrap;
 exports.useContext = useContext;
-exports.useTransition = useTransition;