@tanstack/solid-query-devtools 6.0.0-beta.3 → 6.0.0-beta.4

package/build/chunk/ZANDWIFD.js

@@ -1,1260 +0,0 @@
-import { createRenderEffect, untrack as untrack$1, runWithOwner, sharedConfig } from 'solid-js';
-
-// ../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.4_@solidjs+signals@0.13.9_solid-js@2.0.0-beta.5/node_modules/@solidjs/web/dist/dev.js
-
-// ../../node_modules/.pnpm/@solidjs+signals@0.13.9/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 inTrackedQueueCallback = false;
-var stashedOptimisticReads = 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 queueStashedOptimisticEffects(node) {
-  for (let s = node._subs; s !== null; s = s._nextSub) {
-    const sub = s._sub;
-    if (!sub._type) continue;
-    if (sub._type === EFFECT_TRACKED) {
-      if (!sub._modified) {
-        sub._modified = true;
-        sub._queue.enqueue(EFFECT_USER, sub._run);
-      }
-      continue;
-    }
-    const queue = sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-    if (queue._min > sub._height) queue._min = sub._height;
-    insertIntoHeap(sub, queue);
-  }
-}
-function mergeTransitionState(target, outgoing) {
-  outgoing._done = target;
-  target._actions.push(...outgoing._actions);
-  for (const lane of activeLanes) {
-    if (lane._transition === outgoing) lane._transition = target;
-  }
-  target._optimisticNodes.push(...outgoing._optimisticNodes);
-  for (const store of outgoing._optimisticStores) target._optimisticStores.add(store);
-  for (const node of outgoing._asyncNodes) {
-    if (!target._asyncNodes.includes(node)) target._asyncNodes.push(node);
-  }
-}
-function resolveOptimisticNodes(nodes) {
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    node._optimisticLane = void 0;
-    if (node._pendingValue !== NOT_PENDING) {
-      node._value = node._pendingValue;
-      node._pendingValue = NOT_PENDING;
-    }
-    const prevOverride = node._overrideValue;
-    node._overrideValue = NOT_PENDING;
-    if (prevOverride !== NOT_PENDING && node._value !== prevOverride) insertSubs(node, true);
-    node._transition = null;
-  }
-  nodes.length = 0;
-}
-function cleanupCompletedLanes(completingTransition) {
-  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 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) {
-          const stashedTransition = activeTransition;
-          runHeap(zombieQueue, _GlobalQueue._update);
-          this._pendingNodes = [];
-          this._optimisticNodes = [];
-          this._optimisticStores = /* @__PURE__ */ new Set();
-          runLaneEffects(EFFECT_RENDER);
-          runLaneEffects(EFFECT_USER);
-          this.stashQueues(stashedTransition._queueStash);
-          clock++;
-          scheduled = dirtyQueue._max >= dirtyQueue._min;
-          reassignPendingTransition(stashedTransition._pendingNodes);
-          activeTransition = null;
-          if (!stashedTransition._actions.length && stashedTransition._optimisticNodes.length) {
-            stashedOptimisticReads = /* @__PURE__ */ new Set();
-            for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
-              const node = stashedTransition._optimisticNodes[i];
-              if (node._fn || node._pureWrite) continue;
-              stashedOptimisticReads.add(node);
-              queueStashedOptimisticEffects(node);
-            }
-          }
-          try {
-            finalizePureQueue(null, true);
-          } finally {
-            stashedOptimisticReads = null;
-          }
-          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 (flags & STATUS_PENDING) {
-        const actualError = error !== void 0 ? error : node._error;
-        if (activeTransition && actualError) {
-          const source = actualError.source;
-          if (!activeTransition._asyncNodes.includes(source)) {
-            activeTransition._asyncNodes.push(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;
-      mergeTransitionState(transition, outgoing);
-      transitions.delete(outgoing);
-      activeTransition = transition;
-    }
-    transitions.add(activeTransition);
-    activeTransition._time = clock;
-    if (this._pendingNodes !== activeTransition._pendingNodes) {
-      for (let i = 0; i < this._pendingNodes.length; i++) {
-        const node = this._pendingNodes[i];
-        node._transition = activeTransition;
-        activeTransition._pendingNodes.push(node);
-      }
-      this._pendingNodes = activeTransition._pendingNodes;
-    }
-    if (this._optimisticNodes !== activeTransition._optimisticNodes) {
-      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;
-    }
-    if (this._optimisticStores !== activeTransition._optimisticStores) {
-      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 commitPendingNodes() {
-  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;
-}
-function finalizePureQueue(completingTransition = null, incomplete = false) {
-  const resolvePending = !incomplete;
-  if (resolvePending) commitPendingNodes();
-  if (!incomplete) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
-  if (resolvePending) {
-    commitPendingNodes();
-    resolveOptimisticNodes(
-      completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes
-    );
-    const optimisticStores = completingTransition ? completingTransition._optimisticStores : globalQueue._optimisticStores;
-    if (GlobalQueue._clearOptimisticStore && optimisticStores.size) {
-      for (const store of optimisticStores) {
-        GlobalQueue._clearOptimisticStore(store);
-      }
-      optimisticStores.clear();
-      schedule();
-    }
-    cleanupCompletedLanes(completingTransition);
-  }
-}
-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() {
-  if (globalQueue._running) {
-    if (inTrackedQueueCallback) {
-      throw new Error(
-        "Cannot call flush() from inside onSettled or createTrackedEffect. flush() is not reentrant there."
-      );
-    }
-    return;
-  }
-  let count = 0;
-  while (scheduled || activeTransition) {
-    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;
-    }
-  }
-  if (done) {
-    for (let i = 0; i < transition._optimisticNodes.length; i++) {
-      const node = transition._optimisticNodes[i];
-      if (hasActiveOverride(node) && "_statusFlags" in node && node._statusFlags & STATUS_PENDING && node._error instanceof NotReadyError && 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._overrideSinceLane = false;
-  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 resolveTransition(el) {
-  return resolveLane(el)?._transition ?? el._transition;
-}
-function hasActiveOverride(el) {
-  return !!(el._overrideValue !== void 0 && el._overrideValue !== 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 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;
-  if (self && node._fn) node._inFlight = null;
-  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._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;
-}
-function cleanup(fn) {
-  if (!context) return fn;
-  if (!context._disposal) context._disposal = fn;
-  else if (Array.isArray(context._disposal)) context._disposal.push(fn);
-  else context._disposal = [context._disposal, fn];
-  return fn;
-}
-function addPendingSource(el, source) {
-  if (el._pendingSource === source || el._pendingSources?.has(source)) return false;
-  if (!el._pendingSource) {
-    el._pendingSource = source;
-    return true;
-  }
-  if (!el._pendingSources) {
-    el._pendingSources = /* @__PURE__ */ new Set([el._pendingSource, source]);
-  } else {
-    el._pendingSources.add(source);
-  }
-  el._pendingSource = void 0;
-  return true;
-}
-function removePendingSource(el, source) {
-  if (el._pendingSource) {
-    if (el._pendingSource !== source) return false;
-    el._pendingSource = void 0;
-    return true;
-  }
-  if (!el._pendingSources?.delete(source)) return false;
-  if (el._pendingSources.size === 1) {
-    el._pendingSource = el._pendingSources.values().next().value;
-    el._pendingSources = void 0;
-  } else if (el._pendingSources.size === 0) {
-    el._pendingSources = void 0;
-  }
-  return true;
-}
-function clearPendingSources(el) {
-  el._pendingSource = void 0;
-  el._pendingSources?.clear();
-  el._pendingSources = void 0;
-}
-function setPendingError(el, source, error) {
-  if (!source) {
-    el._error = null;
-    return;
-  }
-  if (error instanceof NotReadyError && error.source === source) {
-    el._error = error;
-    return;
-  }
-  const current = el._error;
-  if (!(current instanceof NotReadyError) || current.source !== source) {
-    el._error = new NotReadyError(source);
-  }
-}
-function forEachDependent(el, fn) {
-  for (let s = el._subs; s !== null; s = s._nextSub) fn(s._sub);
-  for (let child = el._child; child !== null; child = child._nextChild) {
-    for (let s = child._subs; s !== null; s = s._nextSub) fn(s._sub);
-  }
-}
-function settlePendingSource(el) {
-  let scheduled2 = false;
-  const visited = /* @__PURE__ */ new Set();
-  const settle = (node) => {
-    if (visited.has(node) || !removePendingSource(node, el)) return;
-    visited.add(node);
-    node._time = clock;
-    const source = node._pendingSource ?? node._pendingSources?.values().next().value;
-    if (source) {
-      setPendingError(node, source);
-      updatePendingSignal(node);
-    } else {
-      node._statusFlags &= ~STATUS_PENDING;
-      setPendingError(node);
-      updatePendingSignal(node);
-      if (node._blocked) {
-        if (node._type === EFFECT_TRACKED) {
-          const tracked = node;
-          if (!tracked._modified) {
-            tracked._modified = true;
-            tracked._queue.enqueue(EFFECT_USER, tracked._run);
-          }
-        } else {
-          const queue = node._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-          if (queue._min > node._height) queue._min = node._height;
-          insertIntoHeap(node, queue);
-        }
-        scheduled2 = true;
-      }
-      node._blocked = false;
-    }
-    forEachDependent(node, settle);
-  };
-  forEachDependent(el, settle);
-  if (scheduled2) schedule();
-}
-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(resolveTransition(el));
-    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(resolveTransition(el));
-    clearStatus(el);
-    const lane = resolveLane(el);
-    if (lane) lane._pendingAsync.delete(el);
-    if (el._overrideValue !== void 0) {
-      if (el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING)
-        el._pendingValue = value;
-      else {
-        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);
-    }
-    settlePendingSource(el);
-    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(resolveTransition(el));
-      throw new NotReadyError(context);
-    }
-  }
-  if (iterator) {
-    const it = result[Symbol.asyncIterator]();
-    let hadSyncValue = false;
-    let completed = false;
-    cleanup(() => {
-      if (completed) return;
-      completed = true;
-      try {
-        const returned = it.return?.();
-        if (returned && typeof returned.then === "function") {
-          returned.then(void 0, () => {
-          });
-        }
-      } catch {
-      }
-    });
-    const iterate = () => {
-      let syncResult, resolved = false, isSync = true;
-      it.next().then(
-        (r) => {
-          if (isSync) {
-            syncResult = r;
-            resolved = true;
-            if (r.done) completed = true;
-          } else if (el._inFlight !== result) {
-            return;
-          } else if (!r.done) asyncWrite(r.value, iterate);
-          else {
-            completed = true;
-            schedule();
-            flush();
-          }
-        },
-        (e) => {
-          if (!isSync && el._inFlight === result) {
-            completed = true;
-            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(resolveTransition(el));
-      throw new NotReadyError(context);
-    }
-  }
-  return syncValue;
-}
-function clearStatus(el, clearUninitialized = false) {
-  clearPendingSources(el);
-  el._blocked = false;
-  el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
-  setPendingError(el);
-  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 pendingSource = status === STATUS_PENDING && error instanceof NotReadyError ? error.source : void 0;
-  const isSource = pendingSource === el;
-  const isOptimisticBoundary = status === STATUS_PENDING && el._overrideValue !== void 0 && !isSource;
-  const startsBlocking = isOptimisticBoundary && hasActiveOverride(el);
-  if (!blockStatus) {
-    if (status === STATUS_PENDING && pendingSource) {
-      addPendingSource(el, pendingSource);
-      el._statusFlags = STATUS_PENDING | el._statusFlags & STATUS_UNINITIALIZED;
-      setPendingError(el, pendingSource, error);
-    } else {
-      clearPendingSources(el);
-      el._statusFlags = status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
-      el._error = error;
-    }
-    updatePendingSignal(el);
-  }
-  if (lane && !blockStatus) {
-    assignOrMergeLane(el, lane);
-  }
-  const downstreamBlockStatus = blockStatus || startsBlocking;
-  const downstreamLane = blockStatus || isOptimisticBoundary ? void 0 : lane;
-  if (el._notifyStatus) {
-    if (blockStatus && status === STATUS_PENDING) {
-      return;
-    }
-    if (downstreamBlockStatus) {
-      el._notifyStatus(status, error);
-    } else {
-      el._notifyStatus();
-    }
-    return;
-  }
-  forEachDependent(el, (sub) => {
-    sub._time = clock;
-    if (status === STATUS_PENDING && pendingSource && sub._pendingSource !== pendingSource && !sub._pendingSources?.has(pendingSource) || status !== STATUS_PENDING && (sub._error !== error || sub._pendingSource || sub._pendingSources)) {
-      if (!downstreamBlockStatus && !sub._transition) globalQueue._pendingNodes.push(sub);
-      notifyStatus(sub, status, error, downstreamBlockStatus, downstreamLane);
-    }
-  });
-}
-var externalSourceConfig = null;
-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);
-    el._inFlight = null;
-    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 = el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING;
-  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, create);
-    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);
-      }
-    }
-    if (e instanceof NotReadyError) el._blocked = true;
-    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._overrideValue : el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
-    const valueChanged = !el._equals || !el._equals(compareValue, value);
-    if (valueChanged) {
-      const prevVisible = hasOverride ? el._overrideValue : void 0;
-      if (create || isEffect && activeTransition !== el._transition || isOptimisticDirty) {
-        el._value = value;
-        if (hasOverride && isOptimisticDirty) {
-          el._overrideValue = value;
-          el._pendingValue = value;
-        }
-      } else el._pendingValue = value;
-      if (hasOverride && !isOptimisticDirty && wasPending && !el._overrideSinceLane)
-        el._overrideValue = value;
-      if (!hasOverride || isOptimisticDirty || el._overrideValue !== 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 && hasOverride) && globalQueue._pendingNodes.push(el);
-  el._transition && isEffect && activeTransition !== el._transition && runInTransition(el._transition, () => recompute(el));
-}
-var strictRead = false;
-function untrack(fn, strictReadLabel) {
-  if (!externalSourceConfig && !tracking && !strictRead && true) return fn();
-  const prevTracking = tracking;
-  const prevStrictRead = strictRead;
-  tracking = false;
-  strictRead = false;
-  try {
-    if (externalSourceConfig) return externalSourceConfig.untrack(fn);
-    return fn();
-  } finally {
-    tracking = prevTracking;
-    strictRead = prevStrictRead;
-  }
-}
-function setSignal(el, v) {
-  if (!el._pureWrite && !context?._childrenForbidden && 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._overrideValue !== void 0 && !projectionWriteActive;
-  const hasOverride = el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING;
-  const currentValue = isOptimistic ? hasOverride ? el._overrideValue : 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 && hasOverride && el._fn) {
-      insertSubs(el, true);
-      schedule();
-    }
-    return v;
-  }
-  if (isOptimistic) {
-    const firstOverride = el._overrideValue === NOT_PENDING;
-    if (!firstOverride) globalQueue.initTransition(resolveTransition(el));
-    if (firstOverride) {
-      el._pendingValue = el._value;
-      globalQueue._optimisticNodes.push(el);
-    }
-    el._overrideSinceLane = true;
-    const lane = getOrCreateLane(el);
-    el._optimisticLane = lane;
-    el._overrideValue = 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;
-  const firewall = el._firewall;
-  if (firewall && el._pendingValue !== NOT_PENDING) {
-    return !firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING);
-  }
-  if (el._overrideValue !== void 0 && el._overrideValue !== 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._overrideValue !== void 0 && el._overrideValue === NOT_PENDING && !el._parentSource) {
-    return false;
-  }
-  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) && !(typeof Node !== "undefined" && obj instanceof Node);
-}
-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.4_@solidjs+signals@0.13.9_solid-js@2.0.0-beta.5/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 };