@solidjs/universal 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/universal.js

@@ -1,9 +1,1175 @@
-import { createMemo, createRenderEffect, createComponent, merge, createRoot, flatten, untrack, runWithOwner } from 'solid-js';
+import { createMemo as createMemo$1, createRenderEffect, createComponent, merge, createRoot, flatten, untrack as untrack$1, runWithOwner } from 'solid-js';
+
+class NotReadyError extends Error {
+  source;
+  constructor(e) {
+    super();
+    this.source = e;
+  }
+}
+class StatusError extends Error {
+  source;
+  constructor(e, t) {
+    super(t instanceof Error ? t.message : String(t), {
+      cause: t
+    });
+    this.source = e;
+  }
+}
+const REACTIVE_NONE = 0;
+const REACTIVE_CHECK = 1 << 0;
+const REACTIVE_DIRTY = 1 << 1;
+const REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+const REACTIVE_IN_HEAP = 1 << 3;
+const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+const REACTIVE_ZOMBIE = 1 << 5;
+const REACTIVE_DISPOSED = 1 << 6;
+const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
+const REACTIVE_SNAPSHOT_STALE = 1 << 8;
+const REACTIVE_LAZY = 1 << 9;
+const STATUS_PENDING = 1 << 0;
+const STATUS_ERROR = 1 << 1;
+const STATUS_UNINITIALIZED = 1 << 2;
+const EFFECT_RENDER = 1;
+const EFFECT_USER = 2;
+const EFFECT_TRACKED = 3;
+const NOT_PENDING = {};
+const defaultContext = {};
+function actualInsertIntoHeap(e, t) {
+  const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
+  if (n >= e.o) e.o = n + 1;
+  const i = e.o;
+  const r = t.l[i];
+  if (r === undefined) t.l[i] = e;else {
+    const t = r.T;
+    t.S = e;
+    e.T = t;
+    r.T = e;
+  }
+  if (i > t.R) t.R = i;
+}
+function insertIntoHeap(e, t) {
+  let n = e.O;
+  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  if (n & REACTIVE_CHECK) {
+    e.O = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else e.O = n | REACTIVE_IN_HEAP;
+  if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
+}
+function insertIntoHeapHeight(e, t) {
+  let n = e.O;
+  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  e.O = n | REACTIVE_IN_HEAP_HEIGHT;
+  actualInsertIntoHeap(e, t);
+}
+function deleteFromHeap(e, t) {
+  const n = e.O;
+  if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+  e.O = n & -25;
+  const i = e.o;
+  if (e.T === e) t.l[i] = undefined;else {
+    const n = e.S;
+    const r = t.l[i];
+    const s = n ?? r;
+    if (e === r) t.l[i] = n;else e.T.S = n;
+    s.T = e.T;
+  }
+  e.T = e;
+  e.S = undefined;
+}
+function markHeap(e) {
+  if (e._) return;
+  e._ = true;
+  for (let t = 0; t <= e.R; t++) {
+    for (let n = e.l[t]; n !== undefined; n = n.S) {
+      if (n.O & REACTIVE_IN_HEAP) markNode(n);
+    }
+  }
+}
+function markNode(e, t = REACTIVE_DIRTY) {
+  const n = e.O;
+  if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
+  e.O = n & -4 | t;
+  for (let t = e.I; t !== null; t = t.p) {
+    markNode(t.h, REACTIVE_CHECK);
+  }
+  if (e.A !== null) {
+    for (let t = e.A; t !== null; t = t.P) {
+      for (let e = t.I; e !== null; e = e.p) {
+        markNode(e.h, REACTIVE_CHECK);
+      }
+    }
+  }
+}
+function runHeap(e, t) {
+  e._ = false;
+  for (e.N = 0; e.N <= e.R; e.N++) {
+    let n = e.l[e.N];
+    while (n !== undefined) {
+      if (n.O & REACTIVE_IN_HEAP) t(n);else adjustHeight(n, e);
+      n = e.l[e.N];
+    }
+  }
+  e.R = 0;
+}
+function adjustHeight(e, t) {
+  deleteFromHeap(e, t);
+  let n = e.o;
+  for (let t = e.C; t; t = t.D) {
+    const e = t.V;
+    const i = e.m || e;
+    if (i.L && i.o >= n) n = i.o + 1;
+  }
+  if (e.o !== n) {
+    e.o = n;
+    for (let n = e.I; n !== null; n = n.p) {
+      insertIntoHeapHeight(n.h, t);
+    }
+  }
+}
+const transitions = new Set();
+const dirtyQueue = {
+  l: new Array(2e3).fill(undefined),
+  _: false,
+  N: 0,
+  R: 0
+};
+const zombieQueue = {
+  l: new Array(2e3).fill(undefined),
+  _: false,
+  N: 0,
+  R: 0
+};
+let clock = 0;
+let activeTransition = null;
+let scheduled = false;
+function runLaneEffects(e) {
+  for (const t of activeLanes) {
+    if (t.k || t.U.size > 0) continue;
+    const n = t.W[e - 1];
+    if (n.length) {
+      t.W[e - 1] = [];
+      runQueue(n, e);
+    }
+  }
+}
+function schedule() {
+  if (scheduled) return;
+  scheduled = true;
+  if (!globalQueue.H && true) queueMicrotask(flush);
+}
+class Queue {
+  i = null;
+  G = [[], []];
+  M = [];
+  created = clock;
+  addChild(e) {
+    this.M.push(e);
+    e.i = this;
+  }
+  removeChild(e) {
+    const t = this.M.indexOf(e);
+    if (t >= 0) {
+      this.M.splice(t, 1);
+      e.i = null;
+    }
+  }
+  notify(e, t, n, i) {
+    if (this.i) return this.i.notify(e, t, n, i);
+    return false;
+  }
+  run(e) {
+    if (this.G[e - 1].length) {
+      const t = this.G[e - 1];
+      this.G[e - 1] = [];
+      runQueue(t, e);
+    }
+    for (let t = 0; t < this.M.length; t++) this.M[t].run?.(e);
+  }
+  enqueue(e, t) {
+    if (e) {
+      if (currentOptimisticLane) {
+        const n = findLane(currentOptimisticLane);
+        n.W[e - 1].push(t);
+      } else {
+        this.G[e - 1].push(t);
+      }
+    }
+    schedule();
+  }
+  stashQueues(e) {
+    e.G[0].push(...this.G[0]);
+    e.G[1].push(...this.G[1]);
+    this.G = [[], []];
+    for (let t = 0; t < this.M.length; t++) {
+      let n = this.M[t];
+      let i = e.M[t];
+      if (!i) {
+        i = {
+          G: [[], []],
+          M: []
+        };
+        e.M[t] = i;
+      }
+      n.stashQueues(i);
+    }
+  }
+  restoreQueues(e) {
+    this.G[0].push(...e.G[0]);
+    this.G[1].push(...e.G[1]);
+    for (let t = 0; t < e.M.length; t++) {
+      const n = e.M[t];
+      let i = this.M[t];
+      if (i) i.restoreQueues(n);
+    }
+  }
+}
+class GlobalQueue extends Queue {
+  H = false;
+  F = [];
+  $ = [];
+  j = new Set();
+  static K;
+  static Y;
+  static Z = null;
+  flush() {
+    if (this.H) return;
+    this.H = true;
+    try {
+      runHeap(dirtyQueue, GlobalQueue.K);
+      if (activeTransition) {
+        const e = transitionComplete(activeTransition);
+        if (!e) {
+          let e = activeTransition;
+          runHeap(zombieQueue, GlobalQueue.K);
+          this.F = [];
+          this.$ = [];
+          this.j = new Set();
+          runLaneEffects(EFFECT_RENDER);
+          runLaneEffects(EFFECT_USER);
+          this.stashQueues(activeTransition.B);
+          clock++;
+          scheduled = dirtyQueue.R >= dirtyQueue.N;
+          reassignPendingTransition(activeTransition.F);
+          activeTransition = null;
+          finalizePureQueue(null, true);
+          return;
+        }
+        this.F !== activeTransition.F && this.F.push(...activeTransition.F);
+        this.restoreQueues(activeTransition.B);
+        transitions.delete(activeTransition);
+        const t = activeTransition;
+        activeTransition = null;
+        reassignPendingTransition(this.F);
+        finalizePureQueue(t);
+      } else {
+        if (transitions.size) runHeap(zombieQueue, GlobalQueue.K);
+        finalizePureQueue();
+      }
+      clock++;
+      scheduled = dirtyQueue.R >= dirtyQueue.N;
+      runLaneEffects(EFFECT_RENDER);
+      this.run(EFFECT_RENDER);
+      runLaneEffects(EFFECT_USER);
+      this.run(EFFECT_USER);
+    } finally {
+      this.H = false;
+    }
+  }
+  notify(e, t, n, i) {
+    if (t & STATUS_PENDING) {
+      if (n & STATUS_PENDING) {
+        const t = i !== undefined ? i : e.X;
+        if (activeTransition && t && !activeTransition.q.includes(t.source)) {
+          activeTransition.q.push(t.source);
+          schedule();
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  initTransition(e) {
+    if (e) e = currentTransition(e);
+    if (e && e === activeTransition) return;
+    if (!e && activeTransition && activeTransition.J === clock) return;
+    if (!activeTransition) {
+      activeTransition = e ?? {
+        J: clock,
+        F: [],
+        q: [],
+        $: [],
+        j: new Set(),
+        ee: [],
+        B: {
+          G: [[], []],
+          M: []
+        },
+        te: false
+      };
+    } else if (e) {
+      const t = activeTransition;
+      t.te = e;
+      e.ee.push(...t.ee);
+      for (const n of activeLanes) {
+        if (n.ne === t) n.ne = e;
+      }
+      e.$.push(...t.$);
+      for (const n of t.j) {
+        e.j.add(n);
+      }
+      transitions.delete(t);
+      activeTransition = e;
+    }
+    transitions.add(activeTransition);
+    activeTransition.J = clock;
+    for (let e = 0; e < this.F.length; e++) {
+      const t = this.F[e];
+      t.ne = activeTransition;
+      activeTransition.F.push(t);
+    }
+    this.F = activeTransition.F;
+    for (let e = 0; e < this.$.length; e++) {
+      const t = this.$[e];
+      t.ne = activeTransition;
+      activeTransition.$.push(t);
+    }
+    this.$ = activeTransition.$;
+    for (const e of activeLanes) {
+      if (!e.ne) e.ne = activeTransition;
+    }
+    for (const e of this.j) activeTransition.j.add(e);
+    this.j = activeTransition.j;
+  }
+}
+function insertSubs(e, t = false) {
+  const n = e.ie || currentOptimisticLane;
+  const i = e.re !== undefined;
+  for (let r = e.I; r !== null; r = r.p) {
+    if (i && r.h.se) {
+      r.h.O |= REACTIVE_SNAPSHOT_STALE;
+      continue;
+    }
+    if (t && n) {
+      r.h.O |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(r.h, n);
+    } else if (t) {
+      r.h.O |= REACTIVE_OPTIMISTIC_DIRTY;
+      r.h.ie = undefined;
+    }
+    const e = r.h;
+    if (e.oe === EFFECT_TRACKED) {
+      if (!e.ue) {
+        e.ue = true;
+        e.ce.enqueue(EFFECT_USER, e.le);
+      }
+      continue;
+    }
+    const s = r.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (s.N > r.h.o) s.N = r.h.o;
+    insertIntoHeap(r.h, s);
+  }
+}
+function finalizePureQueue(e = null, t = false) {
+  let n = !t;
+  if (!t) checkBoundaryChildren(globalQueue);
+  if (dirtyQueue.R >= dirtyQueue.N) runHeap(dirtyQueue, GlobalQueue.K);
+  if (n) {
+    const t = globalQueue.F;
+    for (let e = 0; e < t.length; e++) {
+      const n = t[e];
+      if (n.ae !== NOT_PENDING) {
+        n.fe = n.ae;
+        n.ae = NOT_PENDING;
+        if (n.oe && n.oe !== EFFECT_TRACKED) n.ue = true;
+      }
+      if (!(n.Ee & STATUS_PENDING)) n.Ee &= ~STATUS_UNINITIALIZED;
+      if (n.L) GlobalQueue.Y(n, false, true);
+    }
+    t.length = 0;
+    const n = e ? e.$ : globalQueue.$;
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      const i = t.ae;
+      t.ie = undefined;
+      if (i !== NOT_PENDING && t.fe !== i) {
+        t.fe = i;
+        insertSubs(t, true);
+      }
+      t.ae = NOT_PENDING;
+      t.ne = null;
+    }
+    n.length = 0;
+    e ? e.j : globalQueue.j;
+    for (const t of activeLanes) {
+      const n = e ? t.ne === e : !t.ne;
+      if (!n) continue;
+      if (!t.k) {
+        if (t.W[0].length) runQueue(t.W[0], EFFECT_RENDER);
+        if (t.W[1].length) runQueue(t.W[1], EFFECT_USER);
+      }
+      if (t.Te.ie === t) t.Te.ie = undefined;
+      t.U.clear();
+      t.W[0].length = 0;
+      t.W[1].length = 0;
+      activeLanes.delete(t);
+      signalLanes.delete(t.Te);
+    }
+  }
+}
+function checkBoundaryChildren(e) {
+  for (const t of e.M) {
+    t.checkSources?.();
+    checkBoundaryChildren(t);
+  }
+}
+function reassignPendingTransition(e) {
+  for (let t = 0; t < e.length; t++) {
+    e[t].ne = activeTransition;
+  }
+}
+const globalQueue = new GlobalQueue();
+function flush() {
+  while (scheduled) {
+    globalQueue.flush();
+  }
+}
+function runQueue(e, t) {
+  for (let n = 0; n < e.length; n++) e[n](t);
+}
+function transitionComplete(e) {
+  if (e.te) return true;
+  if (e.ee.length) return false;
+  let t = true;
+  for (let n = 0; n < e.q.length; n++) {
+    const i = e.q[n];
+    if (i.Ee & STATUS_PENDING && i.X?.source === i) {
+      t = false;
+      break;
+    }
+  }
+  t && (e.te = true);
+  return t;
+}
+function currentTransition(e) {
+  while (e.te && typeof e.te === "object") e = e.te;
+  return e;
+}
+function runInTransition(e, t) {
+  const n = activeTransition;
+  try {
+    activeTransition = currentTransition(e);
+    return t();
+  } finally {
+    activeTransition = n;
+  }
+}
+const signalLanes = new WeakMap();
+const activeLanes = new Set();
+function getOrCreateLane(e) {
+  let t = signalLanes.get(e);
+  if (t) {
+    return findLane(t);
+  }
+  const n = e.de;
+  const i = n?.ie ? findLane(n.ie) : null;
+  t = {
+    Te: e,
+    U: new Set(),
+    W: [[], []],
+    k: null,
+    ne: activeTransition,
+    Se: i
+  };
+  signalLanes.set(e, t);
+  activeLanes.add(t);
+  e.Re = e.Oe || 0;
+  return t;
+}
+function findLane(e) {
+  while (e.k) e = e.k;
+  return e;
+}
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  t.k = e;
+  for (const n of t.U) e.U.add(n);
+  e.W[0].push(...t.W[0]);
+  e.W[1].push(...t.W[1]);
+  return e;
+}
+function resolveLane(e) {
+  const t = e.ie;
+  if (!t) return undefined;
+  const n = findLane(t);
+  if (activeLanes.has(n)) return n;
+  e.ie = undefined;
+  return undefined;
+}
+function hasActiveOverride(e) {
+  return !!(e._e && e.ae !== NOT_PENDING);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const i = e.ie;
+  if (i) {
+    if (i.k) {
+      e.ie = t;
+      return;
+    }
+    const r = findLane(i);
+    if (activeLanes.has(r)) {
+      if (r !== n && !hasActiveOverride(e)) {
+        if (n.Se && findLane(n.Se) === r) {
+          e.ie = t;
+        } else if (r.Se && findLane(r.Se) === n) ;else mergeLanes(n, r);
+      }
+      return;
+    }
+  }
+  e.ie = t;
+}
+function handleAsync(e, t, n) {
+  const i = typeof t === "object" && t !== null;
+  const r = i && untrack(() => t[Symbol.asyncIterator]);
+  const s = !r && i && untrack(() => typeof t.then === "function");
+  if (!s && !r) {
+    e.Ie = null;
+    return t;
+  }
+  e.Ie = t;
+  let o;
+  const handleError = n => {
+    if (e.Ie !== t) return;
+    globalQueue.initTransition(e.ne);
+    notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
+    e.J = clock;
+  };
+  const asyncWrite = (i, r) => {
+    if (e.Ie !== t) return;
+    if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    globalQueue.initTransition(e.ne);
+    clearStatus(e);
+    const s = resolveLane(e);
+    if (s) s.U.delete(e);
+    if (e._e) {
+      const t = e.ae !== NOT_PENDING;
+      if (e.L) e.ae = i;
+      if (!t) {
+        e.fe = i;
+        insertSubs(e);
+      }
+      e.J = clock;
+    } else if (s) {
+      const t = e.fe;
+      const n = e.pe;
+      if (!n || !n(i, t)) {
+        e.fe = i;
+        e.J = clock;
+        if (e.he) {
+          setSignal(e.he, i);
+        }
+        insertSubs(e, true);
+      }
+    } else {
+      setSignal(e, () => i);
+    }
+    schedule();
+    flush();
+    r?.();
+  };
+  if (s) {
+    let n = false,
+      i = true;
+    t.then(e => {
+      if (i) {
+        o = e;
+        n = true;
+      } else asyncWrite(e);
+    }, e => {
+      if (!i) handleError(e);
+    });
+    i = false;
+    if (!n) {
+      globalQueue.initTransition(e.ne);
+      throw new NotReadyError(context);
+    }
+  }
+  if (r) {
+    const n = t[Symbol.asyncIterator]();
+    let i = false;
+    const iterate = () => {
+      let e,
+        t = false,
+        r = true;
+      n.next().then(n => {
+        if (r) {
+          e = n;
+          t = true;
+        } else if (!n.done) asyncWrite(n.value, iterate);else {
+          schedule();
+          flush();
+        }
+      }, e => {
+        if (!r) handleError(e);
+      });
+      r = false;
+      if (t && !e.done) {
+        o = e.value;
+        i = true;
+        return iterate();
+      }
+      return t && e.done;
+    };
+    const r = iterate();
+    if (!i && !r) {
+      globalQueue.initTransition(e.ne);
+      throw new NotReadyError(context);
+    }
+  }
+  return o;
+}
+function clearStatus(e) {
+  e.Ee = e.Ee & STATUS_UNINITIALIZED;
+  e.X = null;
+  updatePendingSignal(e);
+  e.Ae?.();
+}
+function notifyStatus(e, t, n, i, r) {
+  if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError)) n = new StatusError(e, n);
+  const s = n instanceof NotReadyError && n.source === e;
+  const o = t === STATUS_PENDING && e._e && !s;
+  const u = o && hasActiveOverride(e);
+  if (!i) {
+    e.Ee = t | (t !== STATUS_ERROR ? e.Ee & STATUS_UNINITIALIZED : 0);
+    e.X = n;
+    updatePendingSignal(e);
+  }
+  if (r && !i) {
+    assignOrMergeLane(e, r);
+  }
+  if (u && activeTransition && n instanceof NotReadyError) {
+    const e = n.source;
+    if (!activeTransition.q.includes(e)) {
+      activeTransition.q.push(e);
+    }
+  }
+  const c = i || u;
+  const l = i || o ? undefined : r;
+  if (e.Ae) {
+    if (c) {
+      e.Ae(t, n);
+    } else {
+      e.Ae();
+    }
+    return;
+  }
+  for (let i = e.I; i !== null; i = i.p) {
+    i.h.J = clock;
+    if (i.h.X !== n) {
+      !i.h.ne && globalQueue.F.push(i.h);
+      notifyStatus(i.h, t, n, c, l);
+    }
+  }
+  for (let i = e.A; i !== null; i = i.P) {
+    for (let e = i.I; e !== null; e = e.p) {
+      e.h.J = clock;
+      if (e.h.X !== n) {
+        !e.h.ne && globalQueue.F.push(e.h);
+        notifyStatus(e.h, t, n, c, l);
+      }
+    }
+  }
+}
+function unlinkSubs(e) {
+  const t = e.V;
+  const n = e.D;
+  const i = e.p;
+  const r = e.Pe;
+  if (i !== null) i.Pe = r;else t.Ne = r;
+  if (r !== null) r.p = i;else {
+    t.I = i;
+    if (i === null) {
+      t.ge?.();
+      t.L && !t.Ce && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
+    }
+  }
+  return n;
+}
+function unobserved(e) {
+  deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let t = e.C;
+  while (t !== null) {
+    t = unlinkSubs(t);
+  }
+  e.C = null;
+  disposeChildren(e, true);
+}
+function link(e, t) {
+  const n = t.ye;
+  if (n !== null && n.V === e) return;
+  let i = null;
+  const r = t.O & REACTIVE_RECOMPUTING_DEPS;
+  if (r) {
+    i = n !== null ? n.D : t.C;
+    if (i !== null && i.V === e) {
+      t.ye = i;
+      return;
+    }
+  }
+  const s = e.Ne;
+  if (s !== null && s.h === t && (!r || isValidLink(s, t))) return;
+  const o = t.ye = e.Ne = {
+    V: e,
+    h: t,
+    D: i,
+    Pe: s,
+    p: null
+  };
+  if (n !== null) n.D = o;else t.C = o;
+  if (s !== null) s.p = o;else e.I = o;
+}
+function isValidLink(e, t) {
+  const n = t.ye;
+  if (n !== null) {
+    let i = t.C;
+    do {
+      if (i === e) return true;
+      if (i === n) break;
+      i = i.D;
+    } while (i !== null);
+  }
+  return false;
+}
+function markDisposal(e) {
+  let t = e.De;
+  while (t) {
+    t.O |= REACTIVE_ZOMBIE;
+    if (t.O & REACTIVE_IN_HEAP) {
+      deleteFromHeap(t, dirtyQueue);
+      insertIntoHeap(t, zombieQueue);
+    }
+    markDisposal(t);
+    t = t.ve;
+  }
+}
+function disposeChildren(e, t = false, n) {
+  if (e.O & REACTIVE_DISPOSED) return;
+  if (t) e.O = REACTIVE_DISPOSED;
+  let i = n ? e.be : e.De;
+  while (i) {
+    const e = i.ve;
+    if (i.C) {
+      const e = i;
+      deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t = e.C;
+      do {
+        t = unlinkSubs(t);
+      } while (t !== null);
+      e.C = null;
+      e.ye = null;
+    }
+    disposeChildren(i, true);
+    i = e;
+  }
+  if (n) {
+    e.be = null;
+  } else {
+    e.De = null;
+    e.ve = null;
+    e.we = 0;
+  }
+  runDisposal(e, n);
+}
+function runDisposal(e, t) {
+  let n = t ? e.Ve : e.me;
+  if (!n) return;
+  if (Array.isArray(n)) {
+    for (let e = 0; e < n.length; e++) {
+      const t = n[e];
+      t.call(t);
+    }
+  } else {
+    n.call(n);
+  }
+  t ? e.Ve = null : e.me = null;
+}
+GlobalQueue.K = recompute;
+GlobalQueue.Y = disposeChildren;
+let tracking = false;
+let stale = false;
+let context = null;
+let currentOptimisticLane = null;
+function recompute(e, t = false) {
+  const n = e.oe;
+  if (!t) {
+    if (e.ne && (!n || activeTransition) && activeTransition !== e.ne) globalQueue.initTransition(e.ne);
+    deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (e.ne || n === EFFECT_TRACKED) disposeChildren(e);else {
+      markDisposal(e);
+      e.Ve = e.me;
+      e.be = e.De;
+      e.me = null;
+      e.De = null;
+      e.we = 0;
+    }
+  }
+  const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
+  const r = hasActiveOverride(e);
+  const s = !!(e.Ee & STATUS_PENDING);
+  const o = context;
+  context = e;
+  e.ye = null;
+  e.O = REACTIVE_RECOMPUTING_DEPS;
+  e.J = clock;
+  let u = e.ae === NOT_PENDING ? e.fe : e.ae;
+  let c = e.o;
+  let l = tracking;
+  let a = currentOptimisticLane;
+  tracking = true;
+  if (i) {
+    const t = resolveLane(e);
+    if (t) currentOptimisticLane = t;
+  }
+  try {
+    u = handleAsync(e, e.L(u));
+    clearStatus(e);
+    const t = resolveLane(e);
+    if (t) {
+      t.U.delete(e);
+      updatePendingSignal(t.Te);
+    }
+  } catch (t) {
+    if (t instanceof NotReadyError && currentOptimisticLane) {
+      const t = findLane(currentOptimisticLane);
+      if (t.Te !== e) {
+        t.U.add(e);
+        e.ie = t;
+        updatePendingSignal(t.Te);
+      }
+    }
+    notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.ie : undefined);
+  } finally {
+    tracking = l;
+    e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
+    context = o;
+  }
+  if (!e.X) {
+    const o = e.ye;
+    let l = o !== null ? o.D : e.C;
+    if (l !== null) {
+      do {
+        l = unlinkSubs(l);
+      } while (l !== null);
+      if (o !== null) o.D = null;else e.C = null;
+    }
+    const a = r ? e.fe : e.ae === NOT_PENDING ? e.fe : e.ae;
+    const f = !e.pe || !e.pe(a, u);
+    if (f) {
+      const o = r ? e.fe : undefined;
+      if (t || n && activeTransition !== e.ne || i) e.fe = u;else e.ae = u;
+      if (r && !i && s) {
+        const t = e.Oe || 0;
+        const n = e.Re || 0;
+        if (t <= n) e.fe = u;
+      }
+      if (!r || i || e.fe !== o) {
+        insertSubs(e, i || r);
+      }
+    } else if (r) {
+      e.ae = u;
+    } else if (e.o != c) {
+      for (let t = e.I; t !== null; t = t.p) {
+        insertIntoHeapHeight(t.h, t.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
+    }
+  }
+  currentOptimisticLane = a;
+  (!t || e.Ee & STATUS_PENDING) && !e.ne && !(activeTransition && e._e) && globalQueue.F.push(e);
+  e.ne && n && activeTransition !== e.ne && runInTransition(e.ne, () => recompute(e));
+}
+function updateIfNecessary(e) {
+  if (e.O & REACTIVE_CHECK) {
+    for (let t = e.C; t; t = t.D) {
+      const n = t.V;
+      const i = n.m || n;
+      if (i.L) {
+        updateIfNecessary(i);
+      }
+      if (e.O & REACTIVE_DIRTY) {
+        break;
+      }
+    }
+  }
+  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.X && e.J < clock && !e.Ie) {
+    recompute(e);
+  }
+  e.O = REACTIVE_NONE | e.O & REACTIVE_SNAPSHOT_STALE;
+}
+function computed(e, t, n) {
+  const i = n?.transparent;
+  const r = {
+    id: n?.id ?? (context?.id ),
+    Le: i,
+    pe: n?.equals != null ? n.equals : isEqual,
+    Ge: !!n?.pureWrite,
+    ge: n?.unobserved,
+    me: null,
+    ce: context?.ce ?? globalQueue,
+    ke: context?.ke ?? defaultContext,
+    we: 0,
+    L: e,
+    fe: t,
+    o: 0,
+    A: null,
+    S: undefined,
+    T: null,
+    C: null,
+    ye: null,
+    I: null,
+    Ne: null,
+    i: context,
+    ve: null,
+    De: null,
+    O: n?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+    Ee: STATUS_UNINITIALIZED,
+    J: clock,
+    ae: NOT_PENDING,
+    Ve: null,
+    be: null,
+    Ie: null,
+    ne: null
+  };
+  r.T = r;
+  const s = context?.t ? context.u : context;
+  if (context) {
+    const e = context.De;
+    if (e === null) {
+      context.De = r;
+    } else {
+      r.ve = e;
+      context.De = r;
+    }
+  }
+  if (s) r.o = s.o + 1;
+  !n?.lazy && recompute(r, true);
+  return r;
+}
+function isEqual(e, t) {
+  return e === t;
+}
+function untrack(e, t) {
+  if (!tracking && true) return e();
+  const n = tracking;
+  tracking = false;
+  try {
+    return e();
+  } finally {
+    tracking = n;
+  }
+}
+function read(e) {
+  let t = context;
+  if (t?.t) t = t.u;
+  if (e.O & REACTIVE_LAZY) {
+    e.O &= ~REACTIVE_LAZY;
+    recompute(e, true);
+  }
+  const n = e.m || e;
+  if (t && tracking) {
+    if (e.L && e.O & REACTIVE_DISPOSED) recompute(e);
+    link(e, t);
+    if (n.L) {
+      const i = e.O & REACTIVE_ZOMBIE;
+      if (n.o >= (i ? zombieQueue.N : dirtyQueue.N)) {
+        markNode(t);
+        markHeap(i ? zombieQueue : dirtyQueue);
+        updateIfNecessary(n);
+      }
+      const r = n.o;
+      if (r >= t.o && e.i !== t) {
+        t.o = r + 1;
+      }
+    }
+  }
+  if (n.Ee & STATUS_PENDING) {
+    if (t && true) {
+      if (currentOptimisticLane) {
+        const i = n.ie;
+        const r = findLane(currentOptimisticLane);
+        if (i && findLane(i) === r && !hasActiveOverride(n)) {
+          if (!tracking) link(e, t);
+          throw n.X;
+        }
+      } else {
+        if (!tracking) link(e, t);
+        throw n.X;
+      }
+    } else if (!t && n.Ee & STATUS_UNINITIALIZED) {
+      throw n.X;
+    }
+  }
+  if (e.L && e.Ee & STATUS_ERROR) {
+    if (e.J < clock) {
+      recompute(e, true);
+      return read(e);
+    } else throw e.X;
+  }
+  return !t || currentOptimisticLane !== null && (e._e || e.ie || n === e || !!(n.Ee & STATUS_PENDING)) || e.ae === NOT_PENDING || stale ? e.fe : e.ae;
+}
+function setSignal(e, t) {
+  if (e.ne && activeTransition !== e.ne) globalQueue.initTransition(e.ne);
+  const n = e._e && true;
+  const i = n ? e.fe : e.ae === NOT_PENDING ? e.fe : e.ae;
+  if (typeof t === "function") t = t(i);
+  const r = !e.pe || !e.pe(i, t) || !!(e.Ee & STATUS_UNINITIALIZED);
+  if (!r) {
+    if (n && e.ae !== NOT_PENDING && e.L) {
+      insertSubs(e, true);
+      schedule();
+    }
+    return t;
+  }
+  if (n) {
+    const n = globalQueue.$.includes(e);
+    if (e.ne && n) {
+      globalQueue.initTransition(e.ne);
+    }
+    if (e.ae === NOT_PENDING) {
+      e.ae = e.fe;
+    }
+    if (!n) {
+      globalQueue.$.push(e);
+    }
+    e.Oe = (e.Oe || 0) + 1;
+    const i = getOrCreateLane(e);
+    e.ie = i;
+    e.fe = t;
+  } else {
+    if (e.ae === NOT_PENDING) globalQueue.F.push(e);
+    e.ae = t;
+  }
+  updatePendingSignal(e);
+  if (e.he) {
+    setSignal(e.he, t);
+  }
+  e.J = clock;
+  insertSubs(e, n);
+  schedule();
+  return t;
+}
+function computePendingState(e) {
+  const t = e;
+  if (e._e && e.ae !== NOT_PENDING) {
+    if (t.Ee & STATUS_PENDING && !(t.Ee & STATUS_UNINITIALIZED)) return true;
+    if (e.de) {
+      const t = e.ie ? findLane(e.ie) : null;
+      return !!(t && t.U.size > 0);
+    }
+    return true;
+  }
+  if (e.ae !== NOT_PENDING && !(t.Ee & STATUS_UNINITIALIZED)) return true;
+  return !!(t.Ee & STATUS_PENDING && !(t.Ee & STATUS_UNINITIALIZED));
+}
+function updatePendingSignal(e) {
+  if (e.Me) {
+    const t = computePendingState(e);
+    const n = e.Me;
+    setSignal(n, t);
+    if (!t && n.ie) {
+      const t = resolveLane(e);
+      if (t && t.U.size > 0) {
+        const e = findLane(n.ie);
+        if (e !== t) {
+          mergeLanes(t, e);
+        }
+      }
+      signalLanes.delete(n);
+      n.ie = undefined;
+    }
+  }
+}
+function createMemo(e, t, n) {
+  let i = computed(e, t, n);
+  return read.bind(null, i);
+}
+function isWrappable(e) {
+  return e != null && typeof e === "object" && !Object.isFrozen(e);
+}
+const DELETE = Symbol(0);
+function updatePath(e, t, n = 0) {
+  let i,
+    r = e;
+  if (n < t.length - 1) {
+    i = t[n];
+    const s = typeof i;
+    const o = Array.isArray(e);
+    if (Array.isArray(i)) {
+      for (let r = 0; r < i.length; r++) {
+        t[n] = i[r];
+        updatePath(e, t, n);
+      }
+      t[n] = i;
+      return;
+    } else if (o && s === "function") {
+      for (let r = 0; r < e.length; r++) {
+        if (i(e[r], r)) {
+          t[n] = r;
+          updatePath(e, t, n);
+        }
+      }
+      t[n] = i;
+      return;
+    } else if (o && s === "object") {
+      const {
+        from: r = 0,
+        to: s = e.length - 1,
+        by: o = 1
+      } = i;
+      for (let i = r; i <= s; i += o) {
+        t[n] = i;
+        updatePath(e, t, n);
+      }
+      t[n] = i;
+      return;
+    } else if (n < t.length - 2) {
+      updatePath(e[i], t, n + 1);
+      return;
+    }
+    r = e[i];
+  }
+  let s = t[t.length - 1];
+  if (typeof s === "function") {
+    s = s(r);
+    if (s === r) return;
+  }
+  if (i === undefined && s == undefined) return;
+  if (s === DELETE) {
+    delete e[i];
+  } else if (i === undefined || isWrappable(r) && isWrappable(s) && !Array.isArray(s)) {
+    const t = i !== undefined ? e[i] : e;
+    const n = Object.keys(s);
+    for (let e = 0; e < n.length; e++) t[n[e]] = s[n[e]];
+  } else {
+    e[i] = s;
+  }
+}
+Object.assign(function storePath(...e) {
+  return t => {
+    updatePath(t, e);
+  };
+}, {
+  DELETE: DELETE
+});
 
 const effect = (fn, effectFn, initial) => createRenderEffect(fn, effectFn, initial, {
   transparent: true
 });
-const memo = fn => createMemo(() => fn());
+const memo = (fn, transparent) => transparent ? fn.$r ? fn : createMemo(() => fn(), undefined, {
+  transparent: true
+}) : createMemo$1(() => fn());
 
 function createRenderer({
   createElement,
@@ -193,7 +1359,7 @@ function createRenderer({
     Array.isArray(r) ? r.flat(Infinity).forEach(f => f && f(element)) : r(element);
   }
   function ref(fn, element) {
-    const resolved = untrack(fn);
+    const resolved = untrack$1(fn);
     runWithOwner(null, () => applyRef(resolved, element));
   }
   return {