solid-js 2.0.0-experimental.0 → 2.0.0-experimental.10

package/dist/server.js

@@ -1,271 +1,38 @@
-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
-};
-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;
-  try {
-    result = fn(fn.length === 0 ? () => {} : () => cleanNode(root));
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = owner;
-  }
-  return result;
-}
-function createSignal(value, options) {
-  return [
-    () => value,
-    v => {
-      return (value = typeof v === "function" ? v(value) : v);
-    }
-  ];
-}
-function createComputed(fn, value) {
-  Owner = createOwner();
-  try {
-    fn(value);
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
-  }
-}
-const createRenderEffect = createComputed;
-function createEffect(fn, value) {}
-function createReaction(fn) {
-  return fn => {
-    fn();
-  };
-}
-function createMemo(fn, value) {
-  Owner = createOwner();
-  let v;
-  try {
-    v = fn(value);
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
-  }
-  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);
-  };
-}
-function onMount(fn) {}
-function onCleanup(fn) {
-  if (Owner) {
-    if (!Owner.cleanups) Owner.cleanups = [fn];
-    else Owner.cleanups.push(fn);
-  }
-  return fn;
-}
-function cleanNode(node) {
-  if (node.owned) {
-    for (let i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
-    node.owned = null;
-  }
-  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]
-  };
-  Owner = owner;
-  try {
-    return fn();
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
+import { getContext, onCleanup, Owner, runWithOwner, createRoot, setContext, flatten, NotReadyError, getOwner } from '@solidjs/signals';
+export { $PROXY, $TRACK, createRoot, flatten, getOwner, isEqual, isWrappable, onCleanup, runWithOwner } from '@solidjs/signals';
+
+function onMount(fn) {
+  createEffect();
+}
+function createContext(defaultValue, options) {
+  const id = Symbol(options && options.name || "");
+  function provider(props) {
+    return createRoot(() => {
+      setContext(provider, props.value);
+      return children(() => props.children);
+    });
   }
-}
-function getListener() {
-  return null;
-}
-function createContext(defaultValue) {
-  const id = Symbol("context");
-  return {
-    id,
-    Provider: createProvider(id),
-    defaultValue
-  };
+  provider.id = id;
+  provider.defaultValue = defaultValue;
+  return provider;
 }
 function useContext(context) {
-  return Owner && Owner.context && Owner.context[context.id] !== undefined
-    ? Owner.context[context.id]
-    : context.defaultValue;
-}
-function getOwner() {
-  return Owner;
+  return getContext(context);
 }
 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,
-        [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,506 +41,365 @@ 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()));
+    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 ssrRunInScope(fn) {
+  if (Array.isArray(fn)) {
+    const o = new Owner();
+    return fn.map(f => runWithOwner.bind(null, o, f));
   }
+  return runWithOwner.bind(null, new Owner(), fn);
 }
 
-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 ErrorContext = {
+  id: Symbol("ErrorContext"),
+  defaultValue: null
+};
+function ssrHandleError(err) {
+  if (err instanceof NotReadyError) {
+    return err.cause;
   }
-  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);
-    }
+  const handler = getContext(ErrorContext);
+  if (handler) {
+    handler(err);
+    return;
   }
-  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 mapped;
-  }
-  if (t === "object") return node.t;
-  if (t === "function") return resolveSSRNode(node());
-  return String(node);
+  throw err;
 }
 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++);
+    const o = getOwner();
+    if (!o) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
+    return o.getNextChildId();
   }
 };
-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 createUniqueId() {
   return sharedConfig.getNextContextId();
 }
 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;
-            }
-          }
-        });
-      }
-    }
-  }
-  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 Index(props) {
-  return simpleMap(props, (fn, item, i) => fn(() => item, i));
+  return createMemo(mapArray(() => props.each, props.children, {
+    fallback: () => props.fallback
+  }));
+}
+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 || "";
+  const when = props.when;
+  return when ? typeof (c = props.children) === "function" ? c(() => when) : c : props.fallback || "";
 }
 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;
+  const o = getOwner();
+  const conditions = children(() => props.children);
+  o.getNextChildId();
+  return createMemo(() => {
+    let conds = conditions();
+    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(() => w) : c;
+      }
     }
-  }
-  return props.fallback || "";
+    return props.fallback || "";
+  });
 }
 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
+  let sync = true;
+  return createMemo(() => {
+    const o = getOwner();
+    const id = o.id;
+    let res;
+    setContext(ErrorContext, err => {
+      o.dispose(false);
+      ctx.serialize(id, err);
+      runWithOwner(o, () => {
+        const f = props.fallback;
+        res = typeof f === "function" && f.length ? f(err, () => {}) : f;
+        !sync && ctx.replace("e" + id, () => res);
       });
+    }, o);
+    try {
+      res = flatten(props.children);
+    } catch (err) {
+      ssrHandleError(err);
     }
-    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)
-    }
-  ]);
+    sync = false;
+    return ctx.ssr([`<!--!$e${id}-->`, `<!--!$/e${id}-->`], ctx.escape(res));
+  });
 }
 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;
