@tanstack/solid-query-devtools 5.91.3 → 6.0.0-alpha.0

package/build/chunk/KLS34EMT.js

@@ -0,0 +1,1065 @@
+import { createRenderEffect, untrack as untrack$1, runWithOwner, sharedConfig } from 'solid-js';
+
+// ../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.2_@solidjs+signals@0.12.0_solid-js@2.0.0-beta.2/node_modules/@solidjs/web/dist/dev.js
+
+// ../../node_modules/.pnpm/@solidjs+signals@0.12.0/node_modules/@solidjs/signals/dist/dev.js
+var NotReadyError = class extends Error {
+  source;
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+};
+var StatusError = class extends Error {
+  source;
+  constructor(source, original) {
+    super(original instanceof Error ? original.message : String(original), { cause: original });
+    this.source = source;
+  }
+};
+var REACTIVE_NONE = 0;
+var REACTIVE_CHECK = 1 << 0;
+var REACTIVE_DIRTY = 1 << 1;
+var REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+var REACTIVE_IN_HEAP = 1 << 3;
+var REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+var REACTIVE_ZOMBIE = 1 << 5;
+var REACTIVE_DISPOSED = 1 << 6;
+var REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
+var REACTIVE_SNAPSHOT_STALE = 1 << 8;
+var STATUS_PENDING = 1 << 0;
+var STATUS_ERROR = 1 << 1;
+var STATUS_UNINITIALIZED = 1 << 2;
+var EFFECT_RENDER = 1;
+var EFFECT_USER = 2;
+var EFFECT_TRACKED = 3;
+var NOT_PENDING = {};
+function actualInsertIntoHeap(n, heap) {
+  const parentHeight = (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
+  if (parentHeight >= n._height) n._height = parentHeight + 1;
+  const height = n._height;
+  const heapAtHeight = heap._heap[height];
+  if (heapAtHeight === void 0) heap._heap[height] = n;
+  else {
+    const tail = heapAtHeight._prevHeap;
+    tail._nextHeap = n;
+    n._prevHeap = tail;
+    heapAtHeight._prevHeap = n;
+  }
+  if (height > heap._max) heap._max = height;
+}
+function insertIntoHeap(n, heap) {
+  let flags = n._flags;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  if (flags & REACTIVE_CHECK) {
+    n._flags = flags & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else n._flags = flags | REACTIVE_IN_HEAP;
+  if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
+}
+function insertIntoHeapHeight(n, heap) {
+  let flags = n._flags;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
+  actualInsertIntoHeap(n, heap);
+}
+function deleteFromHeap(n, heap) {
+  const flags = n._flags;
+  if (!(flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+  n._flags = flags & -25;
+  const height = n._height;
+  if (n._prevHeap === n) heap._heap[height] = void 0;
+  else {
+    const next = n._nextHeap;
+    const dhh = heap._heap[height];
+    const end = next ?? dhh;
+    if (n === dhh) heap._heap[height] = next;
+    else n._prevHeap._nextHeap = next;
+    end._prevHeap = n._prevHeap;
+  }
+  n._prevHeap = n;
+  n._nextHeap = void 0;
+}
+function runHeap(heap, recompute2) {
+  heap._marked = false;
+  for (heap._min = 0; heap._min <= heap._max; heap._min++) {
+    let el = heap._heap[heap._min];
+    while (el !== void 0) {
+      if (el._flags & REACTIVE_IN_HEAP) recompute2(el);
+      else adjustHeight(el, heap);
+      el = heap._heap[heap._min];
+    }
+  }
+  heap._max = 0;
+}
+function adjustHeight(el, heap) {
+  deleteFromHeap(el, heap);
+  let newHeight = el._height;
+  for (let d = el._deps; d; d = d._nextDep) {
+    const dep1 = d._dep;
+    const dep = dep1._firewall || dep1;
+    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
+  }
+  if (el._height !== newHeight) {
+    el._height = newHeight;
+    for (let s = el._subs; s !== null; s = s._nextSub) {
+      insertIntoHeapHeight(s._sub, heap);
+    }
+  }
+}
+var transitions = /* @__PURE__ */ new Set();
+var dirtyQueue = { _heap: new Array(2e3).fill(void 0), _marked: false, _min: 0, _max: 0 };
+var zombieQueue = { _heap: new Array(2e3).fill(void 0), _marked: false, _min: 0, _max: 0 };
+var clock = 0;
+var activeTransition = null;
+var scheduled = false;
+var projectionWriteActive = false;
+var _onUnhandledAsync = null;
+function runLaneEffects(type) {
+  for (const lane of activeLanes) {
+    if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
+    const effects = lane._effectQueues[type - 1];
+    if (effects.length) {
+      lane._effectQueues[type - 1] = [];
+      runQueue(effects, type);
+    }
+  }
+}
+function schedule() {
+  if (scheduled) return;
+  scheduled = true;
+  if (!globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
+}
+var Queue = class {
+  _parent = null;
+  _queues = [[], []];
+  _children = [];
+  created = clock;
+  addChild(child) {
+    this._children.push(child);
+    child._parent = this;
+  }
+  removeChild(child) {
+    const index = this._children.indexOf(child);
+    if (index >= 0) {
+      this._children.splice(index, 1);
+      child._parent = null;
+    }
+  }
+  notify(node, mask, flags, error) {
+    if (this._parent) return this._parent.notify(node, mask, flags, error);
+    return false;
+  }
+  run(type) {
+    if (this._queues[type - 1].length) {
+      const effects = this._queues[type - 1];
+      this._queues[type - 1] = [];
+      runQueue(effects, type);
+    }
+    for (let i = 0; i < this._children.length; i++) this._children[i].run?.(type);
+  }
+  enqueue(type, fn) {
+    if (type) {
+      if (currentOptimisticLane) {
+        const lane = findLane(currentOptimisticLane);
+        lane._effectQueues[type - 1].push(fn);
+      } else {
+        this._queues[type - 1].push(fn);
+      }
+    }
+    schedule();
+  }
+  stashQueues(stub) {
+    stub._queues[0].push(...this._queues[0]);
+    stub._queues[1].push(...this._queues[1]);
+    this._queues = [[], []];
+    for (let i = 0; i < this._children.length; i++) {
+      let child = this._children[i];
+      let childStub = stub._children[i];
+      if (!childStub) {
+        childStub = { _queues: [[], []], _children: [] };
+        stub._children[i] = childStub;
+      }
+      child.stashQueues(childStub);
+    }
+  }
+  restoreQueues(stub) {
+    this._queues[0].push(...stub._queues[0]);
+    this._queues[1].push(...stub._queues[1]);
+    for (let i = 0; i < stub._children.length; i++) {
+      const childStub = stub._children[i];
+      let child = this._children[i];
+      if (child) child.restoreQueues(childStub);
+    }
+  }
+};
+var GlobalQueue = class _GlobalQueue extends Queue {
+  _running = false;
+  _pendingNodes = [];
+  _optimisticNodes = [];
+  _optimisticStores = /* @__PURE__ */ new Set();
+  static _update;
+  static _dispose;
+  static _clearOptimisticStore = null;
+  flush() {
+    if (this._running) return;
+    this._running = true;
+    try {
+      runHeap(dirtyQueue, _GlobalQueue._update);
+      if (activeTransition) {
+        const isComplete = transitionComplete(activeTransition);
+        if (!isComplete) {
+          let t = activeTransition;
+          runHeap(zombieQueue, _GlobalQueue._update);
+          this._pendingNodes = [];
+          this._optimisticNodes = [];
+          this._optimisticStores = /* @__PURE__ */ new Set();
+          runLaneEffects(EFFECT_RENDER);
+          runLaneEffects(EFFECT_USER);
+          this.stashQueues(activeTransition._queueStash);
+          clock++;
+          scheduled = dirtyQueue._max >= dirtyQueue._min;
+          reassignPendingTransition(activeTransition._pendingNodes);
+          activeTransition = null;
+          finalizePureQueue(null, true);
+          return;
+        }
+        this._pendingNodes !== activeTransition._pendingNodes && this._pendingNodes.push(...activeTransition._pendingNodes);
+        this.restoreQueues(activeTransition._queueStash);
+        transitions.delete(activeTransition);
+        const completingTransition = activeTransition;
+        activeTransition = null;
+        reassignPendingTransition(this._pendingNodes);
+        finalizePureQueue(completingTransition);
+      } else {
+        if (transitions.size) runHeap(zombieQueue, _GlobalQueue._update);
+        finalizePureQueue();
+      }
+      clock++;
+      scheduled = dirtyQueue._max >= dirtyQueue._min;
+      runLaneEffects(EFFECT_RENDER);
+      this.run(EFFECT_RENDER);
+      runLaneEffects(EFFECT_USER);
+      this.run(EFFECT_USER);
+    } finally {
+      this._running = false;
+    }
+  }
+  notify(node, mask, flags, error) {
+    if (mask & STATUS_PENDING) {
+      if (_onUnhandledAsync && flags & STATUS_PENDING) {
+        _onUnhandledAsync();
+      }
+      if (flags & STATUS_PENDING) {
+        const actualError = error !== void 0 ? error : node._error;
+        if (activeTransition && actualError && !activeTransition._asyncNodes.includes(actualError.source)) {
+          activeTransition._asyncNodes.push(actualError.source);
+          schedule();
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  initTransition(transition) {
+    if (transition) transition = currentTransition(transition);
+    if (transition && transition === activeTransition) return;
+    if (!transition && activeTransition && activeTransition._time === clock) return;
+    if (!activeTransition) {
+      activeTransition = transition ?? {
+        _time: clock,
+        _pendingNodes: [],
+        _asyncNodes: [],
+        _optimisticNodes: [],
+        _optimisticStores: /* @__PURE__ */ new Set(),
+        _actions: [],
+        _queueStash: { _queues: [[], []], _children: [] },
+        _done: false
+      };
+    } else if (transition) {
+      const outgoing = activeTransition;
+      outgoing._done = transition;
+      transition._actions.push(...outgoing._actions);
+      for (const lane of activeLanes) {
+        if (lane._transition === outgoing) lane._transition = transition;
+      }
+      transition._optimisticNodes.push(...outgoing._optimisticNodes);
+      for (const store of outgoing._optimisticStores) {
+        transition._optimisticStores.add(store);
+      }
+      transitions.delete(outgoing);
+      activeTransition = transition;
+    }
+    transitions.add(activeTransition);
+    activeTransition._time = clock;
+    for (let i = 0; i < this._pendingNodes.length; i++) {
+      const n = this._pendingNodes[i];
+      n._transition = activeTransition;
+      activeTransition._pendingNodes.push(n);
+    }
+    this._pendingNodes = activeTransition._pendingNodes;
+    for (let i = 0; i < this._optimisticNodes.length; i++) {
+      const node = this._optimisticNodes[i];
+      node._transition = activeTransition;
+      activeTransition._optimisticNodes.push(node);
+    }
+    this._optimisticNodes = activeTransition._optimisticNodes;
+    for (const lane of activeLanes) {
+      if (!lane._transition) lane._transition = activeTransition;
+    }
+    for (const store of this._optimisticStores) activeTransition._optimisticStores.add(store);
+    this._optimisticStores = activeTransition._optimisticStores;
+  }
+};
+function insertSubs(node, optimistic = false) {
+  const sourceLane = node._optimisticLane || currentOptimisticLane;
+  const hasSnapshot = node._snapshotValue !== void 0;
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    if (hasSnapshot && s._sub._inSnapshotScope) {
+      s._sub._flags |= REACTIVE_SNAPSHOT_STALE;
+      continue;
+    }
+    if (optimistic && sourceLane) {
+      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(s._sub, sourceLane);
+    } else if (optimistic) {
+      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      s._sub._optimisticLane = void 0;
+    }
+    const sub = s._sub;
+    if (sub._type === EFFECT_TRACKED) {
+      if (!sub._modified) {
+        sub._modified = true;
+        sub._queue.enqueue(EFFECT_USER, sub._run);
+      }
+      continue;
+    }
+    const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (queue._min > s._sub._height) queue._min = s._sub._height;
+    insertIntoHeap(s._sub, queue);
+  }
+}
+function finalizePureQueue(completingTransition = null, incomplete = false) {
+  let resolvePending = !incomplete;
+  if (!incomplete) checkBoundaryChildren(globalQueue);
+  if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
+  if (resolvePending) {
+    const pendingNodes = globalQueue._pendingNodes;
+    for (let i = 0; i < pendingNodes.length; i++) {
+      const n = pendingNodes[i];
+      if (n._pendingValue !== NOT_PENDING) {
+        n._value = n._pendingValue;
+        n._pendingValue = NOT_PENDING;
+        if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
+      }
+      if (!(n._statusFlags & STATUS_PENDING)) n._statusFlags &= ~STATUS_UNINITIALIZED;
+      if (n._fn) GlobalQueue._dispose(n, false, true);
+    }
+    pendingNodes.length = 0;
+    const optimisticNodes = completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes;
+    for (let i = 0; i < optimisticNodes.length; i++) {
+      const n = optimisticNodes[i];
+      const original = n._pendingValue;
+      n._optimisticLane = void 0;
+      if (original !== NOT_PENDING && n._value !== original) {
+        n._value = original;
+        insertSubs(n, true);
+      }
+      n._pendingValue = NOT_PENDING;
+      n._transition = null;
+    }
+    optimisticNodes.length = 0;
+    const optimisticStores = completingTransition ? completingTransition._optimisticStores : globalQueue._optimisticStores;
+    if (GlobalQueue._clearOptimisticStore && optimisticStores.size) {
+      for (const store of optimisticStores) {
+        GlobalQueue._clearOptimisticStore(store);
+      }
+      optimisticStores.clear();
+      schedule();
+    }
+    for (const lane of activeLanes) {
+      const owned = completingTransition ? lane._transition === completingTransition : !lane._transition;
+      if (!owned) continue;
+      if (!lane._mergedInto) {
+        if (lane._effectQueues[0].length) runQueue(lane._effectQueues[0], EFFECT_RENDER);
+        if (lane._effectQueues[1].length) runQueue(lane._effectQueues[1], EFFECT_USER);
+      }
+      if (lane._source._optimisticLane === lane) lane._source._optimisticLane = void 0;
+      lane._pendingAsync.clear();
+      lane._effectQueues[0].length = 0;
+      lane._effectQueues[1].length = 0;
+      activeLanes.delete(lane);
+      signalLanes.delete(lane._source);
+    }
+  }
+}
+function checkBoundaryChildren(queue) {
+  for (const child of queue._children) {
+    child.checkSources?.();
+    checkBoundaryChildren(child);
+  }
+}
+function reassignPendingTransition(pendingNodes) {
+  for (let i = 0; i < pendingNodes.length; i++) {
+    pendingNodes[i]._transition = activeTransition;
+  }
+}
+var globalQueue = new GlobalQueue();
+function flush() {
+  let count = 0;
+  while (scheduled) {
+    if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
+    globalQueue.flush();
+  }
+}
+function runQueue(queue, type) {
+  for (let i = 0; i < queue.length; i++) queue[i](type);
+}
+function transitionComplete(transition) {
+  if (transition._done) return true;
+  if (transition._actions.length) return false;
+  let done = true;
+  for (let i = 0; i < transition._asyncNodes.length; i++) {
+    const node = transition._asyncNodes[i];
+    if (node._statusFlags & STATUS_PENDING && node._error?.source === node) {
+      done = false;
+      break;
+    }
+  }
+  done && (transition._done = true);
+  return done;
+}
+function currentTransition(transition) {
+  while (transition._done && typeof transition._done === "object") transition = transition._done;
+  return transition;
+}
+function runInTransition(transition, fn) {
+  const prevTransition = activeTransition;
+  try {
+    activeTransition = currentTransition(transition);
+    return fn();
+  } finally {
+    activeTransition = prevTransition;
+  }
+}
+var signalLanes = /* @__PURE__ */ new WeakMap();
+var activeLanes = /* @__PURE__ */ new Set();
+function getOrCreateLane(signal) {
+  let lane = signalLanes.get(signal);
+  if (lane) {
+    return findLane(lane);
+  }
+  const parentSource = signal._parentSource;
+  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
+  lane = {
+    _source: signal,
+    _pendingAsync: /* @__PURE__ */ new Set(),
+    _effectQueues: [[], []],
+    _mergedInto: null,
+    _transition: activeTransition,
+    _parentLane: parentLane
+  };
+  signalLanes.set(signal, lane);
+  activeLanes.add(lane);
+  signal._laneVersion = signal._overrideVersion || 0;
+  return lane;
+}
+function findLane(lane) {
+  while (lane._mergedInto) lane = lane._mergedInto;
+  return lane;
+}
+function mergeLanes(lane1, lane2) {
+  lane1 = findLane(lane1);
+  lane2 = findLane(lane2);
+  if (lane1 === lane2) return lane1;
+  lane2._mergedInto = lane1;
+  for (const node of lane2._pendingAsync) lane1._pendingAsync.add(node);
+  lane1._effectQueues[0].push(...lane2._effectQueues[0]);
+  lane1._effectQueues[1].push(...lane2._effectQueues[1]);
+  return lane1;
+}
+function resolveLane(el) {
+  const lane = el._optimisticLane;
+  if (!lane) return void 0;
+  const root = findLane(lane);
+  if (activeLanes.has(root)) return root;
+  el._optimisticLane = void 0;
+  return void 0;
+}
+function hasActiveOverride(el) {
+  return !!(el._optimistic && el._pendingValue !== NOT_PENDING);
+}
+function assignOrMergeLane(el, sourceLane) {
+  const sourceRoot = findLane(sourceLane);
+  const existing = el._optimisticLane;
+  if (existing) {
+    if (existing._mergedInto) {
+      el._optimisticLane = sourceLane;
+      return;
+    }
+    const existingRoot = findLane(existing);
+    if (activeLanes.has(existingRoot)) {
+      if (existingRoot !== sourceRoot && !hasActiveOverride(el)) {
+        if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
+          el._optimisticLane = sourceLane;
+        } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot) ;
+        else mergeLanes(sourceRoot, existingRoot);
+      }
+      return;
+    }
+  }
+  el._optimisticLane = sourceLane;
+}
+function handleAsync(el, result, setter) {
+  const isObject = typeof result === "object" && result !== null;
+  const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
+  const isThenable = !iterator && isObject && untrack(() => typeof result.then === "function");
+  if (!isThenable && !iterator) {
+    el._inFlight = null;
+    return result;
+  }
+  el._inFlight = result;
+  let syncValue;
+  const handleError = (error) => {
+    if (el._inFlight !== result) return;
+    globalQueue.initTransition(el._transition);
+    notifyStatus(el, error instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, error);
+    el._time = clock;
+  };
+  const asyncWrite = (value, then) => {
+    if (el._inFlight !== result) return;
+    if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    globalQueue.initTransition(el._transition);
+    clearStatus(el);
+    const lane = resolveLane(el);
+    if (lane) lane._pendingAsync.delete(el);
+    if (el._optimistic) {
+      const hadOverride = el._pendingValue !== NOT_PENDING;
+      if (el._fn) el._pendingValue = value;
+      if (!hadOverride) {
+        el._value = value;
+        insertSubs(el);
+      }
+      el._time = clock;
+    } else if (lane) {
+      const prevValue = el._value;
+      const equals = el._equals;
+      if (!equals || !equals(value, prevValue)) {
+        el._value = value;
+        el._time = clock;
+        if (el._latestValueComputed) {
+          setSignal(el._latestValueComputed, value);
+        }
+        insertSubs(el, true);
+      }
+    } else {
+      setSignal(el, () => value);
+    }
+    schedule();
+    flush();
+    then?.();
+  };
+  if (isThenable) {
+    let resolved = false, isSync = true;
+    result.then(
+      (v) => {
+        if (isSync) {
+          syncValue = v;
+          resolved = true;
+        } else asyncWrite(v);
+      },
+      (e) => {
+        if (!isSync) handleError(e);
+      }
+    );
+    isSync = false;
+    if (!resolved) {
+      globalQueue.initTransition(el._transition);
+      throw new NotReadyError(context);
+    }
+  }
+  if (iterator) {
+    const it = result[Symbol.asyncIterator]();
+    let hadSyncValue = false;
+    const iterate = () => {
+      let syncResult, resolved = false, isSync = true;
+      it.next().then(
+        (r) => {
+          if (isSync) {
+            syncResult = r;
+            resolved = true;
+          } else if (!r.done) asyncWrite(r.value, iterate);
+          else {
+            schedule();
+            flush();
+          }
+        },
+        (e) => {
+          if (!isSync) handleError(e);
+        }
+      );
+      isSync = false;
+      if (resolved && !syncResult.done) {
+        syncValue = syncResult.value;
+        hadSyncValue = true;
+        return iterate();
+      }
+      return resolved && syncResult.done;
+    };
+    const immediatelyDone = iterate();
+    if (!hadSyncValue && !immediatelyDone) {
+      globalQueue.initTransition(el._transition);
+      throw new NotReadyError(context);
+    }
+  }
+  return syncValue;
+}
+function clearStatus(el) {
+  el._statusFlags = el._statusFlags & STATUS_UNINITIALIZED;
+  el._error = null;
+  updatePendingSignal(el);
+  el._notifyStatus?.();
+}
+function notifyStatus(el, status, error, blockStatus, lane) {
+  if (status === STATUS_ERROR && !(error instanceof StatusError) && !(error instanceof NotReadyError))
+    error = new StatusError(el, error);
+  const isSource = error instanceof NotReadyError && error.source === el;
+  const isOptimisticBoundary = status === STATUS_PENDING && el._optimistic && !isSource;
+  const startsBlocking = isOptimisticBoundary && hasActiveOverride(el);
+  if (!blockStatus) {
+    el._statusFlags = status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
+    el._error = error;
+    updatePendingSignal(el);
+  }
+  if (lane && !blockStatus) {
+    assignOrMergeLane(el, lane);
+  }
+  if (startsBlocking && activeTransition && error instanceof NotReadyError) {
+    const source = error.source;
+    if (!activeTransition._asyncNodes.includes(source)) {
+      activeTransition._asyncNodes.push(source);
+    }
+  }
+  const downstreamBlockStatus = blockStatus || startsBlocking;
+  const downstreamLane = blockStatus || isOptimisticBoundary ? void 0 : lane;
+  if (el._notifyStatus) {
+    if (downstreamBlockStatus) {
+      el._notifyStatus(status, error);
+    } else {
+      el._notifyStatus();
+    }
+    return;
+  }
+  for (let s = el._subs; s !== null; s = s._nextSub) {
+    s._sub._time = clock;
+    if (s._sub._error !== error) {
+      !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
+      notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
+    }
+  }
+  for (let child = el._child; child !== null; child = child._nextChild) {
+    for (let s = child._subs; s !== null; s = s._nextSub) {
+      s._sub._time = clock;
+      if (s._sub._error !== error) {
+        !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
+        notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
+      }
+    }
+  }
+}
+function unlinkSubs(link) {
+  const dep = link._dep;
+  const nextDep = link._nextDep;
+  const nextSub = link._nextSub;
+  const prevSub = link._prevSub;
+  if (nextSub !== null) nextSub._prevSub = prevSub;
+  else dep._subsTail = prevSub;
+  if (prevSub !== null) prevSub._nextSub = nextSub;
+  else {
+    dep._subs = nextSub;
+    if (nextSub === null) {
+      dep._unobserved?.();
+      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
+    }
+  }
+  return nextDep;
+}
+function unobserved(el) {
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let dep = el._deps;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el._deps = null;
+  disposeChildren(el, true);
+}
+function markDisposal(el) {
+  let child = el._firstChild;
+  while (child) {
+    child._flags |= REACTIVE_ZOMBIE;
+    if (child._flags & REACTIVE_IN_HEAP) {
+      deleteFromHeap(child, dirtyQueue);
+      insertIntoHeap(child, zombieQueue);
+    }
+    markDisposal(child);
+    child = child._nextSibling;
+  }
+}
+function disposeChildren(node, self = false, zombie) {
+  if (node._flags & REACTIVE_DISPOSED) return;
+  if (self) node._flags = REACTIVE_DISPOSED;
+  let child = zombie ? node._pendingFirstChild : node._firstChild;
+  while (child) {
+    const nextChild = child._nextSibling;
+    if (child._deps) {
+      const n = child;
+      deleteFromHeap(n, n._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let toRemove = n._deps;
+      do {
+        toRemove = unlinkSubs(toRemove);
+      } while (toRemove !== null);
+      n._deps = null;
+      n._depsTail = null;
+    }
+    disposeChildren(child, true);
+    child = nextChild;
+  }
+  if (zombie) {
+    node._pendingFirstChild = null;
+  } else {
+    node._firstChild = null;
+    node._nextSibling = null;
+    node._childCount = 0;
+  }
+  runDisposal(node, zombie);
+}
+function runDisposal(node, zombie) {
+  let disposal = zombie ? node._pendingDisposal : node._disposal;
+  if (!disposal) return;
+  if (Array.isArray(disposal)) {
+    for (let i = 0; i < disposal.length; i++) {
+      const callable = disposal[i];
+      callable.call(callable);
+    }
+  } else {
+    disposal.call(disposal);
+  }
+  zombie ? node._pendingDisposal = null : node._disposal = null;
+}
+var leafEffectActive = false;
+GlobalQueue._update = recompute;
+GlobalQueue._dispose = disposeChildren;
+var tracking = false;
+var context = null;
+var currentOptimisticLane = null;
+function recompute(el, create = false) {
+  const isEffect = el._type;
+  if (!create) {
+    if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
+      globalQueue.initTransition(el._transition);
+    deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
+    else {
+      markDisposal(el);
+      el._pendingDisposal = el._disposal;
+      el._pendingFirstChild = el._firstChild;
+      el._disposal = null;
+      el._firstChild = null;
+      el._childCount = 0;
+    }
+  }
+  const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
+  const hasOverride = hasActiveOverride(el);
+  const wasPending = !!(el._statusFlags & STATUS_PENDING);
+  const oldcontext = context;
+  context = el;
+  el._depsTail = null;
+  el._flags = REACTIVE_RECOMPUTING_DEPS;
+  el._time = clock;
+  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  let oldHeight = el._height;
+  let prevTracking = tracking;
+  let prevLane = currentOptimisticLane;
+  let prevStrictRead = false;
+  {
+    prevStrictRead = strictRead;
+    strictRead = false;
+  }
+  tracking = true;
+  if (isOptimisticDirty) {
+    const lane = resolveLane(el);
+    if (lane) currentOptimisticLane = lane;
+  }
+  try {
+    value = handleAsync(el, el._fn(value));
+    clearStatus(el);
+    const resolvedLane = resolveLane(el);
+    if (resolvedLane) {
+      resolvedLane._pendingAsync.delete(el);
+      updatePendingSignal(resolvedLane._source);
+    }
+  } catch (e) {
+    if (e instanceof NotReadyError && currentOptimisticLane) {
+      const lane = findLane(currentOptimisticLane);
+      if (lane._source !== el) {
+        lane._pendingAsync.add(el);
+        el._optimisticLane = lane;
+        updatePendingSignal(lane._source);
+      }
+    }
+    notifyStatus(
+      el,
+      e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
+      e,
+      void 0,
+      e instanceof NotReadyError ? el._optimisticLane : void 0
+    );
+  } finally {
+    tracking = prevTracking;
+    strictRead = prevStrictRead;
+    el._flags = REACTIVE_NONE | (create ? el._flags & REACTIVE_SNAPSHOT_STALE : 0);
+    context = oldcontext;
+  }
+  if (!el._error) {
+    const depsTail = el._depsTail;
+    let toRemove = depsTail !== null ? depsTail._nextDep : el._deps;
+    if (toRemove !== null) {
+      do {
+        toRemove = unlinkSubs(toRemove);
+      } while (toRemove !== null);
+      if (depsTail !== null) depsTail._nextDep = null;
+      else el._deps = null;
+    }
+    const compareValue = hasOverride ? el._value : el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+    const valueChanged = !el._equals || !el._equals(compareValue, value);
+    if (valueChanged) {
+      const prevVisible = hasOverride ? el._value : void 0;
+      if (create || isEffect && activeTransition !== el._transition || isOptimisticDirty)
+        el._value = value;
+      else el._pendingValue = value;
+      if (hasOverride && !isOptimisticDirty && wasPending) {
+        const ov = el._overrideVersion || 0;
+        const lv = el._laneVersion || 0;
+        if (ov <= lv) el._value = value;
+      }
+      if (!hasOverride || isOptimisticDirty || el._value !== prevVisible) {
+        insertSubs(el, isOptimisticDirty || hasOverride);
+      }
+    } else if (hasOverride) {
+      el._pendingValue = value;
+    } else if (el._height != oldHeight) {
+      for (let s = el._subs; s !== null; s = s._nextSub) {
+        insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
+    }
+  }
+  currentOptimisticLane = prevLane;
+  (!create || el._statusFlags & STATUS_PENDING) && !el._transition && !(activeTransition && el._optimistic) && globalQueue._pendingNodes.push(el);
+  el._transition && isEffect && activeTransition !== el._transition && runInTransition(el._transition, () => recompute(el));
+}
+var strictRead = false;
+function untrack(fn, strictReadLabel) {
+  if (!tracking && !strictRead && true) return fn();
+  const prevTracking = tracking;
+  const prevStrictRead = strictRead;
+  tracking = false;
+  strictRead = false;
+  try {
+    return fn();
+  } finally {
+    tracking = prevTracking;
+    strictRead = prevStrictRead;
+  }
+}
+function setSignal(el, v) {
+  if (!el._pureWrite && !leafEffectActive && context && el._firewall !== context)
+    console.warn("A Signal was written to in an owned scope.");
+  if (el._transition && activeTransition !== el._transition)
+    globalQueue.initTransition(el._transition);
+  const isOptimistic = el._optimistic && !projectionWriteActive;
+  const currentValue = isOptimistic ? el._value : el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  if (typeof v === "function") v = v(currentValue);
+  const valueChanged = !el._equals || !el._equals(currentValue, v) || !!(el._statusFlags & STATUS_UNINITIALIZED);
+  if (!valueChanged) {
+    if (isOptimistic && el._pendingValue !== NOT_PENDING && el._fn) {
+      insertSubs(el, true);
+      schedule();
+    }
+    return v;
+  }
+  if (isOptimistic) {
+    const alreadyTracked = globalQueue._optimisticNodes.includes(el);
+    if (el._transition && alreadyTracked) {
+      globalQueue.initTransition(el._transition);
+    }
+    if (el._pendingValue === NOT_PENDING) {
+      el._pendingValue = el._value;
+    }
+    if (!alreadyTracked) {
+      globalQueue._optimisticNodes.push(el);
+    }
+    el._overrideVersion = (el._overrideVersion || 0) + 1;
+    const lane = getOrCreateLane(el);
+    el._optimisticLane = lane;
+    el._value = v;
+  } else {
+    if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
+    el._pendingValue = v;
+  }
+  updatePendingSignal(el);
+  if (el._latestValueComputed) {
+    setSignal(el._latestValueComputed, v);
+  }
+  el._time = clock;
+  insertSubs(el, isOptimistic);
+  schedule();
+  return v;
+}
+function computePendingState(el) {
+  const comp = el;
+  if (el._optimistic && el._pendingValue !== NOT_PENDING) {
+    if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
+      return true;
+    if (el._parentSource) {
+      const lane = el._optimisticLane ? findLane(el._optimisticLane) : null;
+      return !!(lane && lane._pendingAsync.size > 0);
+    }
+    return true;
+  }
+  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
+  return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
+}
+function updatePendingSignal(el) {
+  if (el._pendingSignal) {
+    const pending = computePendingState(el);
+    const sig = el._pendingSignal;
+    setSignal(sig, pending);
+    if (!pending && sig._optimisticLane) {
+      const sourceLane = resolveLane(el);
+      if (sourceLane && sourceLane._pendingAsync.size > 0) {
+        const sigLane = findLane(sig._optimisticLane);
+        if (sigLane !== sourceLane) {
+          mergeLanes(sourceLane, sigLane);
+        }
+      }
+      signalLanes.delete(sig);
+      sig._optimisticLane = void 0;
+    }
+  }
+}
+function isWrappable(obj) {
+  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
+}
+var DELETE = /* @__PURE__ */ Symbol("STORE_PATH_DELETE");
+function updatePath(current, args, i = 0) {
+  let part, prev = current;
+  if (i < args.length - 1) {
+    part = args[i];
+    const partType = typeof part;
+    const isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let j = 0; j < part.length; j++) {
+        args[i] = part[j];
+        updatePath(current, args, i);
+      }
+      args[i] = part;
+      return;
+    } else if (isArray && partType === "function") {
+      for (let j = 0; j < current.length; j++) {
+        if (part(current[j], j)) {
+          args[i] = j;
+          updatePath(current, args, i);
+        }
+      }
+      args[i] = part;
+      return;
+    } else if (isArray && partType === "object") {
+      const { from = 0, to = current.length - 1, by = 1 } = part;
+      for (let j = from; j <= to; j += by) {
+        args[i] = j;
+        updatePath(current, args, i);
+      }
+      args[i] = part;
+      return;
+    } else if (i < args.length - 2) {
+      updatePath(current[part], args, i + 1);
+      return;
+    }
+    prev = current[part];
+  }
+  let value = args[args.length - 1];
+  if (typeof value === "function") {
+    value = value(prev);
+    if (value === prev) return;
+  }
+  if (part === void 0 && value == void 0) return;
+  if (value === DELETE) {
+    delete current[part];
+  } else if (part === void 0 || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
+    const target = part !== void 0 ? current[part] : current;
+    const keys = Object.keys(value);
+    for (let i2 = 0; i2 < keys.length; i2++) target[keys[i2]] = value[keys[i2]];
+  } else {
+    current[part] = value;
+  }
+}
+Object.assign(
+  function storePath2(...args) {
+    return (state) => {
+      updatePath(state, args);
+    };
+  },
+  { DELETE }
+);
+
+// ../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.2_@solidjs+signals@0.12.0_solid-js@2.0.0-beta.2/node_modules/@solidjs/web/dist/dev.js
+var effect = (fn, effectFn, initial) => createRenderEffect(fn, effectFn, initial, {
+  transparent: true
+});
+function template(html, isImportNode, isSVG, isMathML) {
+  let node;
+  const create = (bypassGuard) => {
+    if (isHydrating() && !bypassGuard) throw new Error("Failed attempt to create new DOM elements during hydration. Check that the libraries you are using support hydration.");
+    const t = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "template") : document.createElement("template");
+    t.innerHTML = html;
+    return isSVG ? t.content.firstChild.firstChild : isMathML ? t.firstChild : t.content.firstChild;
+  };
+  const fn = isImportNode ? (bypassGuard) => untrack$1(() => document.importNode(node || (node = create(bypassGuard)), true)) : (bypassGuard) => (node || (node = create(bypassGuard))).cloneNode(true);
+  fn._html = html;
+  return fn;
+}
+function setAttribute(node, name, value) {
+  if (isHydrating(node)) return;
+  node.removeAttribute(name);
+}
+function style(node, value, prev) {
+  if (!value) {
+    if (prev) setAttribute(node, "style");
+    return;
+  }
+  const nodeStyle = node.style;
+  if (typeof value === "string") return nodeStyle.cssText = value;
+  typeof prev === "string" && (nodeStyle.cssText = prev = void 0);
+  prev || (prev = {});
+  value || (value = {});
+  let v, s;
+  for (s in value) {
+    v = value[s];
+    if (v !== prev[s]) nodeStyle.setProperty(s, v);
+    delete prev[s];
+  }
+  for (s in prev) value[s] == null && nodeStyle.removeProperty(s);
+}
+function applyRef(r, element) {
+  Array.isArray(r) ? r.flat(Infinity).forEach((f) => f && f(element)) : r(element);
+}
+function ref(fn, element) {
+  const resolved = untrack$1(fn);
+  runWithOwner(null, () => applyRef(resolved, element));
+}
+function isHydrating(node) {
+  return sharedConfig.hydrating && (!node || node.isConnected);
+}
+var isServer = false;
+var isDev = true;
+
+export { effect, isDev, isServer, ref, style, template };