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

package/dist/server.js

@@ -1,129 +1,95 @@
-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
-};
+import { flatten } from "@solidjs/signals";
+export { $PROXY, $RAW, $TRACK, catchError, flatten, isEqual, isWrappable } from "@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,
-            owned: null,
-            cleanups: null
-          };
+    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) {
+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 [
-    () => value,
+    () => first,
     v => {
-      return (value = typeof v === "function" ? v(value) : 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 isPending() {}
+function latest() {}
+function resolve() {}
+function flushSync() {}
+function getObserver() {
+  return Observer;
 }
-function createSelector(source, fn = equalFn) {
-  return k => fn(k, source());
+function getOwner() {
+  return Owner;
 }
-function batch(fn) {
-  return fn();
+function runWithOwner(o, fn) {
+  const prev = Owner;
+  Owner = o;
+  try {
+    return fn();
+  } finally {
+    Owner = prev;
+  }
 }
-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 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];
@@ -131,6 +97,42 @@ function onCleanup(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]);
@@ -141,131 +143,47 @@ 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]
+  const owner = getOwner();
+  return owner && owner.context && owner.context[context.id] !== undefined
+    ? owner.context[context.id]
     : context.defaultValue;
 }
-function getOwner() {
-  return Owner;
-}
 function children(fn) {
-  const memo = createMemo(() => resolveChildren(fn()));
+  const children = createMemo(fn);
+  const memo = createMemo(() => 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"]() {
@@ -274,7 +192,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()));
@@ -284,96 +204,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);
     }
-  }
-  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 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;
+            }
+          }
+        });
+      }
     }
-  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() {
@@ -416,69 +325,26 @@ 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.when)
       : c
     : props.fallback || "";
 }
@@ -489,7 +355,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 || "";
@@ -497,374 +363,59 @@ 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 ErrorBoundary(props) {}
 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 Suspense(props) {}
 
-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;
 
 export {
   $DEVCOMP,
-  $PROXY,
-  $TRACK,
   DEV,
   ErrorBoundary,
   For,
-  Index,
   Match,
+  Repeat,
   Show,
   Suspense,
-  SuspenseList,
   Switch,
-  batch,
-  catchError,
   children,
+  createAsync,
   createComponent,
   createContext,
-  createDeferred,
   createEffect,
   createMemo,
-  createReaction,
+  createProjection,
   createRenderEffect,
-  createResource,
   createRoot,
-  createSelector,
   createSignal,
   createStore,
   createUniqueId,
-  enableExternalSource,
   enableHydration,
-  enableScheduling,
-  equalFn,
+  flushSync,
   from,
-  getListener,
+  getObserver,
   getOwner,
-  indexArray,
-  isWrappable,
+  isPending,
+  latest,
   lazy,
   mapArray,
-  mergeProps,
+  merge,
   observable,
-  on,
+  omit,
   onCleanup,
-  onError,
   onMount,
   reconcile,
-  requestCallback,
-  resetErrorBoundaries,
+  repeat,
+  resolve,
+  runWithObserver,
   runWithOwner,
   sharedConfig,
-  splitProps,
-  startTransition,
   untrack,
   unwrap,
-  useContext,
-  useTransition
+  useContext
 };