+      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);
-    }
+    sharedConfig.getNextContextId();
+    load();
+    if (p.v) return p.v(props);
     if (sharedConfig.context.async) {
-      sharedConfig.context.block(
-        p.then(() => {
-          track.loading = false;
-          notifySuspense(contexts);
-        })
-      );
+      sharedConfig.context.block(p.then(() => {
+        p.s = "success";
+      }));
     }
-    return "";
+    const err = new NotReadyError();
+    err.cause = p;
+    throw err;
   };
   wrap.preload = load;
   return wrap;
 }
-function suspenseComplete(c) {
-  for (const r of c.resources.values()) {
-    if (r.loading) return false;
+function enableHydration() {}
+function Suspense(props) {
+  const ctx = sharedConfig.context;
+  const o = new Owner();
+  const id = o.id;
+  o.id += "00";
+  let runPromise;
+  function runInitially() {
+    o.dispose(false);
+    return runWithOwner(o, () => {
+      try {
+        return ctx.resolve(flatten(props.children));
+      } catch (err) {
+        runPromise = ssrHandleError(err);
+      }
+    });
+  }
+  let ret = runInitially();
+  if (!(runPromise || ret.p.length)) return ret;
+  const fallbackOwner = new Owner(id);
+  fallbackOwner.getNextChildId();
+  if (ctx.async) {
+    const done = ctx.registerFragment(id);
+    (async () => {
+      while (runPromise) {
+        await runPromise;
+        runPromise = undefined;
+        ret = runInitially();
+      }
+      while (ret.p.length) {
+        await Promise.all(ret.p);
+        ret = ctx.ssr(ret.t, ...ret.h);
+      }
+      done(ret.t[0]);
+    })();
+    return runWithOwner(fallbackOwner, () => ctx.ssr([`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`], ctx.escape(props.fallback)));
   }
-  return true;
+  ctx.serialize(id, "$$f");
+  return runWithOwner(fallbackOwner, () => props.fallback);
 }
-function notifySuspense(contexts) {
-  for (const c of contexts) {
-    if (!suspenseComplete(c)) {
-      continue;
+
+class Computation extends Owner {
+  constructor(initialValue, compute) {
+    super();
+    this._value = initialValue;
+    this._compute = compute;
+  }
+  update() {
+    try {
+      this._error = undefined;
+      runWithOwner(this, () => runWithObserver(this, () => this._value = this._compute(this._value)));
+    } catch (err) {
+      this._error = err;
+    }
+  }
+  read() {
+    if (this._error) {
+      throw this._error;
     }
-    c.completed();
-    contexts.delete(c);
+    return this._value;
   }
 }
-function enableScheduling() {}
-function enableHydration() {}
-function startTransition(fn) {
-  fn();
+let Observer = null;
+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)];
+  }
+  let o = getOwner();
+  if (o?.id != null) o?.getNextChildId();
+  return [() => first, v => {
+    return first = typeof v === "function" ? v(first) : v;
+  }];
 }
-function useTransition() {
-  return [
-    () => false,
-    fn => {
-      fn();
-    }
-  ];
+function createMemo(compute, value, options) {
+  const node = new Computation(value, compute);
+  let v;
+  return () => {
+    if (v !== undefined) return v;
+    node.update();
+    return v = node.read();
+  };
 }
-function SuspenseList(props) {
-  return props.children;
+function createRenderEffect(compute, effect, value, options) {
+  const node = new Computation(value, compute);
+  node.update();
+  try {
+    effect(node.read(), value);
+  } catch (err) {
+  }
 }
-function Suspense(props) {
-  let done;
+function createEffect(compute, effect, value, options) {
+  let o = getOwner();
+  if (o?.id !== null) o?.getNextChildId();
+}
+function createTrackedEffect(compute, options) {
+  let o = getOwner();
+  if (o?.id !== null) o?.getNextChildId();
+}
+function createReaction(effect, options) {
+  return tracking => {
+    tracking();
+  };
+}
+function createAsync(compute, value, options) {
   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)));
-        }
+  const o = new Owner();
+  const id = o.id;
+  let uninitialized = value === undefined;
+  let source;
+  function processSource() {
+    try {
+      source = runWithOwner(o, () => runWithObserver(o, () => compute(value)));
+    } catch (err) {
+      if (err instanceof NotReadyError) {
+        (source = err.cause).then(() => processSource());
       }
-    });
-  function suspenseError(err) {
-    if (!done || !done(undefined, err)) {
-      runWithOwner(o.owner, () => {
-        throw err;
+      return;
+    }
+    const iterator = source[Symbol.asyncIterator];
+    if (source instanceof Promise) {
+      source.then(v => {
+        source.s = "success";
+        return source.value = value = v;
+      });
+      if (ctx.serialize) ctx.serialize(id, source, options?.deferStream);
+      return;
+    } else if (iterator) {
+      source = iterator().next().then(v => {
+        source.s = "success";
+        return source.value = value = v.value;
       });
+      if (ctx.serialize) ctx.serialize(id, iterator(), options?.deferStream);
+      return;
     }
+    return () => source;
   }
-  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;
+  return processSource() || (() => {
+    if (value === undefined && uninitialized) {
+      const error = new NotReadyError();
+      error.cause = source;
+      throw error;
+    }
+    return value;
+  });
+}
+function isPending(fn, fallback) {
+  try {
+    fn();
+    return false;
+  } catch (err) {
+    if (err instanceof NotReadyError && arguments.length > 1) {
+      return fallback;
+    }
+    throw err;
   }
-  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;
+}
+function latest(fn, fallback) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof NotReadyError && arguments.length > 1) {
+      return fallback;
     }
-    setHydrateContext({
-      ...ctx,
-      count: 0,
-      id: ctx.id + "0F"
-    });
-    ctx.serialize(id, "$$f");
-    return props.fallback;
-  }, suspenseError);
+    throw err;
+  }
+}
+function resolve() {
+  throw new Error("resolve is not implemented on the server");
+}
+function flush() {}
+function getObserver() {
+  return Observer;
+}
+function runWithObserver(o, fn) {
+  const prev = Observer;
+  Observer = o;
+  try {
+    return fn();
+  } finally {
+    Observer = prev;
+  }
+}
+function untrack(fn) {
+  return fn();
+}
+function mapArray(list, mapFn, options = {}) {
+  const root = getOwner();
+  const id = root.getNextChildId();
+  return () => {
+    const items = list();
+    let s = [];
+    if (items && items.length) {
+      for (let i = 0, len = items.length; i < len; i++) {
+        const o = new Owner(id + i, true);
+        root.append(o);
+        s.push(runWithOwner(o, () => 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 transition(fn) {
+}
+function useTransition() {
+  return [() => false, () => {}];
+}
+function createOptimistic(value) {
+  return [() => value, v => v];
 }
 
 function isWrappable(obj) {
@@ -794,6 +420,12 @@ function createStore(state) {
   }
   return [state, setStore];
 }
+function createProjection(fn, initialValue = {}) {
+  const [state] = createStore(initialValue);
+  fn(state);
+  return state;
+}
+const createOptimisticStore = createStore;
 function reconcile(value) {
   return state => {
     if (!isWrappable(state) || !isWrappable(value)) return value;
@@ -809,62 +441,71 @@ function reconcile(value) {
     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 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 clone;
+}
+function deep(store) {
+  return store;
+}
 
-export {
-  $DEVCOMP,
-  $PROXY,
-  $TRACK,
-  DEV,
-  ErrorBoundary,
-  For,
-  Index,
-  Match,
-  Show,
-  Suspense,
-  SuspenseList,
-  Switch,
-  batch,
-  catchError,
-  children,
-  createComponent,
-  createContext,
-  createDeferred,
-  createEffect,
-  createMemo,
-  createReaction,
-  createRenderEffect,
-  createResource,
-  createRoot,
-  createSelector,
-  createSignal,
-  createStore,
-  createUniqueId,
-  enableExternalSource,
-  enableHydration,
-  enableScheduling,
-  equalFn,
-  from,
-  getListener,
-  getOwner,
-  indexArray,
-  isWrappable,
-  lazy,
-  mapArray,
-  mergeProps,
-  observable,
-  on,
-  onCleanup,
-  onError,
-  onMount,
-  reconcile,
-  requestCallback,
-  resetErrorBoundaries,
-  runWithOwner,
-  sharedConfig,
-  splitProps,
-  startTransition,
-  untrack,
-  unwrap,
-  useContext,
-  useTransition
-};
+function tryCatch(fn) {
+  try {
+    const v = fn();
+    if (v instanceof Promise) {
+      return v.then(v => [undefined, v], e => {
+        if (e instanceof NotReadyError) throw e;
+        return [e];
+      });
+    }
+    return [undefined, v];
+  } catch (e) {
+    if (e instanceof NotReadyError) throw e;
+    return [e];
+  }
+}
+function reducer(source, reducerFn) {
+  return [source[0], action => {
+    source[1](s => reducerFn(s, action));
+  }];
+}
+
+const $DEVCOMP = Symbol("solid-dev-component");
+const DEV = undefined;
+
+export { $DEVCOMP, DEV, ErrorBoundary, For, Match, Repeat, Show, Suspense, Switch, children, createAsync, createComponent, createContext, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createSignal, createStore, createTrackedEffect, createUniqueId, deep, enableHydration, flush, from, getObserver, isPending, latest, lazy, mapArray, merge, observable, omit, onMount, reconcile, reducer, repeat, resolve, sharedConfig, ssrHandleError, ssrRunInScope, transition, tryCatch, untrack, unwrap, useContext, useTransition };