@solidjs/signals 2.0.0-beta.8 → 2.0.0-rc.0

package/dist/prod.js

@@ -1,3577 +0,0 @@
-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;
-  }
-}
-class NoOwnerError extends Error {
-  constructor() {
-    super("");
-  }
-}
-class ContextNotFoundError extends Error {
-  constructor() {
-    super("");
-  }
-}
-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 NO_SNAPSHOT = {};
-const STORE_SNAPSHOT_PROPS = "sp";
-const SUPPORTS_PROXY = typeof Proxy === "function";
-const defaultContext = {};
-const $REFRESH = Symbol("refresh");
-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.h) {
-    markNode(t.p, REACTIVE_CHECK);
-  }
-  if (e.A !== null) {
-    for (let t = e.A; t !== null; t = t.N) {
-      for (let e = t.I; e !== null; e = e.h) {
-        markNode(e.p, REACTIVE_CHECK);
-      }
-    }
-  }
-}
-function runHeap(e, t) {
-  e._ = false;
-  for (e.P = 0; e.P <= e.R; e.P++) {
-    let n = e.l[e.P];
-    while (n !== undefined) {
-      if (n.O & REACTIVE_IN_HEAP) t(n);
-      else adjustHeight(n, e);
-      n = e.l[e.P];
-    }
-  }
-  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.m;
-    const i = e.V || 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.h) {
-      insertIntoHeapHeight(n.p, t);
-    }
-  }
-}
-const DEV$1 = undefined;
-const transitions = new Set();
-const dirtyQueue = { l: new Array(2e3).fill(undefined), _: false, P: 0, R: 0 };
-const zombieQueue = { l: new Array(2e3).fill(undefined), _: false, P: 0, R: 0 };
-let clock = 0;
-let activeTransition = null;
-let scheduled = false;
-let projectionWriteActive = false;
-let stashedOptimisticReads = null;
-const transientStoreNodes = new Set();
-function registerTransientStoreNode(e) {
-  transientStoreNodes.add(e);
-}
-function sweepTransientStoreNodes() {
-  if (transientStoreNodes.size === 0) return;
-  for (const e of transientStoreNodes) {
-    if (e.I !== null) {
-      transientStoreNodes.delete(e);
-      continue;
-    }
-    if (e.U !== NOT_PENDING) continue;
-    if (e.k !== undefined && e.k !== NOT_PENDING) continue;
-    transientStoreNodes.delete(e);
-    e.G?.();
-  }
-}
-function enforceLoadingBoundary(e) {}
-function shouldReadStashedOptimisticValue(e) {
-  return !!stashedOptimisticReads?.has(e);
-}
-function runLaneEffects(e) {
-  for (const t of activeLanes) {
-    if (t.W || t.H.size > 0) continue;
-    const n = t.M[e - 1];
-    if (n.length) {
-      t.M[e - 1] = [];
-      runQueue(n, e);
-    }
-  }
-}
-function queueStashedOptimisticEffects(e) {
-  for (let t = e.I; t !== null; t = t.h) {
-    const e = t.p;
-    if (!e.F) continue;
-    if (e.F === EFFECT_TRACKED) {
-      if (!e.j) {
-        e.j = true;
-        e.$.enqueue(EFFECT_USER, e.K);
-      }
-      continue;
-    }
-    const n = e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (n.P > e.o) n.P = e.o;
-    insertIntoHeap(e, n);
-  }
-}
-function setProjectionWriteActive(e) {
-  projectionWriteActive = e;
-}
-function mergeTransitionState(e, t) {
-  t.Y = e;
-  e.Z.push(...t.Z);
-  for (const n of activeLanes) if (n.B === t) n.B = e;
-  e.q.push(...t.q);
-  for (const n of t.X) e.X.add(n);
-  for (const [n, i] of t.J) {
-    let t = e.J.get(n);
-    if (!t) e.J.set(n, (t = new Set()));
-    for (const e of i) t.add(e);
-  }
-}
-function resolveOptimisticNodes(e) {
-  for (let t = 0; t < e.length; t++) {
-    const n = e[t];
-    n.ee = undefined;
-    if (n.U !== NOT_PENDING) {
-      n.te = n.U;
-      n.U = NOT_PENDING;
-    }
-    const i = n.k;
-    n.k = NOT_PENDING;
-    if (i !== NOT_PENDING && n.te !== i) insertSubs(n, true);
-    n.B = null;
-  }
-  e.length = 0;
-}
-function cleanupCompletedLanes(e) {
-  for (const t of activeLanes) {
-    const n = e ? t.B === e : !t.B;
-    if (!n) continue;
-    if (!t.W) {
-      if (t.M[0].length) runQueue(t.M[0], EFFECT_RENDER);
-      if (t.M[1].length) runQueue(t.M[1], EFFECT_USER);
-    }
-    if (t.ne.ee === t) t.ne.ee = undefined;
-    t.H.clear();
-    t.M[0].length = 0;
-    t.M[1].length = 0;
-    activeLanes.delete(t);
-    signalLanes.delete(t.ne);
-  }
-}
-function schedule() {
-  if (scheduled) return;
-  scheduled = true;
-  if (!globalQueue.ie && !projectionWriteActive) queueMicrotask(flush);
-}
-class Queue {
-  i = null;
-  re = [[], []];
-  se = [];
-  created = clock;
-  addChild(e) {
-    this.se.push(e);
-    e.i = this;
-  }
-  removeChild(e) {
-    const t = this.se.indexOf(e);
-    if (t >= 0) {
-      this.se.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.re[e - 1].length) {
-      const t = this.re[e - 1];
-      this.re[e - 1] = [];
-      runQueue(t, e);
-    }
-    for (let t = 0; t < this.se.length; t++) this.se[t].run?.(e);
-  }
-  enqueue(e, t) {
-    if (e) {
-      if (currentOptimisticLane) {
-        const n = findLane(currentOptimisticLane);
-        n.M[e - 1].push(t);
-      } else {
-        this.re[e - 1].push(t);
-      }
-    }
-    schedule();
-  }
-  stashQueues(e) {
-    e.re[0].push(...this.re[0]);
-    e.re[1].push(...this.re[1]);
-    this.re = [[], []];
-    for (let t = 0; t < this.se.length; t++) {
-      let n = this.se[t];
-      let i = e.se[t];
-      if (!i) {
-        i = { re: [[], []], se: [] };
-        e.se[t] = i;
-      }
-      n.stashQueues(i);
-    }
-  }
-  restoreQueues(e) {
-    this.re[0].push(...e.re[0]);
-    this.re[1].push(...e.re[1]);
-    for (let t = 0; t < e.se.length; t++) {
-      const n = e.se[t];
-      let i = this.se[t];
-      if (i) i.restoreQueues(n);
-    }
-  }
-}
-class GlobalQueue extends Queue {
-  ie = false;
-  oe = [];
-  q = [];
-  X = new Set();
-  static ue;
-  static ce;
-  static ae = null;
-  flush() {
-    if (this.ie) return;
-    this.ie = true;
-    try {
-      runHeap(dirtyQueue, GlobalQueue.ue);
-      if (activeTransition) {
-        const e = transitionComplete(activeTransition);
-        if (!e) {
-          const e = activeTransition;
-          runHeap(zombieQueue, GlobalQueue.ue);
-          this.oe = [];
-          this.q = [];
-          this.X = new Set();
-          runLaneEffects(EFFECT_RENDER);
-          runLaneEffects(EFFECT_USER);
-          this.stashQueues(e.le);
-          clock++;
-          scheduled = dirtyQueue.R >= dirtyQueue.P;
-          reassignPendingTransition(e.oe);
-          activeTransition = null;
-          if (!e.Z.length && e.q.length) {
-            stashedOptimisticReads = new Set();
-            for (let t = 0; t < e.q.length; t++) {
-              const n = e.q[t];
-              if (n.L || n.fe) continue;
-              stashedOptimisticReads.add(n);
-              queueStashedOptimisticEffects(n);
-            }
-          }
-          try {
-            finalizePureQueue(null, true);
-          } finally {
-            stashedOptimisticReads = null;
-          }
-          return;
-        }
-        this.oe !== activeTransition.oe && this.oe.push(...activeTransition.oe);
-        this.restoreQueues(activeTransition.le);
-        transitions.delete(activeTransition);
-        const t = activeTransition;
-        activeTransition = null;
-        reassignPendingTransition(this.oe);
-        finalizePureQueue(t);
-      } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue.ue);
-        finalizePureQueue();
-      }
-      clock++;
-      scheduled = dirtyQueue.R >= dirtyQueue.P;
-      runLaneEffects(EFFECT_RENDER);
-      this.run(EFFECT_RENDER);
-      runLaneEffects(EFFECT_USER);
-      this.run(EFFECT_USER);
-      if (false);
-    } finally {
-      this.ie = false;
-    }
-  }
-  notify(e, t, n, i) {
-    if (t & STATUS_PENDING) {
-      if (n & STATUS_PENDING) {
-        const t = i !== undefined ? i : e.Ee;
-        if (activeTransition && t) {
-          const n = t.source;
-          let i = activeTransition.J.get(n);
-          if (!i) activeTransition.J.set(n, (i = new Set()));
-          const r = i.size;
-          i.add(e);
-          if (i.size !== r) schedule();
-        }
-      }
-      return true;
-    }
-    return false;
-  }
-  initTransition(e) {
-    if (e) e = currentTransition(e);
-    if (e && e === activeTransition) return;
-    if (!e && activeTransition && activeTransition.de === clock) return;
-    if (!activeTransition) {
-      activeTransition = e ?? {
-        de: clock,
-        oe: [],
-        J: new Map(),
-        q: [],
-        X: new Set(),
-        Z: [],
-        le: { re: [[], []], se: [] },
-        Y: false
-      };
-    } else if (e) {
-      const t = activeTransition;
-      mergeTransitionState(e, t);
-      transitions.delete(t);
-      activeTransition = e;
-    }
-    transitions.add(activeTransition);
-    activeTransition.de = clock;
-    if (this.oe !== activeTransition.oe) {
-      for (let e = 0; e < this.oe.length; e++) {
-        const t = this.oe[e];
-        t.B = activeTransition;
-        activeTransition.oe.push(t);
-      }
-      this.oe = activeTransition.oe;
-    }
-    if (this.q !== activeTransition.q) {
-      for (let e = 0; e < this.q.length; e++) {
-        const t = this.q[e];
-        t.B = activeTransition;
-        activeTransition.q.push(t);
-      }
-      this.q = activeTransition.q;
-    }
-    for (const e of activeLanes) {
-      if (!e.B) e.B = activeTransition;
-    }
-    if (this.X !== activeTransition.X) {
-      for (const e of this.X) activeTransition.X.add(e);
-      this.X = activeTransition.X;
-    }
-  }
-}
-function insertSubs(e, t = false) {
-  const n = e.ee || currentOptimisticLane;
-  const i = e.Te !== undefined;
-  for (let r = e.I; r !== null; r = r.h) {
-    if (i && r.p.Se) {
-      r.p.O |= REACTIVE_SNAPSHOT_STALE;
-      continue;
-    }
-    if (t && n) {
-      r.p.O |= REACTIVE_OPTIMISTIC_DIRTY;
-      assignOrMergeLane(r.p, n);
-    } else if (t) {
-      r.p.O |= REACTIVE_OPTIMISTIC_DIRTY;
-      r.p.ee = undefined;
-    }
-    const e = r.p;
-    if (e.F === EFFECT_TRACKED) {
-      if (!e.j) {
-        e.j = true;
-        e.$.enqueue(EFFECT_USER, e.K);
-      }
-      continue;
-    }
-    const s = r.p.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (s.P > r.p.o) s.P = r.p.o;
-    insertIntoHeap(r.p, s);
-  }
-}
-function commitPendingNodes() {
-  const e = globalQueue.oe;
-  for (let t = 0; t < e.length; t++) {
-    const n = e[t];
-    if (n.U !== NOT_PENDING) {
-      n.te = n.U;
-      n.U = NOT_PENDING;
-      if (n.F && n.F !== EFFECT_TRACKED) n.j = true;
-    }
-    if (!(n.Re & STATUS_PENDING)) n.Re &= ~STATUS_UNINITIALIZED;
-    if (n.L) GlobalQueue.ce(n, false, true);
-  }
-  e.length = 0;
-}
-function finalizePureQueue(e = null, t = false) {
-  const n = !t;
-  if (n) commitPendingNodes();
-  if (!t) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.ue);
-  if (n) {
-    commitPendingNodes();
-    resolveOptimisticNodes(e ? e.q : globalQueue.q);
-    const t = e ? e.X : globalQueue.X;
-    if (GlobalQueue.ae && t.size) {
-      for (const e of t) {
-        GlobalQueue.ae(e);
-      }
-      t.clear();
-      schedule();
-    }
-    sweepTransientStoreNodes();
-    cleanupCompletedLanes(e);
-  }
-}
-function checkBoundaryChildren(e) {
-  for (const t of e.se) {
-    t.checkSources?.();
-    checkBoundaryChildren(t);
-  }
-}
-function trackOptimisticStore(e) {
-  globalQueue.X.add(e);
-  schedule();
-}
-function reassignPendingTransition(e) {
-  for (let t = 0; t < e.length; t++) {
-    e[t].B = activeTransition;
-  }
-}
-const globalQueue = new GlobalQueue();
-function flush() {
-  if (globalQueue.ie) {
-    return;
-  }
-  while (scheduled || activeTransition) {
-    globalQueue.flush();
-  }
-}
-function runQueue(e, t) {
-  for (let n = 0; n < e.length; n++) e[n](t);
-}
-function reporterBlocksSource(e, t) {
-  if (e.O & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-  if (e.Oe === t || e._e?.has(t)) return true;
-  for (let n = e.C; n; n = n.D) {
-    let e = n.m;
-    while (e) {
-      if (e === t || e.V === t) return true;
-      e = e.Ie;
-    }
-  }
-  return !!(e.Re & STATUS_PENDING && e.Ee instanceof NotReadyError && e.Ee.source === t);
-}
-function transitionComplete(e) {
-  if (e.Y) return true;
-  if (e.Z.length) return false;
-  let t = true;
-  for (const [n, i] of e.J) {
-    let r = false;
-    for (const e of i) {
-      if (reporterBlocksSource(e, n)) {
-        r = true;
-        break;
-      }
-      i.delete(e);
-    }
-    if (!r) e.J.delete(n);
-    else if (n.Re & STATUS_PENDING && n.Ee?.source === n) {
-      t = false;
-      break;
-    }
-  }
-  if (t) {
-    for (let n = 0; n < e.q.length; n++) {
-      const i = e.q[n];
-      if (
-        hasActiveOverride(i) &&
-        "Re" in i &&
-        i.Re & STATUS_PENDING &&
-        i.Ee instanceof NotReadyError &&
-        i.Ee.source !== i
-      ) {
-        t = false;
-        break;
-      }
-    }
-  }
-  t && (e.Y = true);
-  return t;
-}
-function currentTransition(e) {
-  while (e.Y && typeof e.Y === "object") e = e.Y;
-  return e;
-}
-function setActiveTransition(e) {
-  activeTransition = 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.Ie;
-  const i = n?.ee ? findLane(n.ee) : null;
-  t = { ne: e, H: new Set(), M: [[], []], W: null, B: activeTransition, he: i };
-  signalLanes.set(e, t);
-  activeLanes.add(t);
-  e.pe = false;
-  return t;
-}
-function findLane(e) {
-  while (e.W) e = e.W;
-  return e;
-}
-function mergeLanes(e, t) {
-  e = findLane(e);
-  t = findLane(t);
-  if (e === t) return e;
-  t.W = e;
-  for (const n of t.H) e.H.add(n);
-  e.M[0].push(...t.M[0]);
-  e.M[1].push(...t.M[1]);
-  return e;
-}
-function resolveLane(e) {
-  const t = e.ee;
-  if (!t) return undefined;
-  const n = findLane(t);
-  if (activeLanes.has(n)) return n;
-  e.ee = undefined;
-  return undefined;
-}
-function resolveTransition(e) {
-  return resolveLane(e)?.B ?? e.B;
-}
-function hasActiveOverride(e) {
-  return !!(e.k !== undefined && e.k !== NOT_PENDING);
-}
-function assignOrMergeLane(e, t) {
-  const n = findLane(t);
-  const i = e.ee;
-  if (i) {
-    if (i.W) {
-      e.ee = t;
-      return;
-    }
-    const r = findLane(i);
-    if (activeLanes.has(r)) {
-      if (r !== n && !hasActiveOverride(e)) {
-        if (n.he && findLane(n.he) === r) {
-          e.ee = t;
-        } else if (r.he && findLane(r.he) === n);
-        else mergeLanes(n, r);
-      }
-      return;
-    }
-  }
-  e.ee = t;
-}
-function unlinkSubs(e) {
-  const t = e.m;
-  const n = e.D;
-  const i = e.h;
-  const r = e.Ae;
-  if (i !== null) i.Ae = r;
-  else t.Ne = r;
-  if (r !== null) r.h = i;
-  else {
-    t.I = i;
-    if (i === null) {
-      t.G?.();
-      t.L && !t.Pe && !(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;
-  e.ge = null;
-  disposeChildren(e, true);
-}
-function link(e, t) {
-  const n = t.ge;
-  if (n !== null && n.m === 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.m === e) {
-      t.ge = i;
-      return;
-    }
-  }
-  const s = e.Ne;
-  if (s !== null && s.p === t && (!r || isValidLink(s, t))) return;
-  const o = (t.ge = e.Ne = { m: e, p: t, D: i, Ae: s, h: null });
-  if (n !== null) n.D = o;
-  else t.C = o;
-  if (s !== null) s.h = o;
-  else e.I = o;
-}
-function isValidLink(e, t) {
-  const n = t.ge;
-  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;
-}
-const PENDING_OWNER = {};
-function markDisposal(e) {
-  let t = e.Ce;
-  while (t) {
-    t.O |= REACTIVE_ZOMBIE;
-    if (t.O & REACTIVE_IN_HEAP) {
-      deleteFromHeap(t, dirtyQueue);
-      insertIntoHeap(t, zombieQueue);
-    }
-    markDisposal(t);
-    t = t.De;
-  }
-}
-function dispose(e) {
-  let t = e.C || null;
-  do {
-    t = unlinkSubs(t);
-  } while (t !== null);
-  e.C = null;
-  e.ge = null;
-  disposeChildren(e, true);
-}
-function disposeChildren(e, t = false, n) {
-  if (e.O & REACTIVE_DISPOSED) return;
-  if (t) e.O = REACTIVE_DISPOSED;
-  if (t && e.L) e.ye = null;
-  let i = n ? e.ve : e.Ce;
-  while (i) {
-    const e = i.De;
-    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.ge = null;
-    }
-    disposeChildren(i, true);
-    i = e;
-  }
-  if (n) {
-    e.ve = null;
-  } else {
-    e.Ce = null;
-    e.me = 0;
-  }
-  runDisposal(e, n);
-}
-function runDisposal(e, t) {
-  let n = t ? e.we : e.Ve;
-  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.we = null) : (e.Ve = null);
-}
-function childId(e, t) {
-  let n = e;
-  while (n.be && n.i) n = n.i;
-  if (n.id != null) return formatId(n.id, t ? n.me++ : n.me);
-  throw new Error("Cannot get child id from owner without an id");
-}
-function getNextChildId(e) {
-  return childId(e, true);
-}
-function peekNextChildId(e) {
-  return childId(e, false);
-}
-function formatId(e, t) {
-  const n = t.toString(36),
-    i = n.length - 1;
-  return e + (i ? String.fromCharCode(64 + i) : "") + n;
-}
-function getObserver() {
-  if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
-  return tracking ? context : null;
-}
-function getOwner() {
-  return context;
-}
-function cleanup(e) {
-  if (!context) return e;
-  if (!context.Ve) context.Ve = e;
-  else if (Array.isArray(context.Ve)) context.Ve.push(e);
-  else context.Ve = [context.Ve, e];
-  return e;
-}
-function isDisposed(e) {
-  return !!(e.O & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
-}
-function createOwner(e) {
-  const t = context;
-  const n = e?.transparent ?? false;
-  const i = {
-    id: e?.id ?? (n ? t?.id : t?.id != null ? getNextChildId(t) : undefined),
-    be: n || undefined,
-    t: true,
-    u: t?.t ? t.u : t,
-    Ce: null,
-    De: null,
-    Ve: null,
-    $: t?.$ ?? globalQueue,
-    Le: t?.Le || defaultContext,
-    me: 0,
-    we: null,
-    ve: null,
-    i: t,
-    dispose(e = true) {
-      disposeChildren(i, e);
-    }
-  };
-  if (t) {
-    const e = t.Ce;
-    if (e === null) {
-      t.Ce = i;
-    } else {
-      i.De = e;
-      t.Ce = i;
-    }
-  }
-  return i;
-}
-function createRoot(e, t) {
-  const n = createOwner(t);
-  return runWithOwner(n, () => e(n.dispose));
-}
-function addPendingSource(e, t) {
-  if (e.Oe === t || e._e?.has(t)) return false;
-  if (!e.Oe) {
-    e.Oe = t;
-    return true;
-  }
-  if (!e._e) {
-    e._e = new Set([e.Oe, t]);
-  } else {
-    e._e.add(t);
-  }
-  e.Oe = undefined;
-  return true;
-}
-function removePendingSource(e, t) {
-  if (e.Oe) {
-    if (e.Oe !== t) return false;
-    e.Oe = undefined;
-    return true;
-  }
-  if (!e._e?.delete(t)) return false;
-  if (e._e.size === 1) {
-    e.Oe = e._e.values().next().value;
-    e._e = undefined;
-  } else if (e._e.size === 0) {
-    e._e = undefined;
-  }
-  return true;
-}
-function clearPendingSources(e) {
-  e.Oe = undefined;
-  e._e?.clear();
-  e._e = undefined;
-}
-function setPendingError(e, t, n) {
-  if (!t) {
-    e.Ee = null;
-    return;
-  }
-  if (n instanceof NotReadyError && n.source === t) {
-    e.Ee = n;
-    return;
-  }
-  const i = e.Ee;
-  if (!(i instanceof NotReadyError) || i.source !== t) {
-    e.Ee = new NotReadyError(t);
-  }
-}
-function forEachDependent(e, t) {
-  for (let n = e.I; n !== null; n = n.h) t(n.p);
-  for (let n = e.A; n !== null; n = n.N) {
-    for (let e = n.I; e !== null; e = e.h) t(e.p);
-  }
-}
-function settlePendingSource(e) {
-  let t = false;
-  const n = new Set();
-  const settle = i => {
-    if (n.has(i) || !removePendingSource(i, e)) return;
-    n.add(i);
-    i.de = clock;
-    const r = i.Oe ?? i._e?.values().next().value;
-    if (r) {
-      setPendingError(i, r);
-      updatePendingSignal(i);
-    } else {
-      i.Re &= ~STATUS_PENDING;
-      setPendingError(i);
-      updatePendingSignal(i);
-      if (i.Ue) {
-        if (i.F === EFFECT_TRACKED) {
-          const e = i;
-          if (!e.j) {
-            e.j = true;
-            e.$.enqueue(EFFECT_USER, e.K);
-          }
-        } else {
-          const e = i.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-          if (e.P > i.o) e.P = i.o;
-          insertIntoHeap(i, e);
-        }
-        t = true;
-      }
-      i.Ue = false;
-    }
-    forEachDependent(i, settle);
-  };
-  forEachDependent(e, settle);
-  if (t) schedule();
-}
-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.ye = null;
-    return t;
-  }
-  e.ye = t;
-  let o;
-  const handleError = n => {
-    if (e.ye !== t) return;
-    globalQueue.initTransition(resolveTransition(e));
-    notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-    e.de = clock;
-  };
-  const asyncWrite = (i, r) => {
-    if (e.ye !== t) return;
-    if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(resolveTransition(e));
-    const s = !!(e.Re & STATUS_UNINITIALIZED);
-    clearStatus(e);
-    const o = resolveLane(e);
-    if (o) o.H.delete(e);
-    if (n) n(i);
-    else if (e.k !== undefined) {
-      if (e.k !== undefined && e.k !== NOT_PENDING) e.U = i;
-      else {
-        e.te = i;
-        insertSubs(e);
-      }
-      e.de = clock;
-    } else if (o) {
-      const t = e.F;
-      const n = e.te;
-      const r = e.ke;
-      if ((!t && s) || !r || !r(i, n)) {
-        e.te = i;
-        e.de = clock;
-        if (e.Ge) {
-          setSignal(e.Ge, i);
-        }
-        insertSubs(e, true);
-      }
-    } else {
-      setSignal(e, () => i);
-    }
-    settlePendingSource(e);
-    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(resolveTransition(e));
-      throw new NotReadyError(context);
-    }
-  }
-  if (r) {
-    const n = t[Symbol.asyncIterator]();
-    let i = false;
-    let r = false;
-    cleanup(() => {
-      if (r) return;
-      r = true;
-      try {
-        const e = n.return?.();
-        if (e && typeof e.then === "function") {
-          e.then(undefined, () => {});
-        }
-      } catch {}
-    });
-    const iterate = () => {
-      let s,
-        u = false,
-        c = true;
-      n.next().then(
-        n => {
-          if (c) {
-            s = n;
-            u = true;
-            if (n.done) r = true;
-          } else if (e.ye !== t) {
-            return;
-          } else if (!n.done) asyncWrite(n.value, iterate);
-          else {
-            r = true;
-            schedule();
-            flush();
-          }
-        },
-        n => {
-          if (!c && e.ye === t) {
-            r = true;
-            handleError(n);
-          }
-        }
-      );
-      c = false;
-      if (u && !s.done) {
-        o = s.value;
-        i = true;
-        return iterate();
-      }
-      return u && s.done;
-    };
-    const s = iterate();
-    if (!i && !s) {
-      globalQueue.initTransition(resolveTransition(e));
-      throw new NotReadyError(context);
-    }
-  }
-  return o;
-}
-function clearStatus(e, t = false) {
-  clearPendingSources(e);
-  e.Ue = false;
-  e.Re = t ? 0 : e.Re & STATUS_UNINITIALIZED;
-  setPendingError(e);
-  updatePendingSignal(e);
-  e.xe?.();
-}
-function notifyStatus(e, t, n, i, r) {
-  if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError))
-    n = new StatusError(e, n);
-  const s = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
-  const o = s === e;
-  const u = t === STATUS_PENDING && e.k !== undefined && !o;
-  const c = u && hasActiveOverride(e);
-  if (!i) {
-    if (t === STATUS_PENDING && s) {
-      addPendingSource(e, s);
-      e.Re = STATUS_PENDING | (e.Re & STATUS_UNINITIALIZED);
-      setPendingError(e, s, n);
-    } else {
-      clearPendingSources(e);
-      e.Re = t | (t !== STATUS_ERROR ? e.Re & STATUS_UNINITIALIZED : 0);
-      e.Ee = n;
-    }
-    updatePendingSignal(e);
-  }
-  if (r && !i) {
-    assignOrMergeLane(e, r);
-  }
-  const a = i || c;
-  const l = i || u ? undefined : r;
-  if (e.xe) {
-    if (i && t === STATUS_PENDING) {
-      return;
-    }
-    if (a) {
-      e.xe(t, n);
-    } else {
-      e.xe();
-    }
-    return;
-  }
-  forEachDependent(e, e => {
-    e.de = clock;
-    if (
-      (t === STATUS_PENDING && s && e.Oe !== s && !e._e?.has(s)) ||
-      (t !== STATUS_PENDING && (e.Ee !== n || e.Oe || e._e))
-    ) {
-      if (!a && !e.B) globalQueue.oe.push(e);
-      notifyStatus(e, t, n, a, l);
-    }
-  });
-}
-let externalSourceConfig = null;
-function enableExternalSource(e) {
-  const { factory: t, untrack: n = e => e() } = e;
-  if (externalSourceConfig) {
-    const { factory: e, untrack: i } = externalSourceConfig;
-    externalSourceConfig = {
-      factory: (n, i) => {
-        const r = e(n, i);
-        const s = t(e => r.track(e), i);
-        return {
-          track: e => s.track(e),
-          dispose() {
-            s.dispose();
-            r.dispose();
-          }
-        };
-      },
-      untrack: e => i(() => n(e))
-    };
-  } else {
-    externalSourceConfig = { factory: t, untrack: n };
-  }
-}
-GlobalQueue.ue = recompute;
-GlobalQueue.ce = disposeChildren;
-let tracking = false;
-let stale = false;
-let refreshing = false;
-let pendingCheckActive = false;
-let foundPending = false;
-let latestReadActive = false;
-let context = null;
-let currentOptimisticLane = null;
-let snapshotCaptureActive = false;
-let snapshotSources = null;
-function ownerInSnapshotScope(e) {
-  while (e) {
-    if (e.We) return true;
-    e = e.i;
-  }
-  return false;
-}
-function setSnapshotCapture(e) {
-  snapshotCaptureActive = e;
-  if (e && !snapshotSources) snapshotSources = new Set();
-}
-function markSnapshotScope(e) {
-  e.We = true;
-}
-function releaseSnapshotScope(e) {
-  e.We = false;
-  releaseSubtree(e);
-  schedule();
-}
-function releaseSubtree(e) {
-  let t = e.Ce;
-  while (t) {
-    if (t.We) {
-      t = t.De;
-      continue;
-    }
-    if (t.L) {
-      const e = t;
-      e.Se = false;
-      if (e.O & REACTIVE_SNAPSHOT_STALE) {
-        e.O &= ~REACTIVE_SNAPSHOT_STALE;
-        e.O |= REACTIVE_DIRTY;
-        if (dirtyQueue.P > e.o) dirtyQueue.P = e.o;
-        insertIntoHeap(e, dirtyQueue);
-      }
-    }
-    releaseSubtree(t);
-    t = t.De;
-  }
-}
-function clearSnapshots() {
-  if (snapshotSources) {
-    for (const e of snapshotSources) {
-      delete e.Te;
-      delete e[STORE_SNAPSHOT_PROPS];
-    }
-    snapshotSources = null;
-  }
-  snapshotCaptureActive = false;
-}
-function recompute(e, t = false) {
-  const n = e.F;
-  if (!t) {
-    if (e.B && (!n || activeTransition) && activeTransition !== e.B)
-      globalQueue.initTransition(e.B);
-    deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    e.ye = null;
-    if (e.B || n === EFFECT_TRACKED) disposeChildren(e);
-    else {
-      markDisposal(e);
-      e.we = e.Ve;
-      e.ve = e.Ce;
-      e.Ve = null;
-      e.Ce = null;
-      e.me = 0;
-    }
-  }
-  const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
-  const r = e.k !== undefined && e.k !== NOT_PENDING;
-  const s = !!(e.Re & STATUS_PENDING);
-  const o = !!(e.Re & STATUS_UNINITIALIZED);
-  const u = context;
-  context = e;
-  e.ge = null;
-  e.O = REACTIVE_RECOMPUTING_DEPS;
-  e.de = clock;
-  let c = e.U === NOT_PENDING ? e.te : e.U;
-  let a = e.o;
-  let l = tracking;
-  let f = currentOptimisticLane;
-  tracking = true;
-  if (i) {
-    const t = resolveLane(e);
-    if (t) currentOptimisticLane = t;
-  }
-  try {
-    const n = e.ye;
-    const i = e.L(c);
-    c = e.ye !== n ? i : handleAsync(e, i);
-    clearStatus(e, t);
-    const r = resolveLane(e);
-    if (r) {
-      r.H.delete(e);
-      updatePendingSignal(r.ne);
-    }
-  } catch (t) {
-    if (t instanceof NotReadyError && currentOptimisticLane) {
-      const t = findLane(currentOptimisticLane);
-      if (t.ne !== e) {
-        t.H.add(e);
-        e.ee = t;
-        updatePendingSignal(t.ne);
-      }
-    }
-    if (t instanceof NotReadyError) e.Ue = true;
-    notifyStatus(
-      e,
-      t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
-      t,
-      undefined,
-      t instanceof NotReadyError ? e.ee : undefined
-    );
-  } finally {
-    tracking = l;
-    e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
-    context = u;
-  }
-  if (!e.Ee) {
-    const u = e.ge;
-    let l = u !== null ? u.D : e.C;
-    if (l !== null) {
-      do {
-        l = unlinkSubs(l);
-      } while (l !== null);
-      if (u !== null) u.D = null;
-      else e.C = null;
-    }
-    const f = r ? e.k : e.U === NOT_PENDING ? e.te : e.U;
-    const E = (!n && o) || !e.ke || !e.ke(f, c);
-    if (E) {
-      const o = r ? e.k : undefined;
-      if (t || (n && activeTransition !== e.B) || i) {
-        e.te = c;
-        if (r && i) {
-          e.k = c;
-          e.U = c;
-        }
-      } else e.U = c;
-      if (r && !i && s && !e.pe) e.k = c;
-      if (!r || i || e.k !== o) insertSubs(e, i || r);
-    } else if (r) {
-      e.U = c;
-    } else if (e.o != a) {
-      for (let t = e.I; t !== null; t = t.h) {
-        insertIntoHeapHeight(t.p, t.p.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      }
-    }
-  }
-  currentOptimisticLane = f;
-  (!t || e.Re & STATUS_PENDING) && !e.B && !(activeTransition && r) && globalQueue.oe.push(e);
-  e.B && n && activeTransition !== e.B && runInTransition(e.B, () => recompute(e));
-}
-function updateIfNecessary(e) {
-  if (e.O & REACTIVE_CHECK) {
-    for (let t = e.C; t; t = t.D) {
-      const n = t.m;
-      const i = n.V || n;
-      if (i.L) {
-        updateIfNecessary(i);
-      }
-      if (e.O & REACTIVE_DIRTY) {
-        break;
-      }
-    }
-  }
-  if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (e.Ee && e.de < clock && !e.ye)) {
-    recompute(e);
-  }
-  e.O = e.O & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
-}
-function computed(e, t) {
-  const n = t?.transparent ?? false;
-  const i = {
-    id: t?.id ?? (n ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
-    be: n || undefined,
-    ke: t?.equals != null ? t.equals : isEqual,
-    fe: !!t?.ownedWrite,
-    G: t?.unobserved,
-    Ve: null,
-    $: context?.$ ?? globalQueue,
-    Le: context?.Le ?? defaultContext,
-    me: 0,
-    L: e,
-    te: undefined,
-    o: 0,
-    A: null,
-    S: undefined,
-    T: null,
-    C: null,
-    ge: null,
-    I: null,
-    Ne: null,
-    i: context,
-    De: null,
-    Ce: null,
-    O: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-    Re: STATUS_UNINITIALIZED,
-    de: clock,
-    U: NOT_PENDING,
-    we: null,
-    ve: null,
-    ye: null,
-    B: null
-  };
-  i.T = i;
-  const r = context?.t ? context.u : context;
-  if (context) {
-    const e = context.Ce;
-    if (e === null) {
-      context.Ce = i;
-    } else {
-      i.De = e;
-      context.Ce = i;
-    }
-  }
-  if (r) i.o = r.o + 1;
-  if (snapshotCaptureActive && ownerInSnapshotScope(context)) i.Se = true;
-  if (externalSourceConfig) {
-    const e = signal(undefined, { equals: false, ownedWrite: true });
-    const t = externalSourceConfig.factory(i.L, () => {
-      setSignal(e, undefined);
-    });
-    cleanup(() => t.dispose());
-    i.L = n => {
-      read(e);
-      return t.track(n);
-    };
-  }
-  !t?.lazy && recompute(i, true);
-  if (snapshotCaptureActive && !t?.lazy) {
-    if (!(i.Re & STATUS_PENDING)) {
-      i.Te = i.te === undefined ? NO_SNAPSHOT : i.te;
-      snapshotSources.add(i);
-    }
-  }
-  return i;
-}
-function signal(e, t, n = null) {
-  const i = {
-    ke: t?.equals != null ? t.equals : isEqual,
-    fe: !!t?.ownedWrite,
-    He: !!t?.He,
-    G: t?.unobserved,
-    te: e,
-    I: null,
-    Ne: null,
-    de: clock,
-    V: n,
-    N: n?.A || null,
-    U: NOT_PENDING
-  };
-  n && (n.A = i);
-  if (snapshotCaptureActive && !i.He && !((n?.Re ?? 0) & STATUS_PENDING)) {
-    i.Te = e === undefined ? NO_SNAPSHOT : e;
-    snapshotSources.add(i);
-  }
-  return i;
-}
-function optimisticSignal(e, t) {
-  const n = signal(e, t);
-  n.k = NOT_PENDING;
-  return n;
-}
-function optimisticComputed(e, t) {
-  const n = computed(e, t);
-  n.k = NOT_PENDING;
-  return n;
-}
-function isEqual(e, t) {
-  return e === t;
-}
-function untrack(e, t) {
-  if (!externalSourceConfig && !tracking && true) return e();
-  const n = tracking;
-  tracking = false;
-  try {
-    if (externalSourceConfig) return externalSourceConfig.untrack(e);
-    return e();
-  } finally {
-    tracking = n;
-  }
-}
-function read(e) {
-  if (latestReadActive) {
-    const t = getLatestValueComputed(e);
-    const n = latestReadActive;
-    latestReadActive = false;
-    const i = e.k !== undefined && e.k !== NOT_PENDING ? e.k : e.te;
-    let r;
-    try {
-      r = read(t);
-    } catch (e) {
-      if (!context && e instanceof NotReadyError) return i;
-      throw e;
-    } finally {
-      latestReadActive = n;
-    }
-    if (t.Re & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.ee) {
-      const e = findLane(t.ee);
-      const n = findLane(currentOptimisticLane);
-      if (e !== n && e.H.size > 0) {
-        return i;
-      }
-    }
-    return r;
-  }
-  if (pendingCheckActive) {
-    const t = e.V;
-    const n = pendingCheckActive;
-    pendingCheckActive = false;
-    if (t && e.k !== undefined) {
-      if (e.k !== NOT_PENDING && (t.ye || !!(t.Re & STATUS_PENDING))) {
-        foundPending = true;
-      }
-      let n = context;
-      if (n?.t) n = n.u;
-      if (n && tracking) link(e, n);
-      read(getPendingSignal(e));
-      read(getPendingSignal(t));
-    } else {
-      if (read(getPendingSignal(e))) foundPending = true;
-      if (t && read(getPendingSignal(t))) foundPending = true;
-    }
-    pendingCheckActive = n;
-    return e.te;
-  }
-  let t = context;
-  if (t?.t) t = t.u;
-  const n = e;
-  if (typeof n.L === "function") {
-    const t = e;
-    if (refreshing && !(t.O & REACTIVE_DISPOSED)) recompute(t);
-    if (t.O & REACTIVE_LAZY) {
-      t.O &= ~REACTIVE_LAZY;
-      recompute(t, true);
-    } else if (t.O & REACTIVE_DISPOSED) {
-      recompute(t, true);
-    }
-  }
-  const i = e.V || e;
-  if (t && tracking) {
-    link(e, t);
-    if (i.L) {
-      const n = e.O & REACTIVE_ZOMBIE;
-      if (i.o >= (n ? zombieQueue.P : dirtyQueue.P)) {
-        markNode(t);
-        markHeap(n ? zombieQueue : dirtyQueue);
-        updateIfNecessary(i);
-      }
-      const r = i.o;
-      if (r >= t.o && e.i !== t) {
-        t.o = r + 1;
-      }
-    }
-  }
-  if (i.Re & STATUS_PENDING) {
-    if (t && !(stale && i.B && activeTransition !== i.B)) {
-      if (currentOptimisticLane) {
-        const n = i.ee;
-        const r = findLane(currentOptimisticLane);
-        if (n && findLane(n) === r && !hasActiveOverride(i)) {
-          if (!tracking && e !== t) link(e, t);
-          throw i.Ee;
-        }
-      } else {
-        if (!tracking && e !== t) link(e, t);
-        throw i.Ee;
-      }
-    } else if (t && i !== e && i.Re & STATUS_UNINITIALIZED) {
-      if (!tracking && e !== t) link(e, t);
-      throw i.Ee;
-    } else if (!t && i.Re & STATUS_UNINITIALIZED) {
-      throw i.Ee;
-    }
-  }
-  if (e.L && e.Re & STATUS_ERROR) {
-    if (e.de < clock) {
-      recompute(e);
-      return read(e);
-    } else throw e.Ee;
-  }
-  if (snapshotCaptureActive && t && t.Se) {
-    const n = e.Te;
-    if (n !== undefined) {
-      const i = n === NO_SNAPSHOT ? undefined : n;
-      const r = e.U !== NOT_PENDING ? e.U : e.te;
-      if (r !== i) t.O |= REACTIVE_SNAPSHOT_STALE;
-      return i;
-    }
-  }
-  if (e.k !== undefined && e.k !== NOT_PENDING) {
-    if (t && stale && shouldReadStashedOptimisticValue(e)) return e.te;
-    return e.k;
-  }
-  const r =
-    !t ||
-    (currentOptimisticLane !== null &&
-      (e.k !== undefined || e.ee || (i === e && stale) || !!(i.Re & STATUS_PENDING))) ||
-    e.U === NOT_PENDING ||
-    (stale && e.B && activeTransition !== e.B)
-      ? e.te
-      : e.U;
-  if (
-    !t &&
-    i === e &&
-    typeof n.L === "function" &&
-    !n.Pe &&
-    !(i.Re & STATUS_PENDING) &&
-    !n.i &&
-    !e.I
-  ) {
-    unobserved(e);
-  }
-  return r;
-}
-function setSignal(e, t) {
-  if (e.B && activeTransition !== e.B) globalQueue.initTransition(e.B);
-  const n = e.k !== undefined && !projectionWriteActive;
-  const i = e.k !== undefined && e.k !== NOT_PENDING;
-  const r = n ? (i ? e.k : e.te) : e.U === NOT_PENDING ? e.te : e.U;
-  if (typeof t === "function") t = t(r);
-  const s = !e.ke || !e.ke(r, t) || !!(e.Re & STATUS_UNINITIALIZED);
-  if (!s) {
-    if (n && i && e.L) {
-      insertSubs(e, true);
-      schedule();
-    }
-    return t;
-  }
-  if (n) {
-    const n = e.k === NOT_PENDING;
-    if (!n) globalQueue.initTransition(resolveTransition(e));
-    if (n) {
-      e.U = e.te;
-      globalQueue.q.push(e);
-    }
-    e.pe = true;
-    const i = getOrCreateLane(e);
-    e.ee = i;
-    e.k = t;
-  } else {
-    if (e.U === NOT_PENDING) globalQueue.oe.push(e);
-    e.U = t;
-  }
-  updatePendingSignal(e);
-  if (e.Ge) {
-    setSignal(e.Ge, t);
-  }
-  e.de = clock;
-  insertSubs(e, n);
-  schedule();
-  return t;
-}
-function runWithOwner(e, t) {
-  const n = context;
-  const i = tracking;
-  context = e;
-  tracking = false;
-  try {
-    return t();
-  } finally {
-    context = n;
-    tracking = i;
-  }
-}
-function getPendingSignal(e) {
-  if (!e.Me) {
-    e.Me = optimisticSignal(false, { ownedWrite: true });
-    if (e.Ie) {
-      e.Me.Ie = e;
-    }
-    if (computePendingState(e)) setSignal(e.Me, true);
-  }
-  return e.Me;
-}
-function computePendingState(e) {
-  const t = e;
-  const n = e.V;
-  if (n && e.U !== NOT_PENDING) {
-    return !n.ye && !(n.Re & STATUS_PENDING);
-  }
-  if (e.k !== undefined && e.k !== NOT_PENDING) {
-    if (t.Re & STATUS_PENDING && !(t.Re & STATUS_UNINITIALIZED)) return true;
-    if (e.Ie) {
-      const t = e.ee ? findLane(e.ee) : null;
-      return !!(t && t.H.size > 0);
-    }
-    return true;
-  }
-  if (e.k !== undefined && e.k === NOT_PENDING && !e.Ie) {
-    return false;
-  }
-  if (e.U !== NOT_PENDING && !(t.Re & STATUS_UNINITIALIZED)) return true;
-  return !!(t.Re & STATUS_PENDING && !(t.Re & STATUS_UNINITIALIZED));
-}
-function updatePendingSignal(e) {
-  if (e.Me) {
-    const t = computePendingState(e);
-    const n = e.Me;
-    setSignal(n, t);
-    if (!t && n.ee) {
-      const t = resolveLane(e);
-      if (t && t.H.size > 0) {
-        const e = findLane(n.ee);
-        if (e !== t) {
-          mergeLanes(t, e);
-        }
-      }
-      signalLanes.delete(n);
-      n.ee = undefined;
-    }
-  }
-}
-function getLatestValueComputed(e) {
-  if (!e.Ge) {
-    const t = latestReadActive;
-    latestReadActive = false;
-    const n = pendingCheckActive;
-    pendingCheckActive = false;
-    const i = context;
-    context = null;
-    e.Ge = optimisticComputed(() => read(e));
-    e.Ge.Ie = e;
-    context = i;
-    pendingCheckActive = n;
-    latestReadActive = t;
-  }
-  return e.Ge;
-}
-function staleValues(e, t = true) {
-  const n = stale;
-  stale = t;
-  try {
-    return e();
-  } finally {
-    stale = n;
-  }
-}
-function latest(e) {
-  const t = latestReadActive;
-  latestReadActive = true;
-  try {
-    return e();
-  } finally {
-    latestReadActive = t;
-  }
-}
-function isPending(e) {
-  const t = pendingCheckActive;
-  const n = foundPending;
-  pendingCheckActive = true;
-  foundPending = false;
-  try {
-    e();
-    return foundPending;
-  } catch {
-    return foundPending;
-  } finally {
-    pendingCheckActive = t;
-    foundPending = n;
-  }
-}
-function refresh(e) {
-  let t = refreshing;
-  refreshing = true;
-  try {
-    if (typeof e !== "function") {
-      recompute(e[$REFRESH]);
-      return e;
-    }
-    return untrack(e);
-  } finally {
-    refreshing = t;
-    if (!t) {
-      schedule();
-    }
-  }
-}
-function isRefreshing() {
-  return refreshing;
-}
-function createContext(e, t) {
-  return { id: Symbol(t), defaultValue: e };
-}
-function getContext(e, t = getOwner()) {
-  if (!t) {
-    throw new NoOwnerError();
-  }
-  const n = hasContext(e, t) ? t.Le[e.id] : e.defaultValue;
-  if (isUndefined(n)) {
-    throw new ContextNotFoundError();
-  }
-  return n;
-}
-function setContext(e, t, n = getOwner()) {
-  if (!n) {
-    throw new NoOwnerError();
-  }
-  n.Le = { ...n.Le, [e.id]: isUndefined(t) ? e.defaultValue : t };
-}
-function hasContext(e, t) {
-  return !isUndefined(t?.Le[e.id]);
-}
-function isUndefined(e) {
-  return typeof e === "undefined";
-}
-function effect(e, t, n, i) {
-  let r = false;
-  const s = !!i?.user;
-  const o = computed(s ? e : t => staleValues(() => e(t)), {
-    ...i,
-    equals: () => {
-      o.j = !o.Ee;
-      if (r) o.$.enqueue(o.F, runEffect.bind(o));
-      return false;
-    },
-    lazy: true
-  });
-  o.Qe = undefined;
-  o.Fe = t;
-  o.je = n;
-  o.$e = undefined;
-  o.F = s ? EFFECT_USER : EFFECT_RENDER;
-  o.xe = (e, t) => {
-    const n = e !== undefined ? e : o.Re;
-    const i = t !== undefined ? t : o.Ee;
-    if (n & STATUS_ERROR) {
-      let e = i;
-      o.$.notify(o, STATUS_PENDING, 0);
-      if (o.F === EFFECT_USER) {
-        try {
-          return o.je
-            ? o.je(e, () => {
-                o.$e?.();
-                o.$e = undefined;
-              })
-            : console.error(e);
-        } catch (t) {
-          e = t;
-        }
-      }
-      if (!o.$.notify(o, STATUS_ERROR, STATUS_ERROR)) throw e;
-    } else if (o.F === EFFECT_RENDER) {
-      o.$.notify(o, STATUS_PENDING | STATUS_ERROR, n, i);
-    }
-  };
-  recompute(o, true);
-  !i?.defer &&
-    (o.F === EFFECT_USER || i?.schedule ? o.$.enqueue(o.F, runEffect.bind(o)) : runEffect.call(o));
-  r = true;
-  cleanup(() => o.$e?.());
-}
-function runEffect() {
-  if (!this.j || this.O & REACTIVE_DISPOSED) return;
-  this.$e?.();
-  this.$e = undefined;
-  try {
-    const e = this.Fe(this.te, this.Qe);
-    if (false && e !== undefined && typeof e !== "function");
-    this.$e = e;
-  } catch (e) {
-    this.Ee = new StatusError(this, e);
-    this.Re |= STATUS_ERROR;
-    if (!this.$.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
-  } finally {
-    this.Qe = this.te;
-    this.j = false;
-  }
-}
-function trackedEffect(e, t) {
-  const run = () => {
-    if (!n.j || n.O & REACTIVE_DISPOSED) return;
-    try {
-      n.j = false;
-      recompute(n);
-    } finally {
-    }
-  };
-  const n = computed(
-    () => {
-      n.$e?.();
-      n.$e = undefined;
-      const t = staleValues(e);
-      n.$e = t;
-    },
-    { ...t, lazy: true }
-  );
-  n.$e = undefined;
-  n.Ke = true;
-  n.j = true;
-  n.F = EFFECT_TRACKED;
-  n.xe = (e, t) => {
-    const i = e !== undefined ? e : n.Re;
-    if (i & STATUS_ERROR) {
-      n.$.notify(n, STATUS_PENDING, 0);
-      const e = t !== undefined ? t : n.Ee;
-      if (!n.$.notify(n, STATUS_ERROR, STATUS_ERROR)) throw e;
-    }
-  };
-  n.K = run;
-  n.$.enqueue(EFFECT_USER, run);
-  cleanup(() => n.$e?.());
-}
-function restoreTransition(e, t) {
-  globalQueue.initTransition(e);
-  const n = t();
-  flush();
-  return n;
-}
-function action(e) {
-  return (...t) =>
-    new Promise((n, i) => {
-      const r = e(...t);
-      globalQueue.initTransition();
-      let s = activeTransition;
-      s.Z.push(r);
-      const done = (e, t) => {
-        s = currentTransition(s);
-        const o = s.Z.indexOf(r);
-        if (o >= 0) s.Z.splice(o, 1);
-        setActiveTransition(s);
-        schedule();
-        t ? i(t) : n(e);
-      };
-      const step = (e, t) => {
-        let n;
-        try {
-          n = t ? r.throw(e) : r.next(e);
-        } catch (e) {
-          return done(undefined, e);
-        }
-        if (n instanceof Promise)
-          return void n.then(run, e => restoreTransition(s, () => step(e, true)));
-        run(n);
-      };
-      const run = e => {
-        if (e.done) return done(e.value);
-        if (e.value instanceof Promise)
-          return void e.value.then(
-            e => restoreTransition(s, () => step(e)),
-            e => restoreTransition(s, () => step(e, true))
-          );
-        restoreTransition(s, () => step(e.value));
-      };
-      step();
-    });
-}
-function onCleanup(e) {
-  return cleanup(e);
-}
-function accessor(e) {
-  const t = read.bind(null, e);
-  t.$r = true;
-  return t;
-}
-function createSignal(e, t) {
-  if (typeof e === "function") {
-    const n = computed(e, t);
-    n.Pe = true;
-    return [accessor(n), setSignal.bind(null, n)];
-  }
-  const n = signal(e, t);
-  return [accessor(n), setSignal.bind(null, n)];
-}
-function createMemo(e, t) {
-  let n = computed(e, t);
-  return accessor(n);
-}
-function createEffect(e, t, n) {
-  effect(e, t.effect || t, t.error, { user: true, ...n });
-}
-function createRenderEffect(e, t, n) {
-  effect(e, t, undefined, n);
-}
-function createTrackedEffect(e, t) {
-  trackedEffect(e, t);
-}
-function createReaction(e, t) {
-  let n = undefined;
-  cleanup(() => n?.());
-  const i = getOwner();
-  return r => {
-    runWithOwner(i, () => {
-      effect(
-        () => (r(), getOwner()),
-        t => {
-          n?.();
-          const i = (e.effect || e)?.();
-          if (false && i !== undefined && typeof i !== "function");
-          n = i;
-          dispose(t);
-        },
-        e.error,
-        { ...(false ? { ...t, name: t?.name ?? "effect" } : t), user: true, defer: true }
-      );
-    });
-  };
-}
-function resolve(e) {
-  return new Promise((t, n) => {
-    createRoot(i => {
-      computed(() => {
-        try {
-          t(e());
-        } catch (e) {
-          if (e instanceof NotReadyError) throw e;
-          n(e);
-        }
-        i();
-      });
-    });
-  });
-}
-function createOptimistic(e, t) {
-  if (typeof e === "function") {
-    const n = optimisticComputed(e, t);
-    n.Pe = true;
-    return [accessor(n), setSignal.bind(null, n)];
-  }
-  const n = optimisticSignal(e, t);
-  return [accessor(n), setSignal.bind(null, n)];
-}
-function onSettled(e) {
-  const t = getOwner();
-  t && !t.Ke
-    ? createTrackedEffect(() => untrack(e), undefined)
-    : globalQueue.enqueue(EFFECT_USER, () => {
-        const t = e();
-        t?.();
-      });
-}
-function unwrap(e) {
-  return e?.[$TARGET]?.[STORE_NODE] ?? e;
-}
-function getOverrideValue(e, t, n, i, r) {
-  if (r && i in r) return r[i];
-  return t && i in t ? t[i] : e[i];
-}
-function getAllKeys(e, t, n) {
-  const i = getKeys(e, t);
-  const r = Object.keys(n);
-  return Array.from(new Set([...i, ...r]));
-}
-function applyState(e, t, n) {
-  const i = t?.[$TARGET];
-  if (!i) return;
-  const r = i[STORE_VALUE];
-  const s = i[STORE_OVERRIDE];
-  const o = i[STORE_OPTIMISTIC_OVERRIDE];
-  let u = i[STORE_NODE];
-  if (e === r && !s && !o) return;
-  (i[STORE_LOOKUP] || storeLookup).set(e, i[$PROXY]);
-  i[STORE_VALUE] = e;
-  i[STORE_OVERRIDE] = undefined;
-  if (Array.isArray(r)) {
-    let t = false;
-    const c = getOverrideValue(r, s, u, "length", o);
-    if (e.length && c && e[0] && n(e[0]) != null) {
-      let a, l, f, E, d, T, S, R;
-      for (
-        f = 0, E = Math.min(c, e.length);
-        f < E &&
-        ((T = getOverrideValue(r, s, u, f, o)) === e[f] || (T && e[f] && n(T) === n(e[f])));
-        f++
-      ) {
-        applyState(e[f], wrap(T, i), n);
-      }
-      const O = new Array(e.length),
-        _ = new Map();
-      for (
-        E = c - 1, d = e.length - 1;
-        E >= f &&
-        d >= f &&
-        ((T = getOverrideValue(r, s, u, E, o)) === e[d] || (T && e[d] && n(T) === n(e[d])));
-        E--, d--
-      ) {
-        O[d] = T;
-      }
-      if (f > d || f > E) {
-        for (l = f; l <= d; l++) {
-          t = true;
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
-        }
-        for (; l < e.length; l++) {
-          t = true;
-          const r = wrap(O[l], i);
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], r);
-          applyState(e[l], r, n);
-        }
-        t && i[STORE_NODE][$TRACK] && setSignal(i[STORE_NODE][$TRACK], void 0);
-        c !== e.length && i[STORE_NODE].length && setSignal(i[STORE_NODE].length, e.length);
-        return;
-      }
-      S = new Array(d + 1);
-      for (l = d; l >= f; l--) {
-        T = e[l];
-        R = T ? n(T) : T;
-        a = _.get(R);
-        S[l] = a === undefined ? -1 : a;
-        _.set(R, l);
-      }
-      for (a = f; a <= E; a++) {
-        T = getOverrideValue(r, s, u, a, o);
-        R = T ? n(T) : T;
-        l = _.get(R);
-        if (l !== undefined && l !== -1) {
-          O[l] = T;
-          l = S[l];
-          _.set(R, l);
-        }
-      }
-      for (l = f; l < e.length; l++) {
-        if (l in O) {
-          const t = wrap(O[l], i);
-          i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], t);
-          applyState(e[l], t, n);
-        } else i[STORE_NODE][l] && setSignal(i[STORE_NODE][l], wrap(e[l], i));
-      }
-      if (f < e.length) t = true;
-    } else if (e.length) {
-      for (let t = 0, c = e.length; t < c; t++) {
-        const c = getOverrideValue(r, s, u, t, o);
-        isWrappable(c)
-          ? applyState(e[t], wrap(c, i), n)
-          : i[STORE_NODE][t] && setSignal(i[STORE_NODE][t], e[t]);
-      }
-    }
-    if (c !== e.length) {
-      t = true;
-      i[STORE_NODE].length && setSignal(i[STORE_NODE].length, e.length);
-    }
-    t && i[STORE_NODE][$TRACK] && setSignal(i[STORE_NODE][$TRACK], void 0);
-    return;
-  }
-  if (u) {
-    const t = u[$TRACK];
-    const c = t ? getAllKeys(r, s, e) : Object.keys(u);
-    for (let a = 0, l = c.length; a < l; a++) {
-      const l = c[a];
-      const f = u[l];
-      const E = unwrap(getOverrideValue(r, s, u, l, o));
-      let d = unwrap(e[l]);
-      if (E === d) continue;
-      if (!E || !isWrappable(E) || !isWrappable(d) || (n(E) != null && n(E) !== n(d))) {
-        t && setSignal(t, void 0);
-        f && setSignal(f, isWrappable(d) ? wrap(d, i) : d);
-      } else applyState(d, wrap(E, i), n);
-    }
-  }
-  if ((u = i[STORE_HAS])) {
-    const t = Object.keys(u);
-    for (let n = 0, i = t.length; n < i; n++) {
-      const i = t[n];
-      setSignal(u[i], i in e);
-    }
-  }
-}
-function reconcile(e, t) {
-  return n => {
-    if (n == null) throw new Error("Cannot reconcile null or undefined state");
-    const i = typeof t === "string" ? e => e[t] : t;
-    const r = i(n);
-    if (r !== undefined && i(e) !== i(n))
-      throw new Error("Cannot reconcile states with different identity");
-    applyState(e, n, i);
-  };
-}
-function createProjectionInternal(e, t, n) {
-  let i;
-  const r = new WeakMap();
-  const wrapper = e => {
-    e[STORE_WRAP] = wrapProjection;
-    e[STORE_LOOKUP] = r;
-    Object.defineProperty(e, STORE_FIREWALL, {
-      get() {
-        return i;
-      },
-      configurable: true
-    });
-  };
-  const wrapProjection = e => {
-    if (r.has(e)) return r.get(e);
-    if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
-    const t = createStoreProxy(e, storeTraps, wrapper);
-    r.set(e, t);
-    return t;
-  };
-  const s = wrapProjection(t);
-  i = computed(() => {
-    if (!i) i = getOwner();
-    runProjectionComputed(s, e, n?.key || "id");
-  }, undefined);
-  i.Pe = true;
-  return { store: s, node: i };
-}
-function createProjection(e, t, n) {
-  return createProjectionInternal(e, t, n).store;
-}
-function runProjectionComputed(e, t, n, i) {
-  const r = getOwner();
-  let s = false;
-  let o;
-  const u = new Proxy(
-    e,
-    createWriteTraps(() => !s || r.ye === o)
-  );
-  storeSetter(u, u => {
-    o = t(u);
-    s = true;
-    const commit = t => {
-      if (t === u || t === undefined) return;
-      const write = () => storeSetter(e, reconcile(t, n));
-      i ? i(write) : write();
-    };
-    commit(handleAsync(r, o, commit));
-  });
-  return r;
-}
-function createWriteTraps(e) {
-  const t = {
-    get(e, n) {
-      let i;
-      setWriteOverride(true);
-      setProjectionWriteActive(true);
-      try {
-        i = e[n];
-      } finally {
-        setWriteOverride(false);
-        setProjectionWriteActive(false);
-      }
-      return typeof i === "object" && i !== null ? new Proxy(i, t) : i;
-    },
-    has(e, t) {
-      let n;
-      setWriteOverride(true);
-      setProjectionWriteActive(true);
-      try {
-        n = t in e;
-      } finally {
-        setWriteOverride(false);
-        setProjectionWriteActive(false);
-      }
-      return n;
-    },
-    set(t, n, i) {
-      if (e && !e()) return true;
-      setWriteOverride(true);
-      setProjectionWriteActive(true);
-      try {
-        t[n] = i;
-      } finally {
-        setWriteOverride(false);
-        setProjectionWriteActive(false);
-      }
-      return true;
-    },
-    deleteProperty(t, n) {
-      if (e && !e()) return true;
-      setWriteOverride(true);
-      setProjectionWriteActive(true);
-      try {
-        delete t[n];
-      } finally {
-        setWriteOverride(false);
-        setProjectionWriteActive(false);
-      }
-      return true;
-    }
-  };
-  return t;
-}
-const $TRACK = Symbol(0),
-  $TARGET = Symbol(0),
-  $PROXY = Symbol(0),
-  $DELETED = Symbol(0);
-const STORE_VALUE = "v",
-  STORE_OVERRIDE = "o",
-  STORE_OPTIMISTIC_OVERRIDE = "x",
-  STORE_NODE = "n",
-  STORE_HAS = "h",
-  STORE_WRAP = "w",
-  STORE_LOOKUP = "l",
-  STORE_FIREWALL = "f",
-  STORE_OPTIMISTIC = "p";
-function createStoreProxy(e, t = storeTraps, n) {
-  let i;
-  if (Array.isArray(e)) {
-    i = [];
-    i.v = e;
-  } else i = { v: e };
-  n && n(i);
-  return (i[$PROXY] = new Proxy(i, t));
-}
-const storeLookup = new WeakMap();
-function wrap(e, t) {
-  if (t?.[STORE_WRAP]) return t[STORE_WRAP](e, t);
-  let n = e[$PROXY] || storeLookup.get(e);
-  if (!n) storeLookup.set(e, (n = createStoreProxy(e)));
-  return n;
-}
-function isWrappable(e) {
-  return (
-    e != null &&
-    typeof e === "object" &&
-    !Object.isFrozen(e) &&
-    !(typeof Node !== "undefined" && e instanceof Node)
-  );
-}
-let writeOverride = false;
-function setWriteOverride(e) {
-  writeOverride = e;
-}
-function writeOnly(e) {
-  return writeOverride || !!Writing?.has(e);
-}
-function getNodes(e, t) {
-  let n = e[t];
-  if (!n) e[t] = n = Object.create(null);
-  return n;
-}
-function getNode(e, t, n, i, r = isEqual, s, o) {
-  if (e[t]) return e[t];
-  const u = signal(
-    n,
-    {
-      equals: r,
-      unobserved() {
-        if (e[t] === u) delete e[t];
-      }
-    },
-    i
-  );
-  if (s) {
-    u.k = NOT_PENDING;
-  }
-  if (o && t in o) {
-    const e = o[t];
-    u.Te = e === undefined ? NO_SNAPSHOT : e;
-    snapshotSources?.add(u);
-  }
-  return (e[t] = u);
-}
-function trackSelf(e, t = $TRACK) {
-  getObserver() &&
-    read(
-      getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL], false, e[STORE_OPTIMISTIC])
-    );
-}
-function getKeys(e, t, n = true) {
-  const i = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
-  if (!t) return i;
-  const r = new Set(i);
-  const s = Reflect.ownKeys(t);
-  for (const e of s) {
-    if (t[e] !== $DELETED) r.add(e);
-    else r.delete(e);
-  }
-  return Array.from(r);
-}
-function getPropertyDescriptor(e, t, n) {
-  if (t && n in t) {
-    if (t[n] === $DELETED) return void 0;
-    const i = Reflect.getOwnPropertyDescriptor(t, n);
-    if (i?.get || i?.set || !(n in e)) return i;
-  }
-  return Reflect.getOwnPropertyDescriptor(e, n);
-}
-function prepareStoreWrite(e, t, n) {
-  if (e[STORE_OPTIMISTIC]) {
-    const t = e[STORE_FIREWALL];
-    if (t?.B) {
-      globalQueue.initTransition(t.B);
-    }
-  }
-  const i = e[STORE_VALUE];
-  const r = i[n];
-  if (
-    snapshotCaptureActive &&
-    typeof n !== "symbol" &&
-    !((e[STORE_FIREWALL]?.Re ?? 0) & STATUS_PENDING)
-  ) {
-    if (!e[STORE_SNAPSHOT_PROPS]) {
-      e[STORE_SNAPSHOT_PROPS] = Object.create(null);
-      snapshotSources?.add(e);
-    }
-    if (!(n in e[STORE_SNAPSHOT_PROPS])) {
-      e[STORE_SNAPSHOT_PROPS][n] = r;
-    }
-  }
-  const s = e[STORE_OPTIMISTIC] && !projectionWriteActive;
-  const o = s ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-  if (s) trackOptimisticStore(t);
-  return { base: r, overrideKey: o, state: i };
-}
-function upsertStoreNode(e, t, n, i, r) {
-  if (t[n]) return t[n];
-  const s = isWrappable(i) ? wrap(i, e) : i;
-  const o = getNode(t, n, s, e[STORE_FIREWALL], isEqual, e[STORE_OPTIMISTIC], r);
-  registerTransientStoreNode(o);
-  return o;
-}
-function notifyStoreProperty(e, t, n, i, r, s) {
-  const o = projectionWriteActive || e[STORE_OPTIMISTIC];
-  const u = n !== "delete";
-  const c = e[STORE_HAS]?.[t];
-  if (c) {
-    setSignal(c, u);
-  } else if (!o && n !== "invalidate" && s !== u) {
-    const n = upsertStoreNode(e, getNodes(e, STORE_HAS), t, s);
-    setSignal(n, u);
-  }
-  const a = getNodes(e, STORE_NODE);
-  if (n === "set") {
-    if (a[t]) {
-      setSignal(a[t], () => (isWrappable(i) ? wrap(i, e) : i));
-    } else if (!o) {
-      const n = upsertStoreNode(e, a, t, r, e[STORE_SNAPSHOT_PROPS]);
-      setSignal(n, () => (isWrappable(i) ? wrap(i, e) : i));
-    }
-  } else if (n === "invalidate") {
-    if (a[t]) {
-      setSignal(a[t], {});
-      delete a[t];
-    }
-  } else {
-    if (a[t]) {
-      setSignal(a[t], undefined);
-    } else if (!o) {
-      const n = upsertStoreNode(e, a, t, r, e[STORE_SNAPSHOT_PROPS]);
-      setSignal(n, undefined);
-    }
-  }
-  a[$TRACK] && setSignal(a[$TRACK], undefined);
-}
-let Writing = null;
-const storeTraps = {
-  get(e, t, n) {
-    if (t === $TARGET) return e;
-    if (t === $PROXY) return n;
-    if (t === $REFRESH) return e[STORE_FIREWALL];
-    if (t === $TRACK) {
-      trackSelf(e);
-      return n;
-    }
-    const i = getNodes(e, STORE_NODE);
-    const r = i[t];
-    const s = e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE];
-    const o = s || (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]);
-    const u = !!e[STORE_VALUE][$TARGET];
-    const c = s
-      ? e[STORE_OPTIMISTIC_OVERRIDE]
-      : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
-        ? e[STORE_OVERRIDE]
-        : e[STORE_VALUE];
-    if (!r) {
-      const e = Object.getOwnPropertyDescriptor(c, t);
-      if (e && e.get) return e.get.call(n);
-    }
-    if (writeOnly(n)) {
-      let n =
-        r && (o || !u)
-          ? r.k !== undefined && r.k !== NOT_PENDING
-            ? r.k
-            : r.U !== NOT_PENDING
-              ? r.U
-              : r.te
-          : c[t];
-      n === $DELETED && (n = undefined);
-      if (!isWrappable(n)) return n;
-      const i = wrap(n, e);
-      Writing?.add(i);
-      return i;
-    }
-    let a = r ? (o || !u ? read(i[t]) : (read(i[t]), c[t])) : c[t];
-    a === $DELETED && (a = undefined);
-    if (!r) {
-      if (!o && typeof a === "function" && !c.hasOwnProperty(t)) {
-        let t;
-        return !Array.isArray(e[STORE_VALUE]) &&
-          (t = Object.getPrototypeOf(e[STORE_VALUE])) &&
-          t !== Object.prototype
-          ? a.bind(c)
-          : a;
-      } else if (getObserver()) {
-        return read(
-          getNode(
-            i,
-            t,
-            isWrappable(a) ? wrap(a, e) : a,
-            e[STORE_FIREWALL],
-            isEqual,
-            e[STORE_OPTIMISTIC],
-            e[STORE_SNAPSHOT_PROPS]
-          )
-        );
-      }
-    }
-    return isWrappable(a) ? wrap(a, e) : a;
-  },
-  has(e, t) {
-    if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
-    const n =
-      e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
-        ? e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED
-        : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
-          ? e[STORE_OVERRIDE][t] !== $DELETED
-          : t in e[STORE_VALUE];
-    if (writeOnly(e[$PROXY])) return n;
-    const i = getNodes(e, STORE_HAS);
-    if (i[t]) return read(i[t]);
-    if (getObserver()) {
-      return read(getNode(i, t, n, e[STORE_FIREWALL], isEqual, e[STORE_OPTIMISTIC]));
-    }
-    return n;
-  },
-  set(e, t, n) {
-    const i = e[$PROXY];
-    if (writeOnly(i)) {
-      untrack(() => {
-        const { base: r, overrideKey: s, state: o } = prepareStoreWrite(e, i, t);
-        const u =
-          e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
-            ? e[STORE_OPTIMISTIC_OVERRIDE][t]
-            : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
-              ? e[STORE_OVERRIDE][t]
-              : r;
-        const c =
-          e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
-            ? e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED
-            : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
-              ? e[STORE_OVERRIDE][t] !== $DELETED
-              : t in e[STORE_VALUE];
-        const a = n?.[$TARGET]?.[STORE_VALUE] ?? n;
-        const l = Array.isArray(o) && t !== "length";
-        const f = l ? parseInt(t) + 1 : 0;
-        const E =
-          l &&
-          (e[STORE_OPTIMISTIC_OVERRIDE] && "length" in e[STORE_OPTIMISTIC_OVERRIDE]
-            ? e[STORE_OPTIMISTIC_OVERRIDE].length
-            : e[STORE_OVERRIDE] && "length" in e[STORE_OVERRIDE]
-              ? e[STORE_OVERRIDE].length
-              : o.length);
-        const d = l && f > E ? f : undefined;
-        if (u === a && d === undefined) return true;
-        if (a !== undefined && a === r && d === undefined) delete e[s]?.[t];
-        else {
-          const n = e[s] || (e[s] = Object.create(null));
-          n[t] = a;
-          if (d !== undefined) n.length = d;
-        }
-        notifyStoreProperty(e, t, "set", a, u, c);
-        if (Array.isArray(o) && t !== "length" && d !== undefined) {
-          const t = getNodes(e, STORE_NODE);
-          if (t.length) {
-            setSignal(t.length, d);
-          } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
-            const n = upsertStoreNode(e, t, "length", E, e[STORE_SNAPSHOT_PROPS]);
-            setSignal(n, d);
-          }
-        }
-        if (false);
-      });
-    }
-    return true;
-  },
-  defineProperty(e, t, n) {
-    const i = e[$PROXY];
-    if (writeOnly(i)) {
-      untrack(() => {
-        const { base: r, overrideKey: s } = prepareStoreWrite(e, i, t);
-        const o = "value" in n ? { ...n, value: n.value?.[$TARGET]?.[STORE_VALUE] ?? n.value } : n;
-        Object.defineProperty(e[s] || (e[s] = Object.create(null)), t, o);
-        notifyStoreProperty(e, t, "invalidate");
-        if (false);
-      });
-    }
-    return true;
-  },
-  deleteProperty(e, t) {
-    const n = e[STORE_OPTIMISTIC_OVERRIDE]?.[t] === $DELETED;
-    const i = e[STORE_OVERRIDE]?.[t] === $DELETED;
-    if (writeOnly(e[$PROXY]) && !n && !i) {
-      untrack(() => {
-        const n = e[STORE_OPTIMISTIC] && !projectionWriteActive;
-        const i = n ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-        if (n) trackOptimisticStore(e[$PROXY]);
-        const r =
-          e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]
-            ? e[STORE_OPTIMISTIC_OVERRIDE][t]
-            : e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
-              ? e[STORE_OVERRIDE][t]
-              : e[STORE_VALUE][t];
-        if (t in e[STORE_VALUE] || (e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE])) {
-          (e[i] || (e[i] = Object.create(null)))[t] = $DELETED;
-        } else if (e[i] && t in e[i]) {
-          delete e[i][t];
-        } else return true;
-        notifyStoreProperty(e, t, "delete", undefined, r, true);
-      });
-    }
-    return true;
-  },
-  ownKeys(e) {
-    trackSelf(e);
-    let t = getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);
-    if (e[STORE_OPTIMISTIC_OVERRIDE]) {
-      const n = new Set(t);
-      for (const t of Reflect.ownKeys(e[STORE_OPTIMISTIC_OVERRIDE])) {
-        if (e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED) n.add(t);
-        else n.delete(t);
-      }
-      t = Array.from(n);
-    }
-    return t;
-  },
-  getOwnPropertyDescriptor(e, t) {
-    if (t === $PROXY) return { value: e[$PROXY], writable: true, configurable: true };
-    if (e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]) {
-      if (e[STORE_OPTIMISTIC_OVERRIDE][t] === $DELETED) return undefined;
-      const n = Reflect.getOwnPropertyDescriptor(e[STORE_OPTIMISTIC_OVERRIDE], t);
-      if (n?.get || n?.set || !(t in e[STORE_VALUE])) return n;
-      const i = getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
-      if (i) {
-        return { ...i, value: e[STORE_OPTIMISTIC_OVERRIDE][t] };
-      }
-      return {
-        value: e[STORE_OPTIMISTIC_OVERRIDE][t],
-        writable: true,
-        enumerable: true,
-        configurable: true
-      };
-    }
-    return getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
-  },
-  getPrototypeOf(e) {
-    return Object.getPrototypeOf(e[STORE_VALUE]);
-  }
-};
-function storeSetter(e, t) {
-  const n = Writing;
-  Writing = new Set();
-  Writing.add(e);
-  try {
-    const n = t(e);
-    if (n !== e && n !== undefined) {
-      if (Array.isArray(n)) {
-        for (let t = 0, i = n.length; t < i; t++) e[t] = n[t];
-        e.length = n.length;
-      } else {
-        const t = new Set([...Object.keys(e), ...Object.keys(n)]);
-        t.forEach(t => {
-          if (t in n) e[t] = n[t];
-          else delete e[t];
-        });
-      }
-    }
-  } finally {
-    Writing.clear();
-    Writing = n;
-  }
-}
-function createStore(e, t, n) {
-  const i = typeof e === "function",
-    r = i ? createProjectionInternal(e, t, n).store : wrap(e);
-  return [r, e => storeSetter(r, e)];
-}
-function createOptimisticStore(e, t, n) {
-  GlobalQueue.ae ||= clearOptimisticStore;
-  const i = typeof e === "function";
-  const r = i ? t : e;
-  const s = i ? e : undefined;
-  const { store: o } = createOptimisticProjectionInternal(s, r, n);
-  return [o, e => storeSetter(o, e)];
-}
-function clearOptimisticStore(e) {
-  const t = e[$TARGET];
-  if (!t || !t[STORE_OPTIMISTIC_OVERRIDE]) return;
-  const n = t[STORE_OPTIMISTIC_OVERRIDE];
-  const i = t[STORE_NODE];
-  setProjectionWriteActive(true);
-  try {
-    if (i) {
-      for (const e of Reflect.ownKeys(n)) {
-        if (i[e]) {
-          i[e].ee = undefined;
-          const n =
-            t[STORE_OVERRIDE] && e in t[STORE_OVERRIDE] ? t[STORE_OVERRIDE][e] : t[STORE_VALUE][e];
-          const r = n === $DELETED ? undefined : n;
-          setSignal(i[e], isWrappable(r) ? wrap(r, t) : r);
-        }
-      }
-      if (i[$TRACK]) {
-        i[$TRACK].ee = undefined;
-        setSignal(i[$TRACK], undefined);
-      }
-    }
-  } finally {
-    setProjectionWriteActive(false);
-  }
-  delete t[STORE_OPTIMISTIC_OVERRIDE];
-}
-function createOptimisticProjectionInternal(e, t, n) {
-  let i;
-  const r = new WeakMap();
-  const wrapper = e => {
-    e[STORE_WRAP] = wrapProjection;
-    e[STORE_LOOKUP] = r;
-    e[STORE_OPTIMISTIC] = true;
-    Object.defineProperty(e, STORE_FIREWALL, {
-      get() {
-        return i;
-      },
-      configurable: true
-    });
-  };
-  const wrapProjection = e => {
-    if (r.has(e)) return r.get(e);
-    if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
-    const t = createStoreProxy(e, storeTraps, wrapper);
-    r.set(e, t);
-    return t;
-  };
-  const s = wrapProjection(t);
-  if (e) {
-    const wrapCommit = e => {
-      setProjectionWriteActive(true);
-      try {
-        e();
-      } finally {
-        setProjectionWriteActive(false);
-      }
-    };
-    i = computed(() => {
-      setProjectionWriteActive(true);
-      try {
-        runProjectionComputed(s, e, n?.key || "id", wrapCommit);
-      } finally {
-        setProjectionWriteActive(false);
-      }
-    }, undefined);
-    i.Pe = true;
-  }
-  return { store: s, node: i };
-}
-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++) {
-      const i = n[e];
-      const r = Object.getOwnPropertyDescriptor(s, i);
-      if (r.get || r.set) Object.defineProperty(t, i, r);
-      else t[i] = r.value;
-    }
-  } else {
-    e[i] = s;
-  }
-}
-const storePath = Object.assign(
-  function storePath(...e) {
-    return t => {
-      updatePath(t, e);
-    };
-  },
-  { DELETE: DELETE }
-);
-function snapshotImpl(e, t, n, i) {
-  let r, s, o, u, c, a;
-  if (!isWrappable(e)) return e;
-  if (n && n.has(e)) return n.get(e);
-  if (!n) n = new Map();
-  if ((r = e[$TARGET] || i?.get(e)?.[$TARGET])) {
-    if (t) trackSelf(r, $TRACK);
-    o = r[STORE_OVERRIDE];
-    s = Array.isArray(r[STORE_VALUE]);
-    n.set(
-      e,
-      o ? (u = s ? [] : Object.create(Object.getPrototypeOf(r[STORE_VALUE]))) : r[STORE_VALUE]
-    );
-    e = r[STORE_VALUE];
-    i = storeLookup;
-  } else {
-    s = Array.isArray(e);
-    n.set(e, e);
-  }
-  if (s) {
-    const s = o?.length || e.length;
-    for (let l = 0; l < s; l++) {
-      a = o && l in o ? o[l] : e[l];
-      if (a === $DELETED) continue;
-      if (t && isWrappable(a)) wrap(a, r);
-      if ((c = snapshotImpl(a, t, n, i)) !== a || u) {
-        if (!u) n.set(e, (u = [...e]));
-        u[l] = c;
-      }
-    }
-  } else {
-    const s = getKeys(e, o);
-    for (let l = 0, f = s.length; l < f; l++) {
-      let f = s[l];
-      const E = getPropertyDescriptor(e, o, f);
-      if (E.get) continue;
-      a = o && f in o ? o[f] : e[f];
-      if (t && isWrappable(a)) wrap(a, r);
-      if ((c = snapshotImpl(a, t, n, i)) !== e[f] || u) {
-        if (!u) {
-          u = Object.create(Object.getPrototypeOf(e));
-          Object.assign(u, e);
-        }
-        u[f] = c;
-      }
-    }
-  }
-  return u || e;
-}
-function snapshot(e, t, n) {
-  return snapshotImpl(e, false, t, n);
-}
-function deep(e) {
-  return snapshotImpl(e, true);
-}
-function trueFn() {
-  return true;
-}
-const propTraps = {
-  get(e, t, n) {
-    if (t === $PROXY) return n;
-    return e.get(t);
-  },
-  has(e, t) {
-    if (t === $PROXY) return true;
-    return e.has(t);
-  },
-  set: trueFn,
-  deleteProperty: trueFn,
-  getOwnPropertyDescriptor(e, t) {
-    return {
-      configurable: true,
-      enumerable: true,
-      get() {
-        return e.get(t);
-      },
-      set: trueFn,
-      deleteProperty: trueFn
-    };
-  },
-  ownKeys(e) {
-    return e.keys();
-  }
-};
-function resolveSource(e) {
-  return !(e = typeof e === "function" ? e() : e) ? {} : e;
-}
-const $SOURCES = Symbol(0);
-function merge(...e) {
-  if (e.length === 1 && typeof e[0] !== "function") return e[0];
-  let t = false;
-  const n = [];
-  for (let i = 0; i < e.length; i++) {
-    const r = e[i];
-    t = t || (!!r && $PROXY in r);
-    const s = !!r && r[$SOURCES];
-    if (s) n.push(...s);
-    else n.push(typeof r === "function" ? ((t = true), createMemo(r)) : r);
-  }
-  if (SUPPORTS_PROXY && t) {
-    return new Proxy(
-      {
-        get(e) {
-          if (e === $SOURCES) return n;
-          for (let t = n.length - 1; t >= 0; t--) {
-            const i = resolveSource(n[t]);
-            if (e in i) return i[e];
-          }
-        },
-        has(e) {
-          for (let t = n.length - 1; t >= 0; t--) {
-            if (e in resolveSource(n[t])) return true;
-          }
-          return false;
-        },
-        keys() {
-          const e = [];
-          for (let t = 0; t < n.length; t++) e.push(...Object.keys(resolveSource(n[t])));
-          return [...new Set(e)];
-        }
-      },
-      propTraps
-    );
-  }
-  const i = Object.create(null);
-  let r = false;
-  let s = n.length - 1;
-  for (let e = s; e >= 0; e--) {
-    const t = n[e];
-    if (!t) {
-      e === s && s--;
-      continue;
-    }
-    const o = Object.getOwnPropertyNames(t);
-    for (let n = o.length - 1; n >= 0; n--) {
-      const u = o[n];
-      if (u === "__proto__" || u === "constructor") continue;
-      if (!i[u]) {
-        r = r || e !== s;
-        const n = Object.getOwnPropertyDescriptor(t, u);
-        i[u] = n.get ? { enumerable: true, configurable: true, get: n.get.bind(t) } : n;
-      }
-    }
-  }
-  if (!r) return n[s];
-  const o = {};
-  const u = Object.keys(i);
-  for (let e = u.length - 1; e >= 0; e--) {
-    const t = u[e],
-      n = i[t];
-    if (n.get) Object.defineProperty(o, t, n);
-    else o[t] = n.value;
-  }
-  o[$SOURCES] = n;
-  return o;
-}
-function omit(e, ...t) {
-  const n = new Set(t);
-  if (SUPPORTS_PROXY && $PROXY in e) {
-    return new Proxy(
-      {
-        get(t) {
-          return n.has(t) ? undefined : e[t];
-        },
-        has(t) {
-          return !n.has(t) && t in e;
-        },
-        keys() {
-          return Object.keys(e).filter(e => !n.has(e));
-        }
-      },
-      propTraps
-    );
-  }
-  const i = {};
-  for (const t of Object.getOwnPropertyNames(e)) {
-    if (!n.has(t)) {
-      const n = Object.getOwnPropertyDescriptor(e, t);
-      !n.get && !n.set && n.enumerable && n.writable && n.configurable
-        ? (i[t] = n.value)
-        : Object.defineProperty(i, t, n);
-    }
-  }
-  return i;
-}
-function mapArray(e, t, n) {
-  const i = typeof n?.keyed === "function" ? n.keyed : undefined;
-  const r = t.length > 1;
-  const s = t;
-  const o = computed(
-    updateKeyedMap.bind({
-      Ye: createOwner(),
-      Ze: 0,
-      Be: e,
-      qe: [],
-      Xe: s,
-      ze: [],
-      Je: [],
-      et: i,
-      tt: i || n?.keyed === false ? [] : undefined,
-      nt: r ? [] : undefined,
-      it: n?.fallback
-    })
-  );
-  o.Pe = true;
-  return accessor(o);
-}
-const pureOptions = { ownedWrite: true };
-function updateKeyedMap() {
-  const e = this.Be() || [],
-    t = e.length;
-  e[$TRACK];
-  runWithOwner(this.Ye, () => {
-    let n,
-      i,
-      r = this.tt
-        ? () => {
-            this.tt[i] = signal(e[i], pureOptions);
-            this.nt && (this.nt[i] = signal(i, pureOptions));
-            return this.Xe(accessor(this.tt[i]), this.nt ? accessor(this.nt[i]) : undefined);
-          }
-        : this.nt
-          ? () => {
-              const t = e[i];
-              this.nt[i] = signal(i, pureOptions);
-              return this.Xe(() => t, accessor(this.nt[i]));
-            }
-          : () => {
-              const t = e[i];
-              return this.Xe(() => t);
-            };
-    if (t === 0) {
-      if (this.Ze !== 0) {
-        this.Ye.dispose(false);
-        this.Je = [];
-        this.qe = [];
-        this.ze = [];
-        this.Ze = 0;
-        this.tt && (this.tt = []);
-        this.nt && (this.nt = []);
-      }
-      if (this.it && !this.ze[0]) {
-        this.ze[0] = runWithOwner((this.Je[0] = createOwner()), this.it);
-      }
-    } else if (this.Ze === 0) {
-      if (this.Je[0]) this.Je[0].dispose();
-      this.ze = new Array(t);
-      for (i = 0; i < t; i++) {
-        this.qe[i] = e[i];
-        this.ze[i] = runWithOwner((this.Je[i] = createOwner()), r);
-      }
-      this.Ze = t;
-    } else {
-      let s,
-        o,
-        u,
-        c,
-        a,
-        l,
-        f,
-        E = new Array(t),
-        d = new Array(t),
-        T = this.tt ? new Array(t) : undefined,
-        S = this.nt ? new Array(t) : undefined;
-      for (
-        s = 0, o = Math.min(this.Ze, t);
-        s < o && (this.qe[s] === e[s] || (this.tt && compare(this.et, this.qe[s], e[s])));
-        s++
-      ) {
-        if (this.tt) setSignal(this.tt[s], e[s]);
-      }
-      for (
-        o = this.Ze - 1, u = t - 1;
-        o >= s &&
-        u >= s &&
-        (this.qe[o] === e[u] || (this.tt && compare(this.et, this.qe[o], e[u])));
-        o--, u--
-      ) {
-        E[u] = this.ze[o];
-        d[u] = this.Je[o];
-        T && (T[u] = this.tt[o]);
-        S && (S[u] = this.nt[o]);
-      }
-      l = new Map();
-      f = new Array(u + 1);
-      for (i = u; i >= s; i--) {
-        c = e[i];
-        a = this.et ? this.et(c) : c;
-        n = l.get(a);
-        f[i] = n === undefined ? -1 : n;
-        l.set(a, i);
-      }
-      for (n = s; n <= o; n++) {
-        c = this.qe[n];
-        a = this.et ? this.et(c) : c;
-        i = l.get(a);
-        if (i !== undefined && i !== -1) {
-          E[i] = this.ze[n];
-          d[i] = this.Je[n];
-          T && (T[i] = this.tt[n]);
-          S && (S[i] = this.nt[n]);
-          i = f[i];
-          l.set(a, i);
-        } else this.Je[n].dispose();
-      }
-      for (i = s; i < t; i++) {
-        if (i in E) {
-          this.ze[i] = E[i];
-          this.Je[i] = d[i];
-          if (T) {
-            this.tt[i] = T[i];
-            setSignal(this.tt[i], e[i]);
-          }
-          if (S) {
-            this.nt[i] = S[i];
-            setSignal(this.nt[i], i);
-          }
-        } else {
-          this.ze[i] = runWithOwner((this.Je[i] = createOwner()), r);
-        }
-      }
-      this.ze = this.ze.slice(0, (this.Ze = t));
-      this.qe = e.slice(0);
-    }
-  });
-  return this.ze;
-}
-function repeat(e, t, n) {
-  const i = t;
-  const r = computed(
-    updateRepeat.bind({
-      Ye: createOwner(),
-      Ze: 0,
-      rt: 0,
-      st: e,
-      Xe: i,
-      Je: [],
-      ze: [],
-      ot: n?.from,
-      it: n?.fallback
-    })
-  );
-  r.Pe = true;
-  return accessor(r);
-}
-function updateRepeat() {
-  const e = this.st();
-  const t = this.ot?.() || 0;
-  runWithOwner(this.Ye, () => {
-    if (e === 0) {
-      if (this.Ze !== 0) {
-        this.Ye.dispose(false);
-        this.Je = [];
-        this.ze = [];
-        this.Ze = 0;
-      }
-      if (this.it && !this.ze[0]) {
-        this.ze[0] = runWithOwner((this.Je[0] = createOwner()), this.it);
-      }
-      return;
-    }
-    const n = t + e;
-    const i = this.rt + this.Ze;
-    if (this.Ze === 0 && this.Je[0]) this.Je[0].dispose();
-    for (let e = n; e < i; e++) this.Je[e - this.rt].dispose();
-    if (this.rt < t) {
-      let e = this.rt;
-      while (e < t && e < this.Ze) this.Je[e++].dispose();
-      this.Je.splice(0, t - this.rt);
-      this.ze.splice(0, t - this.rt);
-    } else if (this.rt > t) {
-      let n = i - this.rt - 1;
-      let r = this.rt - t;
-      this.Je.length = this.ze.length = e;
-      while (n >= r) {
-        this.Je[n] = this.Je[n - r];
-        this.ze[n] = this.ze[n - r];
-        n--;
-      }
-      for (let e = 0; e < r; e++) {
-        this.ze[e] = runWithOwner((this.Je[e] = createOwner()), () => this.Xe(e + t));
-      }
-    }
-    for (let e = i; e < n; e++) {
-      this.ze[e - t] = runWithOwner((this.Je[e - t] = createOwner()), () => this.Xe(e));
-    }
-    this.ze = this.ze.slice(0, e);
-    this.rt = t;
-    this.Ze = e;
-  });
-  return this.ze;
-}
-function compare(e, t, n) {
-  return e ? e(t) === e(n) : true;
-}
-function boundaryComputed(e, t) {
-  const n = computed(e, { lazy: true });
-  n.xe = (e, t) => {
-    const i = e !== undefined ? e : n.Re;
-    const r = t !== undefined ? t : n.Ee;
-    n.Re &= ~n.ut;
-    n.$.notify(n, n.ut, i, r);
-  };
-  n.ut = t;
-  n.Pe = true;
-  recompute(n, true);
-  return n;
-}
-function createBoundChildren(e, t, n, i) {
-  const r = e.$;
-  r.addChild((e.$ = n));
-  cleanup(() => r.removeChild(e.$));
-  return runWithOwner(e, () => {
-    const e = computed(t);
-    return boundaryComputed(() => staleValues(() => flatten(read(e))), i);
-  });
-}
-const ON_INIT = Symbol();
-const RevealControllerContext = createContext(null);
-let _revealUsed = false;
-const FALSE_ACCESSOR = () => false;
-const SEQUENTIAL_ACCESSOR = () => "sequential";
-function isRevealController(e) {
-  return e instanceof RevealController;
-}
-function isSlotReady(e) {
-  return isRevealController(e) ? e.isReady() : e.ct.size === 0 && !e.lt;
-}
-function isSlotMinimallyReady(e) {
-  return isRevealController(e) ? e.isMinimallyReady() : isSlotReady(e);
-}
-function setSlotState(e, t, n, i) {
-  setSignal(e.ft, n);
-  setSignal(e.Et, i);
-  if (isRevealController(e)) {
-    if (!n && e.dt === t) e.dt = undefined;
-    return e.evaluate(n, i);
-  }
-  if (!n && e.Tt === t && e.St) e.Tt = undefined;
-}
-class RevealController {
-  Rt;
-  Ot;
-  _t = [];
-  dt;
-  ft = signal(false, { ownedWrite: true, He: true });
-  Et = signal(false, { ownedWrite: true, He: true });
-  It = true;
-  ht = true;
-  At = false;
-  constructor(e, t) {
-    this.Rt = e;
-    this.Ot = t;
-  }
-  Nt(e) {
-    for (let t = 0; t < this._t.length; t++) {
-      const n = this._t[t];
-      if ((isRevealController(n) ? n.dt : n.Tt) !== this) continue;
-      if (e(n) === false) return false;
-    }
-    return true;
-  }
-  isReady() {
-    return this.Nt(isSlotReady);
-  }
-  isMinimallyReady() {
-    const e = untrack(this.Rt);
-    if (e === "together") return this.isReady();
-    if (e === "natural") {
-      let e = false;
-      let t = false;
-      this.Nt(n => {
-        e = true;
-        if (isSlotMinimallyReady(n)) {
-          t = true;
-          return false;
-        }
-      });
-      return !e || t;
-    }
-    let t = true;
-    this.Nt(e => {
-      t = isSlotMinimallyReady(e);
-      return false;
-    });
-    return t;
-  }
-  register(e) {
-    if (this._t.includes(e)) return;
-    this._t.push(e);
-    const t = untrack(this.Rt);
-    (setSignal(e.ft, true), setSignal(e.Et, t === "sequential" ? !!untrack(this.Ot) : false));
-    untrack(() => this.evaluate());
-  }
-  unregister(e) {
-    const t = this._t.indexOf(e);
-    if (t >= 0) this._t.splice(t, 1);
-    untrack(() => this.evaluate());
-  }
-  evaluate(e, t) {
-    if (this.At) return;
-    this.At = true;
-    const n = this.It;
-    const i = this.ht;
-    try {
-      const n = e ?? read(this.ft),
-        i = untrack(this.Rt),
-        r = i === "sequential" && !!untrack(this.Ot),
-        s = t ?? r;
-      if (n) {
-        this.Nt(e => setSlotState(e, this, true, s));
-      } else if (i === "natural") {
-        this.Nt(e => {
-          if (isRevealController(e)) {
-            setSignal(e.Et, false);
-            setSignal(e.ft, false);
-            e.evaluate(false, false);
-          } else {
-            setSlotState(e, this, !isSlotReady(e), false);
-          }
-        });
-      } else if (i === "together") {
-        const e = this.Nt(isSlotMinimallyReady);
-        this.Nt(t => setSlotState(t, this, !e, false));
-      } else {
-        let e = false;
-        this.Nt(t => {
-          if (e) return setSlotState(t, this, true, r);
-          if (isSlotReady(t)) return setSlotState(t, this, false, false);
-          e = true;
-          if (isRevealController(t)) {
-            setSignal(t.Et, false);
-            setSignal(t.ft, false);
-            t.evaluate(false, false);
-          } else {
-            setSlotState(t, this, true, false);
-          }
-        });
-      }
-    } finally {
-      this.It = this.isReady();
-      this.ht = this.isMinimallyReady();
-      this.At = false;
-    }
-    if (this.dt && (n !== this.It || i !== this.ht)) this.dt.evaluate();
-  }
-}
-class CollectionQueue extends Queue {
-  Pt;
-  ct = new Set();
-  gt;
-  lt = true;
-  ft = signal(false, { ownedWrite: true, He: true });
-  Et = signal(false, { ownedWrite: true, He: true });
-  Tt;
-  St = false;
-  Ct;
-  Dt = ON_INIT;
-  constructor(e) {
-    super();
-    this.Pt = e;
-  }
-  run(e) {
-    if (!e || (read(this.ft) && (!_revealUsed || read(this.Et)))) return;
-    return super.run(e);
-  }
-  notify(e, t, n, i) {
-    if (!(t & this.Pt)) return super.notify(e, t, n, i);
-    if (this.St && this.Ct) {
-      const e = untrack(() => {
-        try {
-          return this.Ct();
-        } catch {
-          return ON_INIT;
-        }
-      });
-      if (e !== this.Dt) {
-        this.Dt = e;
-        this.St = false;
-        this.ct.clear();
-      }
-    }
-    if (this.Pt & STATUS_PENDING && this.St) return super.notify(e, t, n, i);
-    if (this.Pt & STATUS_PENDING && n & STATUS_ERROR) {
-      return super.notify(e, STATUS_ERROR, n, i);
-    }
-    if (n & this.Pt) {
-      this.lt = true;
-      const t = i?.source || e.Ee?.source;
-      if (t) {
-        const e = this.ct.size === 0;
-        this.ct.add(t);
-        if (e) setSignal(this.ft, true);
-      }
-    }
-    t &= ~this.Pt;
-    return t ? super.notify(e, t, n, i) : true;
-  }
-  checkSources() {
-    for (const e of this.ct) {
-      if (
-        e.O & REACTIVE_DISPOSED ||
-        (!(e.Re & this.Pt) && !(this.Pt & STATUS_ERROR && e.Re & STATUS_PENDING))
-      )
-        this.ct.delete(e);
-    }
-    if (!this.ct.size) {
-      if (this.Pt & STATUS_PENDING && this.lt && !this.St && this.gt) {
-        this.lt = !!(this.gt.Re & this.Pt);
-      } else {
-        this.lt = false;
-      }
-      if (!this.lt) {
-        setSignal(this.ft, false);
-        if (this.Ct) {
-          try {
-            this.Dt = untrack(() => this.Ct());
-          } catch {}
-        }
-      }
-    }
-    if (_revealUsed) this.Tt?.evaluate();
-  }
-}
-function createCollectionBoundary(e, t, n, i) {
-  const r = createOwner();
-  if (_revealUsed) setContext(RevealControllerContext, null, r);
-  const s = new CollectionQueue(e);
-  if (i) s.Ct = i;
-  const o = (s.gt = createBoundChildren(r, t, s, e));
-  untrack(() => {
-    let t = false;
-    try {
-      read(o);
-    } catch (e) {
-      if (e instanceof NotReadyError) t = true;
-      else throw e;
-    }
-    s.lt = t || !!(o.Re & e) || o.Ee instanceof NotReadyError;
-  });
-  const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
-  if (u) {
-    s.Tt = u;
-    u.register(s);
-    cleanup(() => u.unregister(s));
-  }
-  const c = computed(() => {
-    if (!read(s.ft)) {
-      const e = read(o);
-      if (!untrack(() => read(s.ft))) return ((s.St = true), e);
-    }
-    if (_revealUsed && read(s.Et)) return undefined;
-    return n(s);
-  });
-  return accessor(c);
-}
-function createLoadingBoundary(e, t, n) {
-  return createCollectionBoundary(STATUS_PENDING, e, () => t(), n?.on);
-}
-function createErrorBoundary(e, t) {
-  return createCollectionBoundary(STATUS_ERROR, e, e => {
-    let n = e.ct.values().next().value;
-    const i = n.Ee?.cause ?? n.Ee;
-    return t(i, () => {
-      for (const t of e.ct) recompute(t);
-      schedule();
-    });
-  });
-}
-function createRevealOrder(e, t) {
-  _revealUsed = true;
-  const n = createOwner();
-  const i = getContext(RevealControllerContext);
-  const r = t?.order || SEQUENTIAL_ACCESSOR,
-    s = t?.collapsed || FALSE_ACCESSOR;
-  const o = new RevealController(r, s);
-  setContext(RevealControllerContext, o, n);
-  return runWithOwner(n, () => {
-    const t = e();
-    computed(() => {
-      r();
-      s();
-      o.evaluate();
-    });
-    if (i) {
-      o.dt = i;
-      i.register(o);
-      cleanup(() => i.unregister(o));
-    }
-    return t;
-  });
-}
-function flatten(e, t) {
-  if (typeof e === "function" && !e.length) {
-    if (t?.doNotUnwrap) return e;
-    do {
-      e = e();
-    } while (typeof e === "function" && !e.length);
-  }
-  if (t?.skipNonRendered && (e == null || e === true || e === false || e === "")) return;
-  if (Array.isArray(e)) {
-    let n = [];
-    if (flattenArray(e, n, t)) {
-      return () => {
-        let e = [];
-        flattenArray(n, e, { ...t, doNotUnwrap: false });
-        return e;
-      };
-    }
-    return n;
-  }
-  return e;
-}
-function flattenArray(e, t = [], n) {
-  let i = null;
-  let r = false;
-  for (let s = 0; s < e.length; s++) {
-    try {
-      let i = e[s];
-      if (typeof i === "function" && !i.length) {
-        if (n?.doNotUnwrap) {
-          t.push(i);
-          r = true;
-          continue;
-        }
-        do {
-          i = i();
-        } while (typeof i === "function" && !i.length);
-      }
-      if (Array.isArray(i)) {
-        r = flattenArray(i, t, n);
-      } else if (n?.skipNonRendered && (i == null || i === true || i === false || i === "")) {
-      } else t.push(i);
-    } catch (e) {
-      if (!(e instanceof NotReadyError)) throw e;
-      i = e;
-    }
-  }
-  if (i) throw i;
-  return r;
-}
-const DEV = undefined;
-export {
-  $PROXY,
-  $REFRESH,
-  $TARGET,
-  $TRACK,
-  ContextNotFoundError,
-  DEV,
-  NoOwnerError,
-  NotReadyError,
-  SUPPORTS_PROXY,
-  action,
-  clearSnapshots,
-  createContext,
-  createEffect,
-  createErrorBoundary,
-  createLoadingBoundary,
-  createMemo,
-  createOptimistic,
-  createOptimisticStore,
-  createOwner,
-  createProjection,
-  createReaction,
-  createRenderEffect,
-  createRevealOrder,
-  createRoot,
-  createSignal,
-  createStore,
-  createTrackedEffect,
-  deep,
-  enableExternalSource,
-  enforceLoadingBoundary,
-  flatten,
-  flush,
-  getContext,
-  getNextChildId,
-  getObserver,
-  getOwner,
-  isDisposed,
-  isEqual,
-  isPending,
-  isRefreshing,
-  isWrappable,
-  latest,
-  mapArray,
-  markSnapshotScope,
-  merge,
-  omit,
-  onCleanup,
-  onSettled,
-  peekNextChildId,
-  reconcile,
-  refresh,
-  releaseSnapshotScope,
-  repeat,
-  resolve,
-  runWithOwner,
-  setContext,
-  setSnapshotCapture,
-  snapshot,
-  storePath,
-  untrack
-};