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

package/build/dev.cjs

@@ -13,1224 +13,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-
-// ../../node_modules/.pnpm/@solidjs+signals@0.13.9/node_modules/@solidjs/signals/dist/dev.js
-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);
-    }
-  }
-}
-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);
-}
-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;
-  }
-}
-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;
-  }
-}
-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 create(html, bypassGuard, flag) {
+  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 = document.createElement("template");
+  t.innerHTML = html;
+  return flag === 2 ? t.content.firstChild.firstChild : t.content.firstChild;
 }
-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);
-    }
-  });
-}
-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));
-}
-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);
-}
-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;
-  }
-}
-var NotReadyError, StatusError, REACTIVE_NONE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_RECOMPUTING_DEPS, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, REACTIVE_DISPOSED, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_SNAPSHOT_STALE, STATUS_PENDING, STATUS_ERROR, STATUS_UNINITIALIZED, EFFECT_RENDER, EFFECT_USER, EFFECT_TRACKED, NOT_PENDING, transitions, dirtyQueue, zombieQueue, clock, activeTransition, scheduled, projectionWriteActive, inTrackedQueueCallback, stashedOptimisticReads, Queue, GlobalQueue, globalQueue, signalLanes, activeLanes, externalSourceConfig, tracking, context, currentOptimisticLane, strictRead, DELETE;
-var init_dev = __esm({
-  "../../node_modules/.pnpm/@solidjs+signals@0.13.9/node_modules/@solidjs/signals/dist/dev.js"() {
-    NotReadyError = class extends Error {
-      source;
-      constructor(source) {
-        super();
-        this.source = source;
-      }
-    };
-    StatusError = class extends Error {
-      source;
-      constructor(source, original) {
-        super(original instanceof Error ? original.message : String(original), { cause: original });
-        this.source = source;
-      }
-    };
-    REACTIVE_NONE = 0;
-    REACTIVE_CHECK = 1 << 0;
-    REACTIVE_DIRTY = 1 << 1;
-    REACTIVE_RECOMPUTING_DEPS = 1 << 2;
-    REACTIVE_IN_HEAP = 1 << 3;
-    REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
-    REACTIVE_ZOMBIE = 1 << 5;
-    REACTIVE_DISPOSED = 1 << 6;
-    REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
-    REACTIVE_SNAPSHOT_STALE = 1 << 8;
-    STATUS_PENDING = 1 << 0;
-    STATUS_ERROR = 1 << 1;
-    STATUS_UNINITIALIZED = 1 << 2;
-    EFFECT_RENDER = 1;
-    EFFECT_USER = 2;
-    EFFECT_TRACKED = 3;
-    NOT_PENDING = {};
-    transitions = /* @__PURE__ */ new Set();
-    dirtyQueue = { _heap: new Array(2e3).fill(void 0), _marked: false, _min: 0, _max: 0 };
-    zombieQueue = { _heap: new Array(2e3).fill(void 0), _marked: false, _min: 0, _max: 0 };
-    clock = 0;
-    activeTransition = null;
-    scheduled = false;
-    projectionWriteActive = false;
-    inTrackedQueueCallback = false;
-    stashedOptimisticReads = null;
-    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);
-        }
-      }
-    };
-    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;
-        }
-      }
-    };
-    globalQueue = new GlobalQueue();
-    signalLanes = /* @__PURE__ */ new WeakMap();
-    activeLanes = /* @__PURE__ */ new Set();
-    externalSourceConfig = null;
-    GlobalQueue._update = recompute;
-    GlobalQueue._dispose = disposeChildren;
-    tracking = false;
-    context = null;
-    currentOptimisticLane = null;
-    strictRead = false;
-    DELETE = /* @__PURE__ */ Symbol("STORE_PATH_DELETE");
-    Object.assign(
-      function storePath2(...args) {
-        return (state) => {
-          updatePath(state, args);
-        };
-      },
-      { DELETE }
-    );
-  }
-});
-function template(html, isImportNode, isSVG, isMathML) {
+function template(html, flag) {
   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 = document.createElement("template");
-    t.innerHTML = html;
-    return t.content.firstChild;
-  };
-  const fn = isImportNode ? (bypassGuard) => solidJs.untrack(() => document.importNode(node || (node = create(bypassGuard)), true)) : (bypassGuard) => (node || (node = create(bypassGuard))).cloneNode(true);
+  const fn = flag === 1 ? (bypassGuard) => document.importNode(node || (node = create(html, bypassGuard, flag)), true) : (bypassGuard) => (node || (node = create(html, bypassGuard, flag))).cloneNode(true);
   fn._html = html;
   return fn;
 }
@@ -1267,10 +58,9 @@ function isHydrating(node) {
   return solidJs.sharedConfig.hydrating && (!node || node.isConnected);
 }
 var effect, isServer, isDev;
-var init_dev2 = __esm({
-  "../../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"() {
-    init_dev();
-    effect = (fn, effectFn, initial) => solidJs.createRenderEffect(fn, effectFn, initial, {
+var init_dev = __esm({
+  "../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.7_@solidjs+signals@2.0.0-beta.7_solid-js@2.0.0-beta.7/node_modules/@solidjs/web/dist/dev.js"() {
+    effect = (fn, effectFn) => solidJs.createRenderEffect(fn, effectFn, {
       transparent: true
     });
     isServer = false;
@@ -1346,8 +136,8 @@ function SolidQueryDevtools(props) {
 var _tmpl$;
 var init_devtools = __esm({
   "src/devtools.tsx"() {
-    init_dev2();
-    init_dev2();
+    init_dev();
+    init_dev();
     _tmpl$ = /* @__PURE__ */ template(`<div class=tsqd-parent-container>`);
   }
 });
@@ -1423,19 +213,19 @@ function SolidQueryDevtoolsPanel(props) {
 var _tmpl$2;
 var init_devtoolsPanel = __esm({
   "src/devtoolsPanel.tsx"() {
-    init_dev2();
-    init_dev2();
-    init_dev2();
-    init_dev2();
+    init_dev();
+    init_dev();
+    init_dev();
+    init_dev();
     _tmpl$2 = /* @__PURE__ */ template(`<div class=tsqd-parent-container style=height:500px>`);
   }
 });
 
 // src/index.tsx
-init_dev2();
+init_dev();
 
 // src/clientOnly.tsx
-init_dev2();
+init_dev();
 function clientOnly(fn) {
   if (isServer) return (props) => props.fallback;
   const [comp, setComp] = solidJs.createSignal();