solid-js 2.0.0-experimental.13 → 2.0.0-experimental.15

package/dist/server.cjs

@@ -1,2 +1,829 @@
 'use strict';
 
+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);
+  }
+};
+
+let Observer = null;
+function runWithObserver(comp, fn) {
+  const prev = Observer;
+  Observer = comp;
+  try {
+    return fn();
+  } finally {
+    Observer = prev;
+  }
+}
+function getObserver() {
+  return Observer;
+}
+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;
+  }];
+}
+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
+  };
+  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 () => {
+    if (!comp.computed) {
+      update();
+    }
+    if (comp.error) {
+      throw comp.error;
+    }
+    return comp.value;
+  };
+}
+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;
+  }
+  comp.value = result;
+}
+function createEffect(compute, effect, value, options) {
+  const o = signals.getOwner();
+  if (o?.id != null) signals.getNextChildId(o);
+}
+function createRenderEffect(compute, effectFn, value, options) {
+  const owner = signals.createOwner();
+  try {
+    const result = signals.runWithOwner(owner, () => runWithObserver({
+      owner,
+      value: value,
+      compute: compute,
+      error: undefined,
+      computed: true,
+      disposed: false
+    }, () => compute(value)));
+    effectFn(result, value);
+  } catch (err) {
+  }
+}
+function createTrackedEffect(compute, options) {
+  const o = signals.getOwner();
+  if (o?.id != null) signals.getNextChildId(o);
+}
+function createReaction(effectFn, options) {
+  return tracking => {
+    tracking();
+  };
+}
+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 [proxy, frozen => {
+    if (frozen) readTarget = frozen;
+    pending = false;
+  }];
+}
+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
+              };
+            });
+          }
+        })
+      };
+      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 deep(store) {
+  return store;
+}
+function mapArray(list, mapFn, options = {}) {
+  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
+        });
+        s.push(signals.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;
+}
+const ErrorContext = {
+  id: Symbol("ErrorContext"),
+  defaultValue: null
+};
+function createErrorBoundary(fn, fallback) {
+  const ctx = sharedConfig.context;
+  const owner = signals.createOwner();
+  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 () => result;
+  });
+}
+function createLoadBoundary(fn, fallback) {
+  try {
+    const result = fn();
+    return () => result;
+  } catch (err) {
+    if (err instanceof signals.NotReadyError) {
+      return () => fallback();
+    }
+    throw err;
+  }
+}
+function untrack(fn) {
+  return fn();
+}
+function flush() {}
+function resolve(fn) {
+  throw new Error("resolve is not implemented on the server");
+}
+function isPending(fn, fallback) {
+  try {
+    fn();
+    return false;
+  } catch (err) {
+    if (err instanceof signals.NotReadyError && arguments.length > 1) {
+      return fallback;
+    }
+    throw err;
+  }
+}
+function pending(fn) {
+  return fn();
+}
+function isRefreshing() {
+  return false;
+}
+function refresh(fn) {
+  return fn();
+}
+function action(fn) {
+  return fn;
+}
+function onSettled(callback) {
+  const o = signals.getOwner();
+  if (o?.id != null) signals.getNextChildId(o);
+}
+
+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);
+    });
+  }
+  provider.id = id;
+  provider.defaultValue = defaultValue;
+  return provider;
+}
+function useContext(context) {
+  return signals.getContext(context);
+}
+function children(fn) {
+  const childrenMemo = createMemo(fn);
+  const memo = createMemo(() => signals.flatten(childrenMemo()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+function ssrRunInScope(fn) {
+  if (Array.isArray(fn)) {
+    const o = signals.createOwner();
+    return fn.map(f => signals.runWithOwner.bind(null, o, f));
+  }
+  return signals.runWithOwner.bind(null, signals.createOwner(), fn);
+}
+
+function enableHydration() {}
+function createComponent(Comp, props) {
+  return Comp(props || {});
+}
+function lazy(fn, moduleUrl) {
+  let p;
+  let load = () => {
+    if (!p) {
+      p = fn();
+      p.then(mod => {
+        p.v = mod.default;
+      });
+    }
+    return p;
+  };
+  const wrap = props => {
+    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 (ctx?.async) {
+      ctx.block(p.then(() => {
+        p.s = "success";
+      }));
+    }
+    return createMemo(() => {
+      if (!p.v) throw new signals.NotReadyError(p);
+      return p.v(props);
+    });
+  };
+  wrap.preload = load;
+  return wrap;
+}
+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 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 when = props.when;
+  if (when) {
+    const child = props.children;
+    if (typeof child === "function" && child.length > 0) {
+      return child(() => when);
+    }
+    return child;
+  }
+  return props.fallback;
+}
+function Switch(props) {
+  const chs = children(() => props.children);
+  const o = signals.getOwner();
+  if (o) 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 Match(props) {
+  return props;
+}
+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;
+  }
+  throw err;
+}
+function Loading(props) {
+  const ctx = sharedConfig.context;
+  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);
+      }
+    });
+    ctx._currentBoundaryId = prevBoundary;
+    ctx.serialize = origSerialize;
+    return result;
+  }
+  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;
+  }
+  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, "createRoot", {
+  enumerable: true,
+  get: function () { return signals.createRoot; }
+});
+Object.defineProperty(exports, "flatten", {
+  enumerable: true,
+  get: function () { return signals.flatten; }
+});
+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; }
+});
+exports.$DEVCOMP = $DEVCOMP;
+exports.DEV = DEV;
+exports.Errored = Errored;
+exports.For = For;
+exports.Loading = Loading;
+exports.Match = Match;
+exports.Repeat = Repeat;
+exports.Show = Show;
+exports.Switch = Switch;
+exports.action = action;
+exports.children = children;
+exports.createComponent = createComponent;
+exports.createContext = createContext;
+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.createSignal = createSignal;
+exports.createStore = createStore;
+exports.createTrackedEffect = createTrackedEffect;
+exports.createUniqueId = createUniqueId;
+exports.deep = deep;
+exports.enableHydration = enableHydration;
+exports.flush = flush;
+exports.getObserver = getObserver;
+exports.isPending = isPending;
+exports.isRefreshing = isRefreshing;
+exports.lazy = lazy;
+exports.mapArray = mapArray;
+exports.onSettled = onSettled;
+exports.pending = pending;
+exports.reconcile = reconcile;
+exports.refresh = refresh;
+exports.repeat = repeat;
+exports.resolve = resolve;
+exports.sharedConfig = sharedConfig;
+exports.ssrHandleError = ssrHandleError;
+exports.ssrRunInScope = ssrRunInScope;
+exports.untrack = untrack;
+exports.useContext = useContext;