solid-js 1.9.3 → 2.0.0-experimental.0

package/dist/dev.cjs

@@ -1,602 +1,29 @@
 'use strict';
 
-let taskIdCounter = 1,
-  isCallbackScheduled = false,
-  isPerformingWork = false,
-  taskQueue = [],
-  currentTask = null,
-  shouldYieldToHost = null,
-  yieldInterval = 5,
-  deadline = 0,
-  maxYieldInterval = 300,
-  scheduleCallback = null,
-  scheduledCallback = null;
-const maxSigned31BitInt = 1073741823;
-function setupScheduler() {
-  const channel = new MessageChannel(),
-    port = channel.port2;
-  scheduleCallback = () => port.postMessage(null);
-  channel.port1.onmessage = () => {
-    if (scheduledCallback !== null) {
-      const currentTime = performance.now();
-      deadline = currentTime + yieldInterval;
-      const hasTimeRemaining = true;
-      try {
-        const hasMoreWork = scheduledCallback(hasTimeRemaining, currentTime);
-        if (!hasMoreWork) {
-          scheduledCallback = null;
-        } else port.postMessage(null);
-      } catch (error) {
-        port.postMessage(null);
-        throw error;
-      }
-    }
-  };
-  if (navigator && navigator.scheduling && navigator.scheduling.isInputPending) {
-    const scheduling = navigator.scheduling;
-    shouldYieldToHost = () => {
-      const currentTime = performance.now();
-      if (currentTime >= deadline) {
-        if (scheduling.isInputPending()) {
-          return true;
-        }
-        return currentTime >= maxYieldInterval;
-      } else {
-        return false;
-      }
-    };
-  } else {
-    shouldYieldToHost = () => performance.now() >= deadline;
-  }
-}
-function enqueue(taskQueue, task) {
-  function findIndex() {
-    let m = 0;
-    let n = taskQueue.length - 1;
-    while (m <= n) {
-      const k = n + m >> 1;
-      const cmp = task.expirationTime - taskQueue[k].expirationTime;
-      if (cmp > 0) m = k + 1;else if (cmp < 0) n = k - 1;else return k;
-    }
-    return m;
-  }
-  taskQueue.splice(findIndex(), 0, task);
-}
-function requestCallback(fn, options) {
-  if (!scheduleCallback) setupScheduler();
-  let startTime = performance.now(),
-    timeout = maxSigned31BitInt;
-  if (options && options.timeout) timeout = options.timeout;
-  const newTask = {
-    id: taskIdCounter++,
-    fn,
-    startTime,
-    expirationTime: startTime + timeout
-  };
-  enqueue(taskQueue, newTask);
-  if (!isCallbackScheduled && !isPerformingWork) {
-    isCallbackScheduled = true;
-    scheduledCallback = flushWork;
-    scheduleCallback();
-  }
-  return newTask;
-}
-function cancelCallback(task) {
-  task.fn = null;
-}
-function flushWork(hasTimeRemaining, initialTime) {
-  isCallbackScheduled = false;
-  isPerformingWork = true;
-  try {
-    return workLoop(hasTimeRemaining, initialTime);
-  } finally {
-    currentTask = null;
-    isPerformingWork = false;
-  }
-}
-function workLoop(hasTimeRemaining, initialTime) {
-  let currentTime = initialTime;
-  currentTask = taskQueue[0] || null;
-  while (currentTask !== null) {
-    if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
-      break;
-    }
-    const callback = currentTask.fn;
-    if (callback !== null) {
-      currentTask.fn = null;
-      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
-      callback(didUserCallbackTimeout);
-      currentTime = performance.now();
-      if (currentTask === taskQueue[0]) {
-        taskQueue.shift();
-      }
-    } else taskQueue.shift();
-    currentTask = taskQueue[0] || null;
-  }
-  return currentTask !== null;
-}
-
-const sharedConfig = {
-  context: undefined,
-  registry: undefined,
-  effects: undefined,
-  done: false,
-  getContextId() {
-    return getContextId(this.context.count);
-  },
-  getNextContextId() {
-    return getContextId(this.context.count++);
-  }
-};
-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,
-    id: sharedConfig.getNextContextId(),
-    count: 0
-  };
-}
+var signals = require('@solidjs/signals');
 
-const equalFn = (a, b) => a === b;
-const $PROXY = Symbol("solid-proxy");
-const SUPPORTS_PROXY = typeof Proxy === "function";
-const $TRACK = Symbol("solid-track");
-const $DEVCOMP = Symbol("solid-dev-component");
-const signalOptions = {
-  equals: equalFn
-};
-let ERROR = null;
-let runEffects = runQueue;
-const STALE = 1;
-const PENDING = 2;
-const UNOWNED = {
-  owned: null,
-  cleanups: null,
-  context: null,
-  owner: null
-};
-const NO_INIT = {};
-var Owner = null;
-let Transition = null;
-let Scheduler = null;
-let ExternalSourceConfig = null;
-let Listener = null;
-let Updates = null;
-let Effects = null;
-let ExecCount = 0;
-const DevHooks = {
-  afterUpdate: null,
-  afterCreateOwner: null,
-  afterCreateSignal: null
-};
-function createRoot(fn, detachedOwner) {
-  const listener = Listener,
-    owner = Owner,
-    unowned = fn.length === 0,
-    current = detachedOwner === undefined ? owner : detachedOwner,
-    root = unowned ? {
-      owned: null,
-      cleanups: null,
-      context: null,
-      owner: null
-    }  : {
-      owned: null,
-      cleanups: null,
-      context: current ? current.context : null,
-      owner: current
-    },
-    updateFn = unowned ? () => fn(() => {
-      throw new Error("Dispose method must be an explicit argument to createRoot function");
-    })  : () => fn(() => untrack(() => cleanNode(root)));
-  DevHooks.afterCreateOwner && DevHooks.afterCreateOwner(root);
-  Owner = root;
-  Listener = null;
-  try {
-    return runUpdates(updateFn, true);
-  } finally {
-    Listener = listener;
-    Owner = owner;
-  }
-}
-function createSignal(value, options) {
-  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
-  const s = {
-    value,
-    observers: null,
-    observerSlots: null,
-    comparator: options.equals || undefined
-  };
-  {
-    if (options.name) s.name = options.name;
-    if (DevHooks.afterCreateSignal) DevHooks.afterCreateSignal(s);
-    if (!options.internal) registerGraph(s);
-  }
-  const setter = value => {
-    if (typeof value === "function") {
-      if (Transition && Transition.running && Transition.sources.has(s)) value = value(s.tValue);else value = value(s.value);
-    }
-    return writeSignal(s, value);
-  };
-  return [readSignal.bind(s), setter];
-}
-function createComputed(fn, value, options) {
-  const c = createComputation(fn, value, true, STALE, options );
-  if (Scheduler && Transition && Transition.running) Updates.push(c);else updateComputation(c);
-}
-function createRenderEffect(fn, value, options) {
-  const c = createComputation(fn, value, false, STALE, options );
-  if (Scheduler && Transition && Transition.running) Updates.push(c);else updateComputation(c);
-}
-function createEffect(fn, value, options) {
-  runEffects = runUserEffects;
-  const c = createComputation(fn, value, false, STALE, options ),
-    s = SuspenseContext && useContext(SuspenseContext);
-  if (s) c.suspense = s;
-  if (!options || !options.render) c.user = true;
-  Effects ? Effects.push(c) : updateComputation(c);
-}
-function createReaction(onInvalidate, options) {
-  let fn;
-  const c = createComputation(() => {
-      fn ? fn() : untrack(onInvalidate);
-      fn = undefined;
-    }, undefined, false, 0, options ),
-    s = SuspenseContext && useContext(SuspenseContext);
-  if (s) c.suspense = s;
-  c.user = true;
-  return tracking => {
-    fn = tracking;
-    updateComputation(c);
-  };
-}
-function createMemo(fn, value, options) {
-  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
-  const c = createComputation(fn, value, true, 0, options );
-  c.observers = null;
-  c.observerSlots = null;
-  c.comparator = options.equals || undefined;
-  if (Scheduler && Transition && Transition.running) {
-    c.tState = STALE;
-    Updates.push(c);
-  } else updateComputation(c);
-  return readSignal.bind(c);
-}
-function isPromise(v) {
-  return v && typeof v === "object" && "then" in v;
-}
-function createResource(pSource, pFetcher, pOptions) {
-  let source;
-  let fetcher;
-  let options;
-  if (arguments.length === 2 && typeof pFetcher === "object" || arguments.length === 1) {
-    source = true;
-    fetcher = pSource;
-    options = pFetcher || {};
-  } else {
-    source = pSource;
-    fetcher = pFetcher;
-    options = pOptions || {};
-  }
-  let pr = null,
-    initP = NO_INIT,
-    id = null,
-    loadedUnderTransition = false,
-    scheduled = false,
-    resolved = "initialValue" in options,
-    dynamic = typeof source === "function" && createMemo(source);
-  const contexts = new Set(),
-    [value, setValue] = (options.storage || createSignal)(options.initialValue),
-    [error, setError] = createSignal(undefined),
-    [track, trigger] = createSignal(undefined, {
-      equals: false
-    }),
-    [state, setState] = createSignal(resolved ? "ready" : "unresolved");
-  if (sharedConfig.context) {
-    id = sharedConfig.getNextContextId();
-    if (options.ssrLoadFrom === "initial") initP = options.initialValue;else if (sharedConfig.load && sharedConfig.has(id)) initP = sharedConfig.load(id);
-  }
-  function loadEnd(p, v, error, key) {
-    if (pr === p) {
-      pr = null;
-      key !== undefined && (resolved = true);
-      if ((p === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, {
-        value: v
-      }));
-      initP = NO_INIT;
-      if (Transition && p && loadedUnderTransition) {
-        Transition.promises.delete(p);
-        loadedUnderTransition = false;
-        runUpdates(() => {
-          Transition.running = true;
-          completeLoad(v, error);
-        }, false);
-      } else completeLoad(v, error);
-    }
-    return v;
-  }
-  function completeLoad(v, err) {
-    runUpdates(() => {
-      if (err === undefined) setValue(() => v);
-      setState(err !== undefined ? "errored" : resolved ? "ready" : "unresolved");
-      setError(err);
-      for (const c of contexts.keys()) c.decrement();
-      contexts.clear();
-    }, false);
-  }
-  function read() {
-    const c = SuspenseContext && useContext(SuspenseContext),
-      v = value(),
-      err = error();
-    if (err !== undefined && !pr) throw err;
-    if (Listener && !Listener.user && c) {
-      createComputed(() => {
-        track();
-        if (pr) {
-          if (c.resolved && Transition && loadedUnderTransition) Transition.promises.add(pr);else if (!contexts.has(c)) {
-            c.increment();
-            contexts.add(c);
-          }
-        }
-      });
-    }
-    return v;
-  }
-  function load(refetching = true) {
-    if (refetching !== false && scheduled) return;
-    scheduled = false;
-    const lookup = dynamic ? dynamic() : source;
-    loadedUnderTransition = Transition && Transition.running;
-    if (lookup == null || lookup === false) {
-      loadEnd(pr, untrack(value));
-      return;
-    }
-    if (Transition && pr) Transition.promises.delete(pr);
-    const p = initP !== NO_INIT ? initP : untrack(() => fetcher(lookup, {
-      value: value(),
-      refetching
-    }));
-    if (!isPromise(p)) {
-      loadEnd(pr, p, undefined, lookup);
-      return p;
-    }
-    pr = p;
-    if ("value" in p) {
-      if (p.status === "success") loadEnd(pr, p.value, undefined, lookup);else loadEnd(pr, undefined, castError(p.value), lookup);
-      return p;
-    }
-    scheduled = true;
-    queueMicrotask(() => scheduled = false);
-    runUpdates(() => {
-      setState(resolved ? "refreshing" : "pending");
-      trigger();
-    }, false);
-    return p.then(v => loadEnd(p, v, undefined, lookup), e => loadEnd(p, undefined, castError(e), lookup));
-  }
-  Object.defineProperties(read, {
-    state: {
-      get: () => state()
-    },
-    error: {
-      get: () => error()
-    },
-    loading: {
-      get() {
-        const s = state();
-        return s === "pending" || s === "refreshing";
-      }
-    },
-    latest: {
-      get() {
-        if (!resolved) return read();
-        const err = error();
-        if (err && !pr) throw err;
-        return value();
-      }
-    }
-  });
-  if (dynamic) createComputed(() => load(false));else load(false);
-  return [read, {
-    refetch: load,
-    mutate: setValue
-  }];
-}
-function createDeferred(source, options) {
-  let t,
-    timeout = options ? options.timeoutMs : undefined;
-  const node = createComputation(() => {
-    if (!t || !t.fn) t = requestCallback(() => setDeferred(() => node.value), timeout !== undefined ? {
-      timeout
-    } : undefined);
-    return source();
-  }, undefined, true);
-  const [deferred, setDeferred] = createSignal(Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, options);
-  updateComputation(node);
-  setDeferred(() => Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value);
-  return deferred;
-}
-function createSelector(source, fn = equalFn, options) {
-  const subs = new Map();
-  const node = createComputation(p => {
-    const v = source();
-    for (const [key, val] of subs.entries()) if (fn(key, v) !== fn(key, p)) {
-      for (const c of val.values()) {
-        c.state = STALE;
-        if (c.pure) Updates.push(c);else Effects.push(c);
-      }
-    }
-    return v;
-  }, undefined, true, STALE, options );
-  updateComputation(node);
-  return key => {
-    const listener = Listener;
-    if (listener) {
-      let l;
-      if (l = subs.get(key)) l.add(listener);else subs.set(key, l = new Set([listener]));
-      onCleanup(() => {
-        l.delete(listener);
-        !l.size && subs.delete(key);
-      });
-    }
-    return fn(key, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value);
-  };
-}
-function batch(fn) {
-  return runUpdates(fn, false);
-}
-function untrack(fn) {
-  if (!ExternalSourceConfig && Listener === null) return fn();
-  const listener = Listener;
-  Listener = null;
-  try {
-    if (ExternalSourceConfig) return ExternalSourceConfig.untrack(fn);
-    return fn();
-  } finally {
-    Listener = listener;
-  }
-}
-function on(deps, fn, options) {
-  const isArray = Array.isArray(deps);
-  let prevInput;
-  let defer = options && options.defer;
-  return prevValue => {
-    let input;
-    if (isArray) {
-      input = Array(deps.length);
-      for (let i = 0; i < deps.length; i++) input[i] = deps[i]();
-    } else input = deps();
-    if (defer) {
-      defer = false;
-      return prevValue;
-    }
-    const result = untrack(() => fn(input, prevInput, prevValue));
-    prevInput = input;
-    return result;
-  };
-}
+const $DEVCOMP = Symbol("COMPONENT_DEV" );
 function onMount(fn) {
-  createEffect(() => untrack(fn));
-}
-function onCleanup(fn) {
-  if (Owner === null) console.warn("cleanups created outside a `createRoot` or `render` will never be run");else if (Owner.cleanups === null) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
-  return fn;
-}
-function catchError(fn, handler) {
-  ERROR || (ERROR = Symbol("error"));
-  Owner = createComputation(undefined, undefined, true);
-  Owner.context = {
-    ...Owner.context,
-    [ERROR]: [handler]
-  };
-  if (Transition && Transition.running) Transition.sources.add(Owner);
-  try {
-    return fn();
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = Owner.owner;
-  }
-}
-function getListener() {
-  return Listener;
-}
-function getOwner() {
-  return Owner;
-}
-function runWithOwner(o, fn) {
-  const prev = Owner;
-  const prevListener = Listener;
-  Owner = o;
-  Listener = null;
-  try {
-    return runUpdates(fn, true);
-  } catch (err) {
-    handleError(err);
-  } finally {
-    Owner = prev;
-    Listener = prevListener;
-  }
-}
-function enableScheduling(scheduler = requestCallback) {
-  Scheduler = scheduler;
-}
-function startTransition(fn) {
-  if (Transition && Transition.running) {
-    fn();
-    return Transition.done;
-  }
-  const l = Listener;
-  const o = Owner;
-  return Promise.resolve().then(() => {
-    Listener = l;
-    Owner = o;
-    let t;
-    if (Scheduler || SuspenseContext) {
-      t = Transition || (Transition = {
-        sources: new Set(),
-        effects: [],
-        promises: new Set(),
-        disposed: new Set(),
-        queue: new Set(),
-        running: true
-      });
-      t.done || (t.done = new Promise(res => t.resolve = res));
-      t.running = true;
-    }
-    runUpdates(fn, false);
-    Listener = Owner = null;
-    return t ? t.done : undefined;
-  });
-}
-const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
-function useTransition() {
-  return [transPending, startTransition];
-}
-function resumeEffects(e) {
-  Effects.push.apply(Effects, e);
-  e.length = 0;
-}
-function devComponent(Comp, props) {
-  const c = createComputation(() => untrack(() => {
-    Object.assign(Comp, {
-      [$DEVCOMP]: true
-    });
-    return Comp(props);
-  }), undefined, true, 0);
-  c.props = props;
-  c.observers = null;
-  c.observerSlots = null;
-  c.name = Comp.name;
-  c.component = Comp;
-  updateComputation(c);
-  return c.tValue !== undefined ? c.tValue : c.value;
-}
-function registerGraph(value) {
-  if (!Owner) return;
-  if (Owner.sourceMap) Owner.sourceMap.push(value);else Owner.sourceMap = [value];
-  value.graph = Owner;
+  signals.createEffect(() => null, fn);
 }
 function createContext(defaultValue, options) {
-  const id = Symbol("context");
-  return {
-    id,
-    Provider: createProvider(id, options),
-    defaultValue
-  };
+  const id = Symbol(options && options.name || "");
+  function provider(props) {
+    return signals.createMemo(() => {
+      signals.setContext(provider, signals.untrack(() => props.value));
+      return children(() => props.children);
+    });
+  }
+  provider.id = id;
+  provider.defaultValue = defaultValue;
+  return provider;
 }
 function useContext(context) {
-  let value;
-  return Owner && Owner.context && (value = Owner.context[context.id]) !== undefined ? value : context.defaultValue;
+  return signals.getContext(context);
 }
 function children(fn) {
-  const children = createMemo(fn);
-  const memo = createMemo(() => resolveChildren(children()), undefined, {
+  const children = signals.createMemo(fn);
+  const memo = signals.createMemo(() => signals.flatten(children()), undefined, {
     name: "children"
   }) ;
   memo.toArray = () => {
@@ -605,465 +32,25 @@ function children(fn) {
   };
   return memo;
 }
-let SuspenseContext;
-function getSuspenseContext() {
-  return SuspenseContext || (SuspenseContext = createContext());
-}
-function enableExternalSource(factory, untrack = fn => fn()) {
-  if (ExternalSourceConfig) {
-    const {
-      factory: oldFactory,
-      untrack: oldUntrack
-    } = ExternalSourceConfig;
-    ExternalSourceConfig = {
-      factory: (fn, trigger) => {
-        const oldSource = oldFactory(fn, trigger);
-        const source = factory(x => oldSource.track(x), trigger);
-        return {
-          track: x => source.track(x),
-          dispose() {
-            source.dispose();
-            oldSource.dispose();
-          }
-        };
-      },
-      untrack: fn => oldUntrack(() => untrack(fn))
-    };
-  } else {
-    ExternalSourceConfig = {
-      factory,
-      untrack
-    };
-  }
-}
-function readSignal() {
-  const runningTransition = Transition && Transition.running;
-  if (this.sources && (runningTransition ? this.tState : this.state)) {
-    if ((runningTransition ? this.tState : this.state) === STALE) updateComputation(this);else {
-      const updates = Updates;
-      Updates = null;
-      runUpdates(() => lookUpstream(this), false);
-      Updates = updates;
-    }
-  }
-  if (Listener) {
-    const sSlot = this.observers ? this.observers.length : 0;
-    if (!Listener.sources) {
-      Listener.sources = [this];
-      Listener.sourceSlots = [sSlot];
-    } else {
-      Listener.sources.push(this);
-      Listener.sourceSlots.push(sSlot);
-    }
-    if (!this.observers) {
-      this.observers = [Listener];
-      this.observerSlots = [Listener.sources.length - 1];
-    } else {
-      this.observers.push(Listener);
-      this.observerSlots.push(Listener.sources.length - 1);
-    }
-  }
-  if (runningTransition && Transition.sources.has(this)) return this.tValue;
-  return this.value;
-}
-function writeSignal(node, value, isComp) {
-  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
-  if (!node.comparator || !node.comparator(current, value)) {
-    if (Transition) {
-      const TransitionRunning = Transition.running;
-      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
-        Transition.sources.add(node);
-        node.tValue = value;
-      }
-      if (!TransitionRunning) node.value = value;
-    } else node.value = value;
-    if (node.observers && node.observers.length) {
-      runUpdates(() => {
-        for (let i = 0; i < node.observers.length; i += 1) {
-          const o = node.observers[i];
-          const TransitionRunning = Transition && Transition.running;
-          if (TransitionRunning && Transition.disposed.has(o)) continue;
-          if (TransitionRunning ? !o.tState : !o.state) {
-            if (o.pure) Updates.push(o);else Effects.push(o);
-            if (o.observers) markDownstream(o);
-          }
-          if (!TransitionRunning) o.state = STALE;else o.tState = STALE;
-        }
-        if (Updates.length > 10e5) {
-          Updates = [];
-          if (true) throw new Error("Potential Infinite Loop Detected.");
-          throw new Error();
-        }
-      }, false);
-    }
-  }
-  return value;
-}
-function updateComputation(node) {
-  if (!node.fn) return;
-  cleanNode(node);
-  const time = ExecCount;
-  runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
-  if (Transition && !Transition.running && Transition.sources.has(node)) {
-    queueMicrotask(() => {
-      runUpdates(() => {
-        Transition && (Transition.running = true);
-        Listener = Owner = node;
-        runComputation(node, node.tValue, time);
-        Listener = Owner = null;
-      }, false);
-    });
-  }
-}
-function runComputation(node, value, time) {
-  let nextValue;
-  const owner = Owner,
-    listener = Listener;
-  Listener = Owner = node;
-  try {
-    nextValue = node.fn(value);
-  } catch (err) {
-    if (node.pure) {
-      if (Transition && Transition.running) {
-        node.tState = STALE;
-        node.tOwned && node.tOwned.forEach(cleanNode);
-        node.tOwned = undefined;
-      } else {
-        node.state = STALE;
-        node.owned && node.owned.forEach(cleanNode);
-        node.owned = null;
-      }
-    }
-    node.updatedAt = time + 1;
-    return handleError(err);
-  } finally {
-    Listener = listener;
-    Owner = owner;
-  }
-  if (!node.updatedAt || node.updatedAt <= time) {
-    if (node.updatedAt != null && "observers" in node) {
-      writeSignal(node, nextValue, true);
-    } else if (Transition && Transition.running && node.pure) {
-      Transition.sources.add(node);
-      node.tValue = nextValue;
-    } else node.value = nextValue;
-    node.updatedAt = time;
-  }
-}
-function createComputation(fn, init, pure, state = STALE, options) {
-  const c = {
-    fn,
-    state: state,
-    updatedAt: null,
-    owned: null,
-    sources: null,
-    sourceSlots: null,
-    cleanups: null,
-    value: init,
-    owner: Owner,
-    context: Owner ? Owner.context : null,
-    pure
-  };
-  if (Transition && Transition.running) {
-    c.state = 0;
-    c.tState = state;
-  }
-  if (Owner === null) console.warn("computations created outside a `createRoot` or `render` will never be disposed");else if (Owner !== UNOWNED) {
-    if (Transition && Transition.running && Owner.pure) {
-      if (!Owner.tOwned) Owner.tOwned = [c];else Owner.tOwned.push(c);
-    } else {
-      if (!Owner.owned) Owner.owned = [c];else Owner.owned.push(c);
-    }
-  }
-  if (options && options.name) c.name = options.name;
-  if (ExternalSourceConfig && c.fn) {
-    const [track, trigger] = createSignal(undefined, {
-      equals: false
-    });
-    const ordinary = ExternalSourceConfig.factory(c.fn, trigger);
-    onCleanup(() => ordinary.dispose());
-    const triggerInTransition = () => startTransition(trigger).then(() => inTransition.dispose());
-    const inTransition = ExternalSourceConfig.factory(c.fn, triggerInTransition);
-    c.fn = x => {
-      track();
-      return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
-    };
-  }
-  DevHooks.afterCreateOwner && DevHooks.afterCreateOwner(c);
-  return c;
-}
-function runTop(node) {
-  const runningTransition = Transition && Transition.running;
-  if ((runningTransition ? node.tState : node.state) === 0) return;
-  if ((runningTransition ? node.tState : node.state) === PENDING) return lookUpstream(node);
-  if (node.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
-  const ancestors = [node];
-  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
-    if (runningTransition && Transition.disposed.has(node)) return;
-    if (runningTransition ? node.tState : node.state) ancestors.push(node);
-  }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    node = ancestors[i];
-    if (runningTransition) {
-      let top = node,
-        prev = ancestors[i + 1];
-      while ((top = top.owner) && top !== prev) {
-        if (Transition.disposed.has(top)) return;
-      }
-    }
-    if ((runningTransition ? node.tState : node.state) === STALE) {
-      updateComputation(node);
-    } else if ((runningTransition ? node.tState : node.state) === PENDING) {
-      const updates = Updates;
-      Updates = null;
-      runUpdates(() => lookUpstream(node, ancestors[0]), false);
-      Updates = updates;
-    }
-  }
-}
-function runUpdates(fn, init) {
-  if (Updates) return fn();
-  let wait = false;
-  if (!init) Updates = [];
-  if (Effects) wait = true;else Effects = [];
-  ExecCount++;
-  try {
-    const res = fn();
-    completeUpdates(wait);
-    return res;
-  } catch (err) {
-    if (!wait) Effects = null;
-    Updates = null;
-    handleError(err);
-  }
-}
-function completeUpdates(wait) {
-  if (Updates) {
-    if (Scheduler && Transition && Transition.running) scheduleQueue(Updates);else runQueue(Updates);
-    Updates = null;
-  }
-  if (wait) return;
-  let res;
-  if (Transition) {
-    if (!Transition.promises.size && !Transition.queue.size) {
-      const sources = Transition.sources;
-      const disposed = Transition.disposed;
-      Effects.push.apply(Effects, Transition.effects);
-      res = Transition.resolve;
-      for (const e of Effects) {
-        "tState" in e && (e.state = e.tState);
-        delete e.tState;
-      }
-      Transition = null;
-      runUpdates(() => {
-        for (const d of disposed) cleanNode(d);
-        for (const v of sources) {
-          v.value = v.tValue;
-          if (v.owned) {
-            for (let i = 0, len = v.owned.length; i < len; i++) cleanNode(v.owned[i]);
-          }
-          if (v.tOwned) v.owned = v.tOwned;
-          delete v.tValue;
-          delete v.tOwned;
-          v.tState = 0;
-        }
-        setTransPending(false);
-      }, false);
-    } else if (Transition.running) {
-      Transition.running = false;
-      Transition.effects.push.apply(Transition.effects, Effects);
-      Effects = null;
-      setTransPending(true);
-      return;
-    }
-  }
-  const e = Effects;
-  Effects = null;
-  if (e.length) runUpdates(() => runEffects(e), false);else DevHooks.afterUpdate && DevHooks.afterUpdate();
-  if (res) res();
-}
-function runQueue(queue) {
-  for (let i = 0; i < queue.length; i++) runTop(queue[i]);
-}
-function scheduleQueue(queue) {
-  for (let i = 0; i < queue.length; i++) {
-    const item = queue[i];
-    const tasks = Transition.queue;
-    if (!tasks.has(item)) {
-      tasks.add(item);
-      Scheduler(() => {
-        tasks.delete(item);
-        runUpdates(() => {
-          Transition.running = true;
-          runTop(item);
-        }, false);
-        Transition && (Transition.running = false);
+function devComponent(Comp, props) {
+  return signals.createRoot(() => {
+    const owner = signals.getOwner();
+    owner._props = props;
+    owner._name = Comp.name;
+    owner._component = Comp;
+    return signals.untrack(() => {
+      Object.assign(Comp, {
+        [$DEVCOMP]: true
       });
-    }
-  }
-}
-function runUserEffects(queue) {
-  let i,
-    userLength = 0;
-  for (i = 0; i < queue.length; i++) {
-    const e = queue[i];
-    if (!e.user) runTop(e);else queue[userLength++] = e;
-  }
-  if (sharedConfig.context) {
-    if (sharedConfig.count) {
-      sharedConfig.effects || (sharedConfig.effects = []);
-      sharedConfig.effects.push(...queue.slice(0, userLength));
-      return;
-    }
-    setHydrateContext();
-  }
-  if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
-    queue = [...sharedConfig.effects, ...queue];
-    userLength += sharedConfig.effects.length;
-    delete sharedConfig.effects;
-  }
-  for (i = 0; i < userLength; i++) runTop(queue[i]);
-}
-function lookUpstream(node, ignore) {
-  const runningTransition = Transition && Transition.running;
-  if (runningTransition) node.tState = 0;else node.state = 0;
-  for (let i = 0; i < node.sources.length; i += 1) {
-    const source = node.sources[i];
-    if (source.sources) {
-      const state = runningTransition ? source.tState : source.state;
-      if (state === STALE) {
-        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount)) runTop(source);
-      } else if (state === PENDING) lookUpstream(source, ignore);
-    }
-  }
-}
-function markDownstream(node) {
-  const runningTransition = Transition && Transition.running;
-  for (let i = 0; i < node.observers.length; i += 1) {
-    const o = node.observers[i];
-    if (runningTransition ? !o.tState : !o.state) {
-      if (runningTransition) o.tState = PENDING;else o.state = PENDING;
-      if (o.pure) Updates.push(o);else Effects.push(o);
-      o.observers && markDownstream(o);
-    }
-  }
-}
-function cleanNode(node) {
-  let i;
-  if (node.sources) {
-    while (node.sources.length) {
-      const source = node.sources.pop(),
-        index = node.sourceSlots.pop(),
-        obs = source.observers;
-      if (obs && obs.length) {
-        const n = obs.pop(),
-          s = source.observerSlots.pop();
-        if (index < obs.length) {
-          n.sourceSlots[s] = index;
-          obs[index] = n;
-          source.observerSlots[index] = s;
-        }
-      }
-    }
-  }
-  if (node.tOwned) {
-    for (i = node.tOwned.length - 1; i >= 0; i--) cleanNode(node.tOwned[i]);
-    delete node.tOwned;
-  }
-  if (Transition && Transition.running && node.pure) {
-    reset(node, true);
-  } else if (node.owned) {
-    for (i = node.owned.length - 1; i >= 0; i--) cleanNode(node.owned[i]);
-    node.owned = null;
-  }
-  if (node.cleanups) {
-    for (i = node.cleanups.length - 1; i >= 0; i--) node.cleanups[i]();
-    node.cleanups = null;
-  }
-  if (Transition && Transition.running) node.tState = 0;else node.state = 0;
-  delete node.sourceMap;
-}
-function reset(node, top) {
-  if (!top) {
-    node.tState = 0;
-    Transition.disposed.add(node);
-  }
-  if (node.owned) {
-    for (let i = 0; i < node.owned.length; i++) reset(node.owned[i]);
-  }
-}
-function castError(err) {
-  if (err instanceof Error) return err;
-  return new Error(typeof err === "string" ? err : "Unknown error", {
-    cause: err
+      return Comp(props);
+    });
   });
 }
-function runErrors(err, fns, owner) {
-  try {
-    for (const f of fns) f(err);
-  } catch (e) {
-    handleError(e, owner && owner.owner || null);
-  }
-}
-function handleError(err, owner = Owner) {
-  const fns = ERROR && owner && owner.context && owner.context[ERROR];
-  const error = castError(err);
-  if (!fns) throw error;
-  if (Effects) Effects.push({
-    fn() {
-      runErrors(error, fns, owner);
-    },
-    state: STALE
-  });else runErrors(error, fns, owner);
-}
-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, options) {
-  return function provider(props) {
-    let res;
-    createRenderEffect(() => res = untrack(() => {
-      Owner.context = {
-        ...Owner.context,
-        [id]: props.value
-      };
-      return children(() => props.children);
-    }), undefined, options);
-    return res;
-  };
-}
-function onError(fn) {
-  ERROR || (ERROR = Symbol("error"));
-  if (Owner === null) console.warn("error handlers created outside a `createRoot` or `render` will never be run");else 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 registerGraph(value) {
+  const owner = signals.getOwner();
+  if (!owner) return;
+  if (owner.sourceMap) owner.sourceMap.push(value);else owner.sourceMap = [value];
+  value.graph = owner;
 }
 
 function observable(input) {
@@ -1078,14 +65,13 @@ function observable(input) {
           unsubscribe() {}
         };
       }
-      const dispose = createRoot(disposer => {
-        createEffect(() => {
-          const v = input();
-          untrack(() => handler(v));
+      const dispose = signals.createRoot(disposer => {
+        signals.createEffect(() => input(), v => {
+          handler(v);
         });
         return disposer;
       });
-      if (getOwner()) onCleanup(dispose);
+      if (signals.getOwner()) signals.onCleanup(dispose);
       return {
         unsubscribe() {
           dispose();
@@ -1098,181 +84,43 @@ function observable(input) {
   };
 }
 function from(producer) {
-  const [s, set] = createSignal(undefined, {
+  const [s, set] = signals.createSignal(undefined, {
     equals: false
   });
   if ("subscribe" in producer) {
     const unsub = producer.subscribe(v => set(() => v));
-    onCleanup(() => "unsubscribe" in unsub ? unsub.unsubscribe() : unsub());
+    signals.onCleanup(() => "unsubscribe" in unsub ? unsub.unsubscribe() : unsub());
   } else {
     const clean = producer(set);
-    onCleanup(clean);
+    signals.onCleanup(clean);
   }
   return s;
 }
 
-const FALLBACK = Symbol("fallback");
-function dispose(d) {
-  for (let i = 0; i < d.length; i++) d[i]();
+const sharedConfig = {
+  context: undefined,
+  registry: undefined,
+  done: false,
+  getContextId() {
+    return getContextId(this.context.count);
+  },
+  getNextContextId() {
+    return getContextId(this.context.count++);
+  }
+};
+function getContextId(count) {
+  const num = String(count),
+    len = num.length - 1;
+  return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
 }
-function mapArray(list, mapFn, options = {}) {
-  let items = [],
-    mapped = [],
-    disposers = [],
-    len = 0,
-    indexes = mapFn.length > 1 ? [] : null;
-  onCleanup(() => dispose(disposers));
-  return () => {
-    let newItems = list() || [],
-      newLen = newItems.length,
-      i,
-      j;
-    newItems[$TRACK];
-    return untrack(() => {
-      let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
-      if (newLen === 0) {
-        if (len !== 0) {
-          dispose(disposers);
-          disposers = [];
-          items = [];
-          mapped = [];
-          len = 0;
-          indexes && (indexes = []);
-        }
-        if (options.fallback) {
-          items = [FALLBACK];
-          mapped[0] = createRoot(disposer => {
-            disposers[0] = disposer;
-            return options.fallback();
-          });
-          len = 1;
-        }
-      }
-      else if (len === 0) {
-        mapped = new Array(newLen);
-        for (j = 0; j < newLen; j++) {
-          items[j] = newItems[j];
-          mapped[j] = createRoot(mapper);
-        }
-        len = newLen;
-      } else {
-        temp = new Array(newLen);
-        tempdisposers = new Array(newLen);
-        indexes && (tempIndexes = new Array(newLen));
-        for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++);
-        for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
-          temp[newEnd] = mapped[end];
-          tempdisposers[newEnd] = disposers[end];
-          indexes && (tempIndexes[newEnd] = indexes[end]);
-        }
-        newIndices = new Map();
-        newIndicesNext = new Array(newEnd + 1);
-        for (j = newEnd; j >= start; j--) {
-          item = newItems[j];
-          i = newIndices.get(item);
-          newIndicesNext[j] = i === undefined ? -1 : i;
-          newIndices.set(item, j);
-        }
-        for (i = start; i <= end; i++) {
-          item = items[i];
-          j = newIndices.get(item);
-          if (j !== undefined && j !== -1) {
-            temp[j] = mapped[i];
-            tempdisposers[j] = disposers[i];
-            indexes && (tempIndexes[j] = indexes[i]);
-            j = newIndicesNext[j];
-            newIndices.set(item, j);
-          } else disposers[i]();
-        }
-        for (j = start; j < newLen; j++) {
-          if (j in temp) {
-            mapped[j] = temp[j];
-            disposers[j] = tempdisposers[j];
-            if (indexes) {
-              indexes[j] = tempIndexes[j];
-              indexes[j](j);
-            }
-          } else mapped[j] = createRoot(mapper);
-        }
-        mapped = mapped.slice(0, len = newLen);
-        items = newItems.slice(0);
-      }
-      return mapped;
-    });
-    function mapper(disposer) {
-      disposers[j] = disposer;
-      if (indexes) {
-        const [s, set] = createSignal(j, {
-          name: "index"
-        }) ;
-        indexes[j] = set;
-        return mapFn(newItems[j], s);
-      }
-      return mapFn(newItems[j]);
-    }
-  };
+function setHydrateContext(context) {
+  sharedConfig.context = context;
 }
-function indexArray(list, mapFn, options = {}) {
-  let items = [],
-    mapped = [],
-    disposers = [],
-    signals = [],
-    len = 0,
-    i;
-  onCleanup(() => dispose(disposers));
-  return () => {
-    const newItems = list() || [],
-      newLen = newItems.length;
-    newItems[$TRACK];
-    return untrack(() => {
-      if (newLen === 0) {
-        if (len !== 0) {
-          dispose(disposers);
-          disposers = [];
-          items = [];
-          mapped = [];
-          len = 0;
-          signals = [];
-        }
-        if (options.fallback) {
-          items = [FALLBACK];
-          mapped[0] = createRoot(disposer => {
-            disposers[0] = disposer;
-            return options.fallback();
-          });
-          len = 1;
-        }
-        return mapped;
-      }
-      if (items[0] === FALLBACK) {
-        disposers[0]();
-        disposers = [];
-        items = [];
-        mapped = [];
-        len = 0;
-      }
-      for (i = 0; i < newLen; i++) {
-        if (i < items.length && items[i] !== newItems[i]) {
-          signals[i](() => newItems[i]);
-        } else if (i >= items.length) {
-          mapped[i] = createRoot(mapper);
-        }
-      }
-      for (; i < items.length; i++) {
-        disposers[i]();
-      }
-      len = signals.length = disposers.length = newLen;
-      items = newItems.slice(0);
-      return mapped = mapped.slice(0, len);
-    });
-    function mapper(disposer) {
-      disposers[i] = disposer;
-      const [s, set] = createSignal(newItems[i], {
-        name: "value"
-      }) ;
-      signals[i] = set;
-      return mapFn(s, i);
-    }
+function nextHydrateContext() {
+  return {
+    ...sharedConfig.context,
+    id: sharedConfig.getNextContextId(),
+    count: 0
   };
 }
 
@@ -1292,161 +140,13 @@ function createComponent(Comp, props) {
   }
   return devComponent(Comp, props || {});
 }
-function trueFn() {
-  return true;
-}
-const propTraps = {
-  get(_, property, receiver) {
-    if (property === $PROXY) return receiver;
-    return _.get(property);
-  },
-  has(_, property) {
-    if (property === $PROXY) return true;
-    return _.has(property);
-  },
-  set: trueFn,
-  deleteProperty: trueFn,
-  getOwnPropertyDescriptor(_, property) {
-    return {
-      configurable: true,
-      enumerable: true,
-      get() {
-        return _.get(property);
-      },
-      set: trueFn,
-      deleteProperty: trueFn
-    };
-  },
-  ownKeys(_) {
-    return _.keys();
-  }
-};
-function resolveSource(s) {
-  return !(s = typeof s === "function" ? s() : s) ? {} : s;
-}
-function resolveSources() {
-  for (let i = 0, length = this.length; i < length; ++i) {
-    const v = this[i]();
-    if (v !== undefined) return v;
-  }
-}
-function mergeProps(...sources) {
-  let proxy = false;
-  for (let i = 0; i < sources.length; i++) {
-    const s = sources[i];
-    proxy = proxy || !!s && $PROXY in s;
-    sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
-  }
-  if (SUPPORTS_PROXY && proxy) {
-    return new Proxy({
-      get(property) {
-        for (let i = sources.length - 1; i >= 0; i--) {
-          const v = resolveSource(sources[i])[property];
-          if (v !== undefined) return v;
-        }
-      },
-      has(property) {
-        for (let i = sources.length - 1; i >= 0; i--) {
-          if (property in resolveSource(sources[i])) return true;
-        }
-        return false;
-      },
-      keys() {
-        const keys = [];
-        for (let i = 0; i < sources.length; i++) keys.push(...Object.keys(resolveSource(sources[i])));
-        return [...new Set(keys)];
-      }
-    }, propTraps);
-  }
-  const sourcesMap = {};
-  const defined = Object.create(null);
-  for (let i = sources.length - 1; i >= 0; i--) {
-    const source = sources[i];
-    if (!source) continue;
-    const sourceKeys = Object.getOwnPropertyNames(source);
-    for (let i = sourceKeys.length - 1; i >= 0; i--) {
-      const key = sourceKeys[i];
-      if (key === "__proto__" || key === "constructor") continue;
-      const desc = Object.getOwnPropertyDescriptor(source, key);
-      if (!defined[key]) {
-        defined[key] = desc.get ? {
-          enumerable: true,
-          configurable: true,
-          get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
-        } : desc.value !== undefined ? desc : undefined;
-      } else {
-        const sources = sourcesMap[key];
-        if (sources) {
-          if (desc.get) sources.push(desc.get.bind(source));else if (desc.value !== undefined) sources.push(() => desc.value);
-        }
-      }
-    }
-  }
-  const target = {};
-  const definedKeys = Object.keys(defined);
-  for (let i = definedKeys.length - 1; i >= 0; i--) {
-    const key = definedKeys[i],
-      desc = defined[key];
-    if (desc && desc.get) Object.defineProperty(target, key, desc);else target[key] = desc ? desc.value : undefined;
-  }
-  return target;
-}
-function splitProps(props, ...keys) {
-  if (SUPPORTS_PROXY && $PROXY in props) {
-    const blocked = new Set(keys.length > 1 ? keys.flat() : keys[0]);
-    const res = keys.map(k => {
-      return new Proxy({
-        get(property) {
-          return k.includes(property) ? props[property] : undefined;
-        },
-        has(property) {
-          return k.includes(property) && property in props;
-        },
-        keys() {
-          return k.filter(property => property in props);
-        }
-      }, propTraps);
-    });
-    res.push(new Proxy({
-      get(property) {
-        return blocked.has(property) ? undefined : props[property];
-      },
-      has(property) {
-        return blocked.has(property) ? false : property in props;
-      },
-      keys() {
-        return Object.keys(props).filter(k => !blocked.has(k));
-      }
-    }, propTraps));
-    return res;
-  }
-  const otherObject = {};
-  const objects = keys.map(() => ({}));
-  for (const propName of Object.getOwnPropertyNames(props)) {
-    const desc = Object.getOwnPropertyDescriptor(props, propName);
-    const isDefaultDesc = !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable;
-    let blocked = false;
-    let objectIndex = 0;
-    for (const k of keys) {
-      if (k.includes(propName)) {
-        blocked = true;
-        isDefaultDesc ? objects[objectIndex][propName] = desc.value : Object.defineProperty(objects[objectIndex], propName, desc);
-      }
-      ++objectIndex;
-    }
-    if (!blocked) {
-      isDefaultDesc ? otherObject[propName] = desc.value : Object.defineProperty(otherObject, propName, desc);
-    }
-  }
-  return [...objects, otherObject];
-}
 function lazy(fn) {
   let comp;
   let p;
   const wrap = props => {
     const ctx = sharedConfig.context;
     if (ctx) {
-      const [s, set] = createSignal();
+      const [s, set] = signals.createSignal();
       sharedConfig.count || (sharedConfig.count = 0);
       sharedConfig.count++;
       (p || (p = fn())).then(mod => {
@@ -1457,12 +157,12 @@ function lazy(fn) {
       });
       comp = s;
     } else if (!comp) {
-      const [s] = createResource(() => (p || (p = fn())).then(mod => mod.default));
+      const s = signals.createAsync(() => (p || (p = fn())).then(mod => mod.default));
       comp = s;
     }
     let Comp;
-    return createMemo(() => (Comp = comp()) ? untrack(() => {
-      if (true) Object.assign(Comp, {
+    return signals.createMemo(() => (Comp = comp()) ? signals.untrack(() => {
+      Object.assign(Comp, {
         [$DEVCOMP]: true
       });
       if (!ctx || sharedConfig.done) return Comp(props);
@@ -1484,34 +184,37 @@ function createUniqueId() {
 
 const narrowedError = name => `Attempting to access a stale value from <${name}> that could possibly be undefined. This may occur because you are reading the accessor returned from the component at a time where it has already been unmounted. We recommend cleaning up any stale timers or async, or reading from the initial condition.` ;
 function For(props) {
-  const fallback = "fallback" in props && {
+  const options = "fallback" in props ? {
+    keyed: props.keyed,
     fallback: () => props.fallback
+  } : {
+    keyed: props.keyed
   };
-  return createMemo(mapArray(() => props.each, props.children, fallback || undefined), undefined, {
+  return signals.createMemo(signals.mapArray(() => props.each, props.children, options), undefined, {
     name: "value"
   }) ;
 }
-function Index(props) {
-  const fallback = "fallback" in props && {
+function Repeat(props) {
+  const options = "fallback" in props ? {
     fallback: () => props.fallback
-  };
-  return createMemo(indexArray(() => props.each, props.children, fallback || undefined), undefined, {
+  } : {};
+  return signals.createMemo(signals.repeat(() => props.count, index => typeof props.children === "function" ? props.children(index) : props.children, options), undefined, {
     name: "value"
   }) ;
 }
 function Show(props) {
   const keyed = props.keyed;
-  const condition = createMemo(() => props.when, undefined, {
+  const condition = signals.createMemo(() => props.when, undefined, {
     equals: (a, b) => keyed ? a === b : !a === !b,
     name: "condition"
   } );
-  return createMemo(() => {
+  return signals.createMemo(() => {
     const c = condition();
     if (c) {
       const child = props.children;
       const fn = typeof child === "function" && child.length > 0;
-      return fn ? untrack(() => child(keyed ? c : () => {
-        if (!untrack(condition)) throw narrowedError("Show");
+      return fn ? signals.untrack(() => child(() => {
+        if (!signals.untrack(condition)) throw narrowedError("Show");
         return props.when;
       })) : child;
     }
@@ -1524,7 +227,7 @@ function Switch(props) {
   let keyed = false;
   const equals = (a, b) => (keyed ? a[1] === b[1] : !a[1] === !b[1]) && a[2] === b[2];
   const conditions = children(() => props.children),
-    evalConditions = createMemo(() => {
+    evalConditions = signals.createMemo(() => {
       let conds = conditions();
       if (!Array.isArray(conds)) conds = [conds];
       for (let i = 0; i < conds.length; i++) {
@@ -1539,13 +242,13 @@ function Switch(props) {
       equals,
       name: "eval conditions"
     } );
-  return createMemo(() => {
+  return signals.createMemo(() => {
     const [index, when, cond] = evalConditions();
     if (index < 0) return props.fallback;
     const c = cond.children;
     const fn = typeof c === "function" && c.length > 0;
-    return fn ? untrack(() => c(keyed ? when : () => {
-      if (untrack(evalConditions)[0] !== index) throw narrowedError("Match");
+    return fn ? signals.untrack(() => c(() => {
+      if (signals.untrack(evalConditions)[0] !== index) throw narrowedError("Match");
       return cond.when;
     })) : c;
   }, undefined, {
@@ -1555,260 +258,167 @@ function Switch(props) {
 function Match(props) {
   return props;
 }
-let Errors;
-function resetErrorBoundaries() {
-  Errors && [...Errors].forEach(fn => fn());
-}
 function ErrorBoundary(props) {
-  let err;
-  if (sharedConfig.context && sharedConfig.load) err = sharedConfig.load(sharedConfig.getContextId());
-  const [errored, setErrored] = createSignal(err, {
-    name: "errored"
-  } );
-  Errors || (Errors = new Set());
-  Errors.add(setErrored);
-  onCleanup(() => Errors.delete(setErrored));
-  return createMemo(() => {
-    let e;
-    if (e = errored()) {
-      const f = props.fallback;
-      if ((typeof f !== "function" || f.length == 0)) console.error(e);
-      return typeof f === "function" && f.length ? untrack(() => f(e, () => setErrored())) : f;
-    }
-    return catchError(() => props.children, setErrored);
-  }, undefined, {
-    name: "value"
-  } );
-}
-
-const suspenseListEquals = (a, b) => a.showContent === b.showContent && a.showFallback === b.showFallback;
-const SuspenseListContext = /* #__PURE__ */createContext();
-function SuspenseList(props) {
-  let [wrapper, setWrapper] = createSignal(() => ({
-      inFallback: false
-    })),
-    show;
-  const listContext = useContext(SuspenseListContext);
-  const [registry, setRegistry] = createSignal([]);
-  if (listContext) {
-    show = listContext.register(createMemo(() => wrapper()().inFallback));
-  }
-  const resolved = createMemo(prev => {
-    const reveal = props.revealOrder,
-      tail = props.tail,
-      {
-        showContent = true,
-        showFallback = true
-      } = show ? show() : {},
-      reg = registry(),
-      reverse = reveal === "backwards";
-    if (reveal === "together") {
-      const all = reg.every(inFallback => !inFallback());
-      const res = reg.map(() => ({
-        showContent: all && showContent,
-        showFallback
-      }));
-      res.inFallback = !all;
-      return res;
-    }
-    let stop = false;
-    let inFallback = prev.inFallback;
-    const res = [];
-    for (let i = 0, len = reg.length; i < len; i++) {
-      const n = reverse ? len - i - 1 : i,
-        s = reg[n]();
-      if (!stop && !s) {
-        res[n] = {
-          showContent,
-          showFallback
-        };
-      } else {
-        const next = !stop;
-        if (next) inFallback = true;
-        res[n] = {
-          showContent: next,
-          showFallback: !tail || next && tail === "collapsed" ? showFallback : false
-        };
-        stop = true;
-      }
-    }
-    if (!stop) inFallback = false;
-    res.inFallback = inFallback;
-    return res;
-  }, {
-    inFallback: false
-  });
-  setWrapper(() => resolved);
-  return createComponent(SuspenseListContext.Provider, {
-    value: {
-      register: inFallback => {
-        let index;
-        setRegistry(registry => {
-          index = registry.length;
-          return [...registry, inFallback];
-        });
-        return createMemo(() => resolved()[index], undefined, {
-          equals: suspenseListEquals
-        });
-      }
-    },
-    get children() {
-      return props.children;
-    }
+  return signals.createErrorBoundary(() => props.children, (err, reset) => {
+    const f = props.fallback;
+    if ((typeof f !== "function" || f.length == 0)) console.error(err);
+    return typeof f === "function" && f.length ? f(err, reset) : f;
   });
 }
 function Suspense(props) {
-  let counter = 0,
-    show,
-    ctx,
-    p,
-    flicker,
-    error;
-  const [inFallback, setFallback] = createSignal(false),
-    SuspenseContext = getSuspenseContext(),
-    store = {
-      increment: () => {
-        if (++counter === 1) setFallback(true);
-      },
-      decrement: () => {
-        if (--counter === 0) setFallback(false);
-      },
-      inFallback,
-      effects: [],
-      resolved: false
-    },
-    owner = getOwner();
-  if (sharedConfig.context && sharedConfig.load) {
-    const key = sharedConfig.getContextId();
-    let ref = sharedConfig.load(key);
-    if (ref) {
-      if (typeof ref !== "object" || ref.status !== "success") p = ref;else sharedConfig.gather(key);
-    }
-    if (p && p !== "$$f") {
-      const [s, set] = createSignal(undefined, {
-        equals: false
-      });
-      flicker = s;
-      p.then(() => {
-        if (sharedConfig.done) return set();
-        sharedConfig.gather(key);
-        setHydrateContext(ctx);
-        set();
-        setHydrateContext();
-      }, err => {
-        error = err;
-        set();
-      });
-    }
-  }
-  const listContext = useContext(SuspenseListContext);
-  if (listContext) show = listContext.register(store.inFallback);
-  let dispose;
-  onCleanup(() => dispose && dispose());
-  return createComponent(SuspenseContext.Provider, {
-    value: store,
-    get children() {
-      return createMemo(() => {
-        if (error) throw error;
-        ctx = sharedConfig.context;
-        if (flicker) {
-          flicker();
-          return flicker = undefined;
-        }
-        if (ctx && p === "$$f") setHydrateContext();
-        const rendered = createMemo(() => props.children);
-        return createMemo(prev => {
-          const inFallback = store.inFallback(),
-            {
-              showContent = true,
-              showFallback = true
-            } = show ? show() : {};
-          if ((!inFallback || p && p !== "$$f") && showContent) {
-            store.resolved = true;
-            dispose && dispose();
-            dispose = ctx = p = undefined;
-            resumeEffects(store.effects);
-            return rendered();
-          }
-          if (!showFallback) return;
-          if (dispose) return prev;
-          return createRoot(disposer => {
-            dispose = disposer;
-            if (ctx) {
-              setHydrateContext({
-                id: ctx.id + "F",
-                count: 0
-              });
-              ctx = undefined;
-            }
-            return props.fallback;
-          }, owner);
-        });
-      });
-    }
-  });
+  return signals.createSuspense(() => props.children, () => props.fallback);
 }
 
+const DevHooks = {};
 const DEV = {
   hooks: DevHooks,
-  writeSignal,
   registerGraph
 } ;
 if (globalThis) {
   if (!globalThis.Solid$$) globalThis.Solid$$ = true;else console.warn("You appear to have multiple instances of Solid. This can lead to unexpected behavior.");
 }
 
+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, "createAsync", {
+  enumerable: true,
+  get: function () { return signals.createAsync; }
+});
+Object.defineProperty(exports, "createEffect", {
+  enumerable: true,
+  get: function () { return signals.createEffect; }
+});
+Object.defineProperty(exports, "createMemo", {
+  enumerable: true,
+  get: function () { return signals.createMemo; }
+});
+Object.defineProperty(exports, "createProjection", {
+  enumerable: true,
+  get: function () { return signals.createProjection; }
+});
+Object.defineProperty(exports, "createReaction", {
+  enumerable: true,
+  get: function () { return signals.createReaction; }
+});
+Object.defineProperty(exports, "createRenderEffect", {
+  enumerable: true,
+  get: function () { return signals.createRenderEffect; }
+});
+Object.defineProperty(exports, "createRoot", {
+  enumerable: true,
+  get: function () { return signals.createRoot; }
+});
+Object.defineProperty(exports, "createSignal", {
+  enumerable: true,
+  get: function () { return signals.createSignal; }
+});
+Object.defineProperty(exports, "createStore", {
+  enumerable: true,
+  get: function () { return signals.createStore; }
+});
+Object.defineProperty(exports, "flatten", {
+  enumerable: true,
+  get: function () { return signals.flatten; }
+});
+Object.defineProperty(exports, "flushSync", {
+  enumerable: true,
+  get: function () { return signals.flushSync; }
+});
+Object.defineProperty(exports, "getObserver", {
+  enumerable: true,
+  get: function () { return signals.getObserver; }
+});
+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, "isStale", {
+  enumerable: true,
+  get: function () { return signals.isStale; }
+});
+Object.defineProperty(exports, "isWrappable", {
+  enumerable: true,
+  get: function () { return signals.isWrappable; }
+});
+Object.defineProperty(exports, "latest", {
+  enumerable: true,
+  get: function () { return signals.latest; }
+});
+Object.defineProperty(exports, "mapArray", {
+  enumerable: true,
+  get: function () { return signals.mapArray; }
+});
+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, "reconcile", {
+  enumerable: true,
+  get: function () { return signals.reconcile; }
+});
+Object.defineProperty(exports, "repeat", {
+  enumerable: true,
+  get: function () { return signals.repeat; }
+});
+Object.defineProperty(exports, "resolve", {
+  enumerable: true,
+  get: function () { return signals.resolve; }
+});
+Object.defineProperty(exports, "runWithOwner", {
+  enumerable: true,
+  get: function () { return signals.runWithOwner; }
+});
+Object.defineProperty(exports, "untrack", {
+  enumerable: true,
+  get: function () { return signals.untrack; }
+});
+Object.defineProperty(exports, "unwrap", {
+  enumerable: true,
+  get: function () { return signals.unwrap; }
+});
 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.cancelCallback = cancelCallback;
-exports.catchError = catchError;
 exports.children = children;
 exports.createComponent = createComponent;
-exports.createComputed = createComputed;
 exports.createContext = createContext;
-exports.createDeferred = createDeferred;
-exports.createEffect = createEffect;
-exports.createMemo = createMemo;
-exports.createReaction = createReaction;
-exports.createRenderEffect = createRenderEffect;
-exports.createResource = createResource;
-exports.createRoot = createRoot;
-exports.createSelector = createSelector;
-exports.createSignal = createSignal;
 exports.createUniqueId = createUniqueId;
-exports.enableExternalSource = enableExternalSource;
 exports.enableHydration = enableHydration;
-exports.enableScheduling = enableScheduling;
-exports.equalFn = equalFn;
 exports.from = from;
-exports.getListener = getListener;
-exports.getOwner = getOwner;
-exports.indexArray = indexArray;
 exports.lazy = lazy;
-exports.mapArray = mapArray;
-exports.mergeProps = mergeProps;
 exports.observable = observable;
-exports.on = on;
-exports.onCleanup = onCleanup;
-exports.onError = onError;
 exports.onMount = onMount;
-exports.requestCallback = requestCallback;
-exports.resetErrorBoundaries = resetErrorBoundaries;
-exports.runWithOwner = runWithOwner;
 exports.sharedConfig = sharedConfig;
-exports.splitProps = splitProps;
-exports.startTransition = startTransition;
-exports.untrack = untrack;
 exports.useContext = useContext;
-exports.useTransition = useTransition;