@tanstack/query-devtools 5.0.0-alpha.84 → 5.0.0-alpha.87

package/{dist/esm/index-7c6d68e3.js → build/chunk/MZOCHHZD.js}

@@ -1,41 +1,48 @@
-const sharedConfig = {};
+// ../../node_modules/.pnpm/solid-js@1.6.13/node_modules/solid-js/dist/solid.js
+var sharedConfig = {};
 function setHydrateContext(context) {
   sharedConfig.context = context;
 }
-const equalFn = (a, b) => a === b;
-const $PROXY = Symbol("solid-proxy");
-const $TRACK = Symbol("solid-track");
-const signalOptions = {
+function nextHydrateContext() {
+  return {
+    ...sharedConfig.context,
+    id: `${sharedConfig.context.id}${sharedConfig.context.count++}-`,
+    count: 0
+  };
+}
+var equalFn = (a, b) => a === b;
+var $PROXY = Symbol("solid-proxy");
+var $TRACK = Symbol("solid-track");
+var signalOptions = {
   equals: equalFn
 };
-let runEffects = runQueue;
-const STALE = 1;
-const PENDING = 2;
-const UNOWNED = {
+var ERROR = null;
+var runEffects = runQueue;
+var STALE = 1;
+var PENDING = 2;
+var UNOWNED = {
   owned: null,
   cleanups: null,
   context: null,
   owner: null
 };
-const NO_INIT = {};
+var NO_INIT = {};
 var Owner = null;
-let Transition = null;
-let Listener = null;
-let Updates = null;
-let Effects = null;
-let ExecCount = 0;
-const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
+var Transition = null;
+var Scheduler = null;
+var ExternalSourceFactory = null;
+var Listener = null;
+var Updates = null;
+var Effects = null;
+var ExecCount = 0;
+var [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
 function createRoot(fn, detachedOwner) {
-  const listener = Listener,
-    owner = Owner,
-    unowned = fn.length === 0,
-    root = unowned ? UNOWNED : {
-      owned: null,
-      cleanups: null,
-      context: null,
-      owner: detachedOwner === undefined ? owner : detachedOwner
-    },
-    updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
+  const listener = Listener, owner = Owner, unowned = fn.length === 0, root = unowned ? UNOWNED : {
+    owned: null,
+    cleanups: null,
+    context: null,
+    owner: detachedOwner === void 0 ? owner : detachedOwner
+  }, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
   Owner = root;
   Listener = null;
   try {
@@ -51,27 +58,38 @@ function createSignal(value, options) {
     value,
     observers: null,
     observerSlots: null,
-    comparator: options.equals || undefined
+    comparator: options.equals || void 0
   };
-  const setter = value => {
-    if (typeof value === "function") {
-      value = value(s.value);
+  const setter = (value2) => {
+    if (typeof value2 === "function") {
+      if (Transition && Transition.running && Transition.sources.has(s))
+        value2 = value2(s.tValue);
+      else
+        value2 = value2(s.value);
     }
-    return writeSignal(s, value);
+    return writeSignal(s, value2);
   };
   return [readSignal.bind(s), setter];
 }
 function createComputed(fn, value, options) {
   const c = createComputation(fn, value, true, STALE);
-  updateComputation(c);
+  if (Scheduler && Transition && Transition.running)
+    Updates.push(c);
+  else
+    updateComputation(c);
 }
 function createRenderEffect(fn, value, options) {
   const c = createComputation(fn, value, false, STALE);
-  updateComputation(c);
+  if (Scheduler && Transition && Transition.running)
+    Updates.push(c);
+  else
+    updateComputation(c);
 }
 function createEffect(fn, value, options) {
   runEffects = runUserEffects;
-  const c = createComputation(fn, value, false, STALE);
+  const c = createComputation(fn, value, false, STALE), s = SuspenseContext && lookup(Owner, SuspenseContext.id);
+  if (s)
+    c.suspense = s;
   c.user = true;
   Effects ? Effects.push(c) : updateComputation(c);
 }
@@ -80,8 +98,12 @@ function createMemo(fn, value, options) {
   const c = createComputation(fn, value, true, 0);
   c.observers = null;
   c.observerSlots = null;
-  c.comparator = options.equals || undefined;
-  updateComputation(c);
+  c.comparator = options.equals || void 0;
+  if (Scheduler && Transition && Transition.running) {
+    c.tState = STALE;
+    Updates.push(c);
+  } else
+    updateComputation(c);
   return readSignal.bind(c);
 }
 function createResource(pSource, pFetcher, pOptions) {
@@ -97,55 +119,61 @@ function createResource(pSource, pFetcher, pOptions) {
     fetcher = pFetcher;
     options = pOptions || {};
   }
-  let pr = null,
-    initP = NO_INIT,
-    id = null,
-    scheduled = false,
-    resolved = ("initialValue" in options),
-    dynamic = typeof source === "function" && createMemo(source);
-  const contexts = new Set(),
-    [value, setValue] = (options.storage || createSignal)(options.initialValue),
-    [error, setError] = createSignal(undefined),
-    [track, trigger] = createSignal(undefined, {
-      equals: false
-    }),
-    [state, setState] = createSignal(resolved ? "ready" : "unresolved");
+  let pr = null, initP = NO_INIT, id = null, loadedUnderTransition = false, scheduled = false, resolved = "initialValue" in options, dynamic = typeof source === "function" && createMemo(source);
+  const contexts = /* @__PURE__ */ new Set(), [value, setValue] = (options.storage || createSignal)(options.initialValue), [error, setError] = createSignal(void 0), [track, trigger] = createSignal(void 0, {
+    equals: false
+  }), [state, setState] = createSignal(resolved ? "ready" : "unresolved");
   if (sharedConfig.context) {
     id = `${sharedConfig.context.id}${sharedConfig.context.count++}`;
     let v;
-    if (options.ssrLoadFrom === "initial") initP = options.initialValue;else if (sharedConfig.load && (v = sharedConfig.load(id))) initP = v[0];
+    if (options.ssrLoadFrom === "initial")
+      initP = options.initialValue;
+    else if (sharedConfig.load && (v = sharedConfig.load(id)))
+      initP = v[0];
   }
-  function loadEnd(p, v, error, key) {
+  function loadEnd(p, v, error2, key) {
     if (pr === p) {
       pr = null;
       resolved = true;
-      if ((p === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, {
-        value: v
-      }));
+      if ((p === initP || v === initP) && options.onHydrated)
+        queueMicrotask(() => options.onHydrated(key, {
+          value: v
+        }));
       initP = NO_INIT;
-      completeLoad(v, error);
+      if (Transition && p && loadedUnderTransition) {
+        Transition.promises.delete(p);
+        loadedUnderTransition = false;
+        runUpdates(() => {
+          Transition.running = true;
+          completeLoad(v, error2);
+        }, false);
+      } else
+        completeLoad(v, error2);
     }
     return v;
   }
   function completeLoad(v, err) {
     runUpdates(() => {
-      if (err === undefined) setValue(() => v);
-      setState(err !== undefined ? "errored" : "ready");
+      if (err === void 0)
+        setValue(() => v);
+      setState(err !== void 0 ? "errored" : "ready");
       setError(err);
-      for (const c of contexts.keys()) c.decrement();
+      for (const c of contexts.keys())
+        c.decrement();
       contexts.clear();
     }, false);
   }
   function read() {
-    const c = SuspenseContext ,
-      v = value(),
-      err = error();
-    if (err !== undefined && !pr) throw err;
+    const c = SuspenseContext && lookup(Owner, SuspenseContext.id), v = value(), err = error();
+    if (err !== void 0 && !pr)
+      throw err;
     if (Listener && !Listener.user && c) {
       createComputed(() => {
         track();
         if (pr) {
-          if (c.resolved  ) ;else if (!contexts.has(c)) {
+          if (c.resolved && Transition && loadedUnderTransition)
+            Transition.promises.add(pr);
+          else if (!contexts.has(c)) {
             c.increment();
             contexts.add(c);
           }
@@ -155,19 +183,23 @@ function createResource(pSource, pFetcher, pOptions) {
     return v;
   }
   function load(refetching = true) {
-    if (refetching !== false && scheduled) return;
+    if (refetching !== false && scheduled)
+      return;
     scheduled = false;
-    const lookup = dynamic ? dynamic() : source;
-    if (lookup == null || lookup === false) {
+    const lookup2 = dynamic ? dynamic() : source;
+    loadedUnderTransition = Transition && Transition.running;
+    if (lookup2 == null || lookup2 === false) {
       loadEnd(pr, untrack(value));
       return;
     }
-    const p = initP !== NO_INIT ? initP : untrack(() => fetcher(lookup, {
+    if (Transition && pr)
+      Transition.promises.delete(pr);
+    const p = initP !== NO_INIT ? initP : untrack(() => fetcher(lookup2, {
       value: value(),
       refetching
     }));
     if (typeof p !== "object" || !(p && "then" in p)) {
-      loadEnd(pr, p, undefined, lookup);
+      loadEnd(pr, p, void 0, lookup2);
       return p;
     }
     pr = p;
@@ -177,7 +209,7 @@ function createResource(pSource, pFetcher, pOptions) {
       setState(resolved ? "refreshing" : "pending");
       trigger();
     }, false);
-    return p.then(v => loadEnd(p, v, undefined, lookup), e => loadEnd(p, undefined, castError(e), lookup));
+    return p.then((v) => loadEnd(p, v, void 0, lookup2), (e) => loadEnd(p, void 0, castError(e), lookup2));
   }
   Object.defineProperties(read, {
     state: {
@@ -194,21 +226,27 @@ function createResource(pSource, pFetcher, pOptions) {
     },
     latest: {
       get() {
-        if (!resolved) return read();
+        if (!resolved)
+          return read();
         const err = error();
-        if (err && !pr) throw err;
+        if (err && !pr)
+          throw err;
         return value();
       }
     }
   });
-  if (dynamic) createComputed(() => load(false));else load(false);
+  if (dynamic)
+    createComputed(() => load(false));
+  else
+    load(false);
   return [read, {
     refetch: load,
     mutate: setValue
   }];
 }
 function untrack(fn) {
-  if (Listener === null) return fn();
+  if (Listener === null)
+    return fn();
   const listener = Listener;
   Listener = null;
   try {
@@ -221,15 +259,17 @@ function on(deps, fn, options) {
   const isArray = Array.isArray(deps);
   let prevInput;
   let defer = options && options.defer;
-  return prevValue => {
+  return (prevValue) => {
     let input;
     if (isArray) {
       input = Array(deps.length);
-      for (let i = 0; i < deps.length; i++) input[i] = deps[i]();
-    } else input = deps();
+      for (let i = 0; i < deps.length; i++)
+        input[i] = deps[i]();
+    } else
+      input = deps();
     if (defer) {
       defer = false;
-      return undefined;
+      return void 0;
     }
     const result = untrack(() => fn(input, prevInput, prevValue));
     prevInput = input;
@@ -240,19 +280,40 @@ function onMount(fn) {
   createEffect(() => untrack(fn));
 }
 function onCleanup(fn) {
-  if (Owner === null) ;else if (Owner.cleanups === null) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
+  if (Owner === null)
+    ;
+  else if (Owner.cleanups === null)
+    Owner.cleanups = [fn];
+  else
+    Owner.cleanups.push(fn);
   return fn;
 }
 function startTransition(fn) {
+  if (Transition && Transition.running) {
+    fn();
+    return Transition.done;
+  }
   const l = Listener;
   const o = Owner;
   return Promise.resolve().then(() => {
     Listener = l;
     Owner = o;
     let t;
+    if (Scheduler || SuspenseContext) {
+      t = Transition || (Transition = {
+        sources: /* @__PURE__ */ new Set(),
+        effects: [],
+        promises: /* @__PURE__ */ new Set(),
+        disposed: /* @__PURE__ */ new Set(),
+        queue: /* @__PURE__ */ new Set(),
+        running: true
+      });
+      t.done || (t.done = new Promise((res) => t.resolve = res));
+      t.running = true;
+    }
     runUpdates(fn, false);
     Listener = Owner = null;
-    return t ? t.done : undefined;
+    return t ? t.done : void 0;
   });
 }
 function useTransition() {
@@ -268,22 +329,24 @@ function createContext(defaultValue, options) {
 }
 function useContext(context) {
   let ctx;
-  return (ctx = lookup(Owner, context.id)) !== undefined ? ctx : context.defaultValue;
+  return (ctx = lookup(Owner, context.id)) !== void 0 ? ctx : context.defaultValue;
 }
 function children(fn) {
-  const children = createMemo(fn);
-  const memo = createMemo(() => resolveChildren(children()));
+  const children2 = createMemo(fn);
+  const memo = createMemo(() => resolveChildren(children2()));
   memo.toArray = () => {
     const c = memo();
     return Array.isArray(c) ? c : c != null ? [c] : [];
   };
   return memo;
 }
-let SuspenseContext;
+var SuspenseContext;
 function readSignal() {
-  const runningTransition = Transition ;
-  if (this.sources && (this.state || runningTransition )) {
-    if (this.state === STALE || runningTransition ) updateComputation(this);else {
+  const runningTransition = Transition && Transition.running;
+  if (this.sources && (!runningTransition && this.state || runningTransition && this.tState)) {
+    if (!runningTransition && this.state === STALE || runningTransition && this.tState === STALE)
+      updateComputation(this);
+    else {
       const updates = Updates;
       Updates = null;
       runUpdates(() => lookUpstream(this), false);
@@ -307,27 +370,47 @@ function readSignal() {
       this.observerSlots.push(Listener.sources.length - 1);
     }
   }
+  if (runningTransition && Transition.sources.has(this))
+    return this.tValue;
   return this.value;
 }
 function writeSignal(node, value, isComp) {
-  let current = node.value;
+  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
   if (!node.comparator || !node.comparator(current, value)) {
-    node.value = value;
+    if (Transition) {
+      const TransitionRunning = Transition.running;
+      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+        Transition.sources.add(node);
+        node.tValue = value;
+      }
+      if (!TransitionRunning)
+        node.value = value;
+    } else
+      node.value = value;
     if (node.observers && node.observers.length) {
       runUpdates(() => {
         for (let i = 0; i < node.observers.length; i += 1) {
           const o = node.observers[i];
           const TransitionRunning = Transition && Transition.running;
-          if (TransitionRunning && Transition.disposed.has(o)) ;
+          if (TransitionRunning && Transition.disposed.has(o))
+            continue;
           if (TransitionRunning && !o.tState || !TransitionRunning && !o.state) {
-            if (o.pure) Updates.push(o);else Effects.push(o);
-            if (o.observers) markDownstream(o);
+            if (o.pure)
+              Updates.push(o);
+            else
+              Effects.push(o);
+            if (o.observers)
+              markDownstream(o);
           }
-          if (TransitionRunning) ;else o.state = STALE;
+          if (TransitionRunning)
+            o.tState = STALE;
+          else
+            o.state = STALE;
         }
-        if (Updates.length > 10e5) {
+        if (Updates.length > 1e6) {
           Updates = [];
-          if (false) ;
+          if (false)
+            ;
           throw new Error();
         }
       }, false);
@@ -336,13 +419,22 @@ function writeSignal(node, value, isComp) {
   return value;
 }
 function updateComputation(node) {
-  if (!node.fn) return;
+  if (!node.fn)
+    return;
   cleanNode(node);
-  const owner = Owner,
-    listener = Listener,
-    time = ExecCount;
+  const owner = Owner, listener = Listener, time = ExecCount;
   Listener = Owner = node;
-  runComputation(node, node.value, time);
+  runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
+  if (Transition && !Transition.running && Transition.sources.has(node)) {
+    queueMicrotask(() => {
+      runUpdates(() => {
+        Transition && (Transition.running = true);
+        Listener = Owner = node;
+        runComputation(node, node.tValue, time);
+        Listener = Owner = null;
+      }, false);
+    });
+  }
   Listener = listener;
   Owner = owner;
 }
@@ -352,7 +444,11 @@ function runComputation(node, value, time) {
     nextValue = node.fn(value);
   } catch (err) {
     if (node.pure) {
-      {
+      if (Transition && Transition.running) {
+        node.tState = STALE;
+        node.tOwned && node.tOwned.forEach(cleanNode);
+        node.tOwned = void 0;
+      } else {
         node.state = STALE;
         node.owned && node.owned.forEach(cleanNode);
         node.owned = null;
@@ -363,15 +459,19 @@ function runComputation(node, value, time) {
   }
   if (!node.updatedAt || node.updatedAt <= time) {
     if (node.updatedAt != null && "observers" in node) {
-      writeSignal(node, nextValue);
-    } else node.value = nextValue;
+      writeSignal(node, nextValue, true);
+    } else if (Transition && Transition.running && node.pure) {
+      Transition.sources.add(node);
+      node.tValue = nextValue;
+    } else
+      node.value = nextValue;
     node.updatedAt = time;
   }
 }
 function createComputation(fn, init, pure, state = STALE, options) {
   const c = {
     fn,
-    state: state,
+    state,
     updatedAt: null,
     owned: null,
     sources: null,
@@ -382,27 +482,67 @@ function createComputation(fn, init, pure, state = STALE, options) {
     context: null,
     pure
   };
-  if (Owner === null) ;else if (Owner !== UNOWNED) {
-    {
-      if (!Owner.owned) Owner.owned = [c];else Owner.owned.push(c);
+  if (Transition && Transition.running) {
+    c.state = 0;
+    c.tState = state;
+  }
+  if (Owner === null)
+    ;
+  else if (Owner !== UNOWNED) {
+    if (Transition && Transition.running && Owner.pure) {
+      if (!Owner.tOwned)
+        Owner.tOwned = [c];
+      else
+        Owner.tOwned.push(c);
+    } else {
+      if (!Owner.owned)
+        Owner.owned = [c];
+      else
+        Owner.owned.push(c);
     }
   }
+  if (ExternalSourceFactory) {
+    const [track, trigger] = createSignal(void 0, {
+      equals: false
+    });
+    const ordinary = ExternalSourceFactory(c.fn, trigger);
+    onCleanup(() => ordinary.dispose());
+    const triggerInTransition = () => startTransition(trigger).then(() => inTransition.dispose());
+    const inTransition = ExternalSourceFactory(c.fn, triggerInTransition);
+    c.fn = (x) => {
+      track();
+      return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
+    };
+  }
   return c;
 }
 function runTop(node) {
-  const runningTransition = Transition ;
-  if (node.state === 0 || runningTransition ) return;
-  if (node.state === PENDING || runningTransition ) return lookUpstream(node);
-  if (node.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
+  const runningTransition = Transition && Transition.running;
+  if (!runningTransition && node.state === 0 || runningTransition && node.tState === 0)
+    return;
+  if (!runningTransition && node.state === PENDING || runningTransition && node.tState === PENDING)
+    return lookUpstream(node);
+  if (node.suspense && untrack(node.suspense.inFallback))
+    return node.suspense.effects.push(node);
   const ancestors = [node];
   while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
-    if (node.state || runningTransition ) ancestors.push(node);
+    if (runningTransition && Transition.disposed.has(node))
+      return;
+    if (!runningTransition && node.state || runningTransition && node.tState)
+      ancestors.push(node);
   }
   for (let i = ancestors.length - 1; i >= 0; i--) {
     node = ancestors[i];
-    if (node.state === STALE || runningTransition ) {
+    if (runningTransition) {
+      let top = node, prev = ancestors[i + 1];
+      while ((top = top.owner) && top !== prev) {
+        if (Transition.disposed.has(top))
+          return;
+      }
+    }
+    if (!runningTransition && node.state === STALE || runningTransition && node.tState === STALE) {
       updateComputation(node);
-    } else if (node.state === PENDING || runningTransition ) {
+    } else if (!runningTransition && node.state === PENDING || runningTransition && node.tState === PENDING) {
       const updates = Updates;
       Updates = null;
       runUpdates(() => lookUpstream(node, ancestors[0]), false);
@@ -411,63 +551,146 @@ function runTop(node) {
   }
 }
 function runUpdates(fn, init) {
-  if (Updates) return fn();
+  if (Updates)
+    return fn();
   let wait = false;
-  if (!init) Updates = [];
-  if (Effects) wait = true;else Effects = [];
+  if (!init)
+    Updates = [];
+  if (Effects)
+    wait = true;
+  else
+    Effects = [];
   ExecCount++;
   try {
     const res = fn();
     completeUpdates(wait);
     return res;
   } catch (err) {
-    if (!wait) Effects = null;
+    if (!wait)
+      Effects = null;
     Updates = null;
     handleError(err);
   }
 }
 function completeUpdates(wait) {
   if (Updates) {
-    runQueue(Updates);
+    if (Scheduler && Transition && Transition.running)
+      scheduleQueue(Updates);
+    else
+      runQueue(Updates);
     Updates = null;
   }
-  if (wait) return;
+  if (wait)
+    return;
+  let res;
+  if (Transition) {
+    if (!Transition.promises.size && !Transition.queue.size) {
+      const sources = Transition.sources;
+      const disposed = Transition.disposed;
+      Effects.push.apply(Effects, Transition.effects);
+      res = Transition.resolve;
+      for (const e2 of Effects) {
+        "tState" in e2 && (e2.state = e2.tState);
+        delete e2.tState;
+      }
+      Transition = null;
+      runUpdates(() => {
+        for (const d of disposed)
+          cleanNode(d);
+        for (const v of sources) {
+          v.value = v.tValue;
+          if (v.owned) {
+            for (let i = 0, len = v.owned.length; i < len; i++)
+              cleanNode(v.owned[i]);
+          }
+          if (v.tOwned)
+            v.owned = v.tOwned;
+          delete v.tValue;
+          delete v.tOwned;
+          v.tState = 0;
+        }
+        setTransPending(false);
+      }, false);
+    } else if (Transition.running) {
+      Transition.running = false;
+      Transition.effects.push.apply(Transition.effects, Effects);
+      Effects = null;
+      setTransPending(true);
+      return;
+    }
+  }
   const e = Effects;
   Effects = null;
-  if (e.length) runUpdates(() => runEffects(e), false);
+  if (e.length)
+    runUpdates(() => runEffects(e), false);
+  if (res)
+    res();
 }
 function runQueue(queue) {
-  for (let i = 0; i < queue.length; i++) runTop(queue[i]);
+  for (let i = 0; i < queue.length; i++)
+    runTop(queue[i]);
+}
+function scheduleQueue(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    const item = queue[i];
+    const tasks = Transition.queue;
+    if (!tasks.has(item)) {
+      tasks.add(item);
+      Scheduler(() => {
+        tasks.delete(item);
+        runUpdates(() => {
+          Transition.running = true;
+          runTop(item);
+        }, false);
+        Transition && (Transition.running = false);
+      });
+    }
+  }
 }
 function runUserEffects(queue) {
-  let i,
-    userLength = 0;
+  let i, userLength = 0;
   for (i = 0; i < queue.length; i++) {
     const e = queue[i];
-    if (!e.user) runTop(e);else queue[userLength++] = e;
+    if (!e.user)
+      runTop(e);
+    else
+      queue[userLength++] = e;
   }
-  if (sharedConfig.context) setHydrateContext();
-  for (i = 0; i < userLength; i++) runTop(queue[i]);
+  if (sharedConfig.context)
+    setHydrateContext();
+  for (i = 0; i < userLength; i++)
+    runTop(queue[i]);
 }
 function lookUpstream(node, ignore) {
-  const runningTransition = Transition ;
-  node.state = 0;
+  const runningTransition = Transition && Transition.running;
+  if (runningTransition)
+    node.tState = 0;
+  else
+    node.state = 0;
   for (let i = 0; i < node.sources.length; i += 1) {
     const source = node.sources[i];
     if (source.sources) {
-      if (source.state === STALE || runningTransition ) {
-        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount)) runTop(source);
-      } else if (source.state === PENDING || runningTransition ) lookUpstream(source, ignore);
+      if (!runningTransition && source.state === STALE || runningTransition && source.tState === STALE) {
+        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount))
+          runTop(source);
+      } else if (!runningTransition && source.state === PENDING || runningTransition && source.tState === PENDING)
+        lookUpstream(source, ignore);
     }
   }
 }
 function markDownstream(node) {
-  const runningTransition = Transition ;
+  const runningTransition = Transition && Transition.running;
   for (let i = 0; i < node.observers.length; i += 1) {
     const o = node.observers[i];
-    if (!o.state || runningTransition ) {
-      o.state = PENDING;
-      if (o.pure) Updates.push(o);else Effects.push(o);
+    if (!runningTransition && !o.state || runningTransition && !o.tState) {
+      if (runningTransition)
+        o.tState = PENDING;
+      else
+        o.state = PENDING;
+      if (o.pure)
+        Updates.push(o);
+      else
+        Effects.push(o);
       o.observers && markDownstream(o);
     }
   }
@@ -476,12 +699,9 @@ function cleanNode(node) {
   let i;
   if (node.sources) {
     while (node.sources.length) {
-      const source = node.sources.pop(),
-        index = node.sourceSlots.pop(),
-        obs = source.observers;
+      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
       if (obs && obs.length) {
-        const n = obs.pop(),
-          s = source.observerSlots.pop();
+        const n = obs.pop(), s = source.observerSlots.pop();
         if (index < obs.length) {
           n.sourceSlots[s] = index;
           obs[index] = n;
@@ -490,39 +710,78 @@ function cleanNode(node) {
       }
     }
   }
-  if (node.owned) {
-    for (i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
+  if (Transition && Transition.running && node.pure) {
+    if (node.tOwned) {
+      for (i = 0; i < node.tOwned.length; i++)
+        cleanNode(node.tOwned[i]);
+      delete node.tOwned;
+    }
+    reset(node, true);
+  } else if (node.owned) {
+    for (i = 0; i < node.owned.length; i++)
+      cleanNode(node.owned[i]);
     node.owned = null;
   }
   if (node.cleanups) {
-    for (i = 0; i < node.cleanups.length; i++) node.cleanups[i]();
+    for (i = 0; i < node.cleanups.length; i++)
+      node.cleanups[i]();
     node.cleanups = null;
   }
-  node.state = 0;
+  if (Transition && Transition.running)
+    node.tState = 0;
+  else
+    node.state = 0;
   node.context = null;
 }
+function reset(node, top) {
+  if (!top) {
+    node.tState = 0;
+    Transition.disposed.add(node);
+  }
+  if (node.owned) {
+    for (let i = 0; i < node.owned.length; i++)
+      reset(node.owned[i]);
+  }
+}
 function castError(err) {
-  if (err instanceof Error || typeof err === "string") return err;
+  if (err instanceof Error || typeof err === "string")
+    return err;
   return new Error("Unknown error");
 }
+function runErrors(fns, err) {
+  for (const f of fns)
+    f(err);
+}
 function handleError(err) {
   err = castError(err);
-  throw err;
+  const fns = ERROR && lookup(Owner, ERROR);
+  if (!fns)
+    throw err;
+  if (Effects)
+    Effects.push({
+      fn() {
+        runErrors(fns, err);
+      },
+      state: STALE
+    });
+  else
+    runErrors(fns, err);
 }
 function lookup(owner, key) {
-  return owner ? owner.context && owner.context[key] !== undefined ? owner.context[key] : lookup(owner.owner, key) : undefined;
+  return owner ? owner.context && owner.context[key] !== void 0 ? owner.context[key] : lookup(owner.owner, key) : void 0;
 }
-function resolveChildren(children) {
-  if (typeof children === "function" && !children.length) return resolveChildren(children());
-  if (Array.isArray(children)) {
+function resolveChildren(children2) {
+  if (typeof children2 === "function" && !children2.length)
+    return resolveChildren(children2());
+  if (Array.isArray(children2)) {
     const results = [];
-    for (let i = 0; i < children.length; i++) {
-      const result = resolveChildren(children[i]);
+    for (let i = 0; i < children2.length; i++) {
+      const result = resolveChildren(children2[i]);
       Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
     }
     return results;
   }
-  return children;
+  return children2;
 }
 function createProvider(id, options) {
   return function provider(props) {
@@ -532,37 +791,23 @@ function createProvider(id, options) {
         [id]: props.value
       };
       return children(() => props.children);
-    }), undefined);
+    }), void 0);
     return res;
   };
 }
-const FALLBACK = Symbol("fallback");
+var FALLBACK = Symbol("fallback");
 function dispose(d) {
-  for (let i = 0; i < d.length; i++) d[i]();
+  for (let i = 0; i < d.length; i++)
+    d[i]();
 }
 function mapArray(list, mapFn, options = {}) {
-  let items = [],
-    mapped = [],
-    disposers = [],
-    len = 0,
-    indexes = mapFn.length > 1 ? [] : null;
+  let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
   onCleanup(() => dispose(disposers));
   return () => {
-    let newItems = list() || [],
-      i,
-      j;
+    let newItems = list() || [], i, j;
     newItems[$TRACK];
     return untrack(() => {
-      let newLen = newItems.length,
-        newIndices,
-        newIndicesNext,
-        temp,
-        tempdisposers,
-        tempIndexes,
-        start,
-        end,
-        newEnd,
-        item;
+      let newLen = newItems.length, newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
       if (newLen === 0) {
         if (len !== 0) {
           dispose(disposers);
@@ -574,7 +819,7 @@ function mapArray(list, mapFn, options = {}) {
         }
         if (options.fallback) {
           items = [FALLBACK];
-          mapped[0] = createRoot(disposer => {
+          mapped[0] = createRoot((disposer) => {
             disposers[0] = disposer;
             return options.fallback();
           });
@@ -591,30 +836,32 @@ function mapArray(list, mapFn, options = {}) {
         temp = new Array(newLen);
         tempdisposers = new Array(newLen);
         indexes && (tempIndexes = new Array(newLen));
-        for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++);
+        for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++)
+          ;
         for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
           temp[newEnd] = mapped[end];
           tempdisposers[newEnd] = disposers[end];
           indexes && (tempIndexes[newEnd] = indexes[end]);
         }
-        newIndices = new Map();
+        newIndices = /* @__PURE__ */ new Map();
         newIndicesNext = new Array(newEnd + 1);
         for (j = newEnd; j >= start; j--) {
           item = newItems[j];
           i = newIndices.get(item);
-          newIndicesNext[j] = i === undefined ? -1 : i;
+          newIndicesNext[j] = i === void 0 ? -1 : i;
           newIndices.set(item, j);
         }
         for (i = start; i <= end; i++) {
           item = items[i];
           j = newIndices.get(item);
-          if (j !== undefined && j !== -1) {
+          if (j !== void 0 && j !== -1) {
             temp[j] = mapped[i];
             tempdisposers[j] = disposers[i];
             indexes && (tempIndexes[j] = indexes[i]);
             j = newIndicesNext[j];
             newIndices.set(item, j);
-          } else disposers[i]();
+          } else
+            disposers[i]();
         }
         for (j = start; j < newLen; j++) {
           if (j in temp) {
@@ -624,7 +871,8 @@ function mapArray(list, mapFn, options = {}) {
               indexes[j] = tempIndexes[j];
               indexes[j](j);
             }
-          } else mapped[j] = createRoot(mapper);
+          } else
+            mapped[j] = createRoot(mapper);
         }
         mapped = mapped.slice(0, len = newLen);
         items = newItems.slice(0);
@@ -643,12 +891,7 @@ function mapArray(list, mapFn, options = {}) {
   };
 }
 function indexArray(list, mapFn, options = {}) {
-  let items = [],
-    mapped = [],
-    disposers = [],
-    signals = [],
-    len = 0,
-    i;
+  let items = [], mapped = [], disposers = [], signals = [], len = 0, i;
   onCleanup(() => dispose(disposers));
   return () => {
     const newItems = list() || [];
@@ -665,7 +908,7 @@ function indexArray(list, mapFn, options = {}) {
         }
         if (options.fallback) {
           items = [FALLBACK];
-          mapped[0] = createRoot(disposer => {
+          mapped[0] = createRoot((disposer) => {
             disposers[0] = disposer;
             return options.fallback();
           });
@@ -702,19 +945,31 @@ function indexArray(list, mapFn, options = {}) {
     }
   };
 }
+var hydrationEnabled = false;
 function createComponent(Comp, props) {
+  if (hydrationEnabled) {
+    if (sharedConfig.context) {
+      const c = sharedConfig.context;
+      setHydrateContext(nextHydrateContext());
+      const r = untrack(() => Comp(props || {}));
+      setHydrateContext(c);
+      return r;
+    }
+  }
   return untrack(() => Comp(props || {}));
 }
 function trueFn() {
   return true;
 }
-const propTraps = {
+var propTraps = {
   get(_, property, receiver) {
-    if (property === $PROXY) return receiver;
+    if (property === $PROXY)
+      return receiver;
     return _.get(property);
   },
   has(_, property) {
-    if (property === $PROXY) return true;
+    if (property === $PROXY)
+      return true;
     return _.has(property);
   },
   set: trueFn,
@@ -749,18 +1004,21 @@ function mergeProps(...sources) {
       get(property) {
         for (let i = sources.length - 1; i >= 0; i--) {
           const v = resolveSource(sources[i])[property];
-          if (v !== undefined) return v;
+          if (v !== void 0)
+            return v;
         }
       },
       has(property) {
         for (let i = sources.length - 1; i >= 0; i--) {
-          if (property in resolveSource(sources[i])) return true;
+          if (property in resolveSource(sources[i]))
+            return true;
         }
         return false;
       },
       keys() {
         const keys = [];
-        for (let i = 0; i < sources.length; i++) keys.push(...Object.keys(resolveSource(sources[i])));
+        for (let i = 0; i < sources.length; i++)
+          keys.push(...Object.keys(resolveSource(sources[i])));
         return [...new Set(keys)];
       }
     }, propTraps);
@@ -770,13 +1028,15 @@ function mergeProps(...sources) {
     if (sources[i]) {
       const descriptors = Object.getOwnPropertyDescriptors(sources[i]);
       for (const key in descriptors) {
-        if (key in target) continue;
+        if (key in target)
+          continue;
         Object.defineProperty(target, key, {
           enumerable: true,
           get() {
-            for (let i = sources.length - 1; i >= 0; i--) {
-              const v = (sources[i] || {})[key];
-              if (v !== undefined) return v;
+            for (let i2 = sources.length - 1; i2 >= 0; i2--) {
+              const v = (sources[i2] || {})[key];
+              if (v !== void 0)
+                return v;
             }
           }
         });
@@ -788,24 +1048,26 @@ function mergeProps(...sources) {
 function lazy(fn) {
   let comp;
   let p;
-  const wrap = props => {
+  const wrap = (props) => {
     const ctx = sharedConfig.context;
     if (ctx) {
       const [s, set] = createSignal();
-      (p || (p = fn())).then(mod => {
+      (p || (p = fn())).then((mod) => {
         setHydrateContext(ctx);
         set(() => mod.default);
         setHydrateContext();
       });
       comp = s;
     } else if (!comp) {
-      const [s] = createResource(() => (p || (p = fn())).then(mod => mod.default));
+      const [s] = createResource(() => (p || (p = fn())).then((mod) => mod.default));
       comp = s;
     }
     let Comp;
     return createMemo(() => (Comp = comp()) && untrack(() => {
-      if (false) ;
-      if (!ctx) return Comp(props);
+      if (false)
+        ;
+      if (!ctx)
+        return Comp(props);
       const c = sharedConfig.context;
       setHydrateContext(ctx);
       const r = Comp(props);
@@ -813,25 +1075,25 @@ function lazy(fn) {
       return r;
     }));
   };
-  wrap.preload = () => p || ((p = fn()).then(mod => comp = () => mod.default), p);
+  wrap.preload = () => p || ((p = fn()).then((mod) => comp = () => mod.default), p);
   return wrap;
 }
 function For(props) {
   const fallback = "fallback" in props && {
     fallback: () => props.fallback
   };
-  return createMemo(mapArray(() => props.each, props.children, fallback || undefined));
+  return createMemo(mapArray(() => props.each, props.children, fallback || void 0));
 }
 function Index(props) {
   const fallback = "fallback" in props && {
     fallback: () => props.fallback
   };
-  return createMemo(indexArray(() => props.each, props.children, fallback || undefined));
+  return createMemo(indexArray(() => props.each, props.children, fallback || void 0));
 }
 function Show(props) {
   let strictEqual = false;
   const keyed = props.keyed;
-  const condition = createMemo(() => props.when, undefined, {
+  const condition = createMemo(() => props.when, void 0, {
     equals: (a, b) => strictEqual ? a === b : !a === !b
   });
   return createMemo(() => {
@@ -843,48 +1105,50 @@ function Show(props) {
       return fn ? untrack(() => child(c)) : child;
     }
     return props.fallback;
-  }, undefined, undefined);
+  }, void 0, void 0);
 }
 function Switch(props) {
   let strictEqual = false;
   let keyed = false;
   const equals = (a, b) => a[0] === b[0] && (strictEqual ? a[1] === b[1] : !a[1] === !b[1]) && a[2] === b[2];
-  const conditions = children(() => props.children),
-    evalConditions = createMemo(() => {
-      let conds = conditions();
-      if (!Array.isArray(conds)) conds = [conds];
-      for (let i = 0; i < conds.length; i++) {
-        const c = conds[i].when;
-        if (c) {
-          keyed = !!conds[i].keyed;
-          return [i, c, conds[i]];
-        }
+  const conditions = children(() => props.children), evalConditions = createMemo(() => {
+    let conds = conditions();
+    if (!Array.isArray(conds))
+      conds = [conds];
+    for (let i = 0; i < conds.length; i++) {
+      const c = conds[i].when;
+      if (c) {
+        keyed = !!conds[i].keyed;
+        return [i, c, conds[i]];
       }
-      return [-1];
-    }, undefined, {
-      equals
-    });
+    }
+    return [-1];
+  }, void 0, {
+    equals
+  });
   return createMemo(() => {
     const [index, when, cond] = evalConditions();
-    if (index < 0) return props.fallback;
+    if (index < 0)
+      return props.fallback;
     const c = cond.children;
     const fn = typeof c === "function" && c.length > 0;
     strictEqual = keyed || fn;
     return fn ? untrack(() => c(when)) : c;
-  }, undefined, undefined);
+  }, void 0, void 0);
 }
 function Match(props) {
   return props;
 }
 
-const booleans = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"];
-const Properties = /*#__PURE__*/new Set(["className", "value", "readOnly", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]);
-const ChildProperties = /*#__PURE__*/new Set(["innerHTML", "textContent", "innerText", "children"]);
-const Aliases = /*#__PURE__*/Object.assign(Object.create(null), {
+// ../../node_modules/.pnpm/solid-js@1.6.13/node_modules/solid-js/web/dist/web.js
+var booleans = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"];
+var Properties = /* @__PURE__ */ new Set(["className", "value", "readOnly", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]);
+var ChildProperties = /* @__PURE__ */ new Set(["innerHTML", "textContent", "innerText", "children"]);
+var Aliases = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(null), {
   className: "class",
   htmlFor: "for"
 });
-const PropAliases = /*#__PURE__*/Object.assign(Object.create(null), {
+var PropAliases = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(null), {
   class: "className",
   formnovalidate: "formNoValidate",
   ismap: "isMap",
@@ -892,19 +1156,13 @@ const PropAliases = /*#__PURE__*/Object.assign(Object.create(null), {
   playsinline: "playsInline",
   readonly: "readOnly"
 });
-const DelegatedEvents = /*#__PURE__*/new Set(["beforeinput", "click", "dblclick", "contextmenu", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]);
-const SVGNamespace = {
+var DelegatedEvents = /* @__PURE__ */ new Set(["beforeinput", "click", "dblclick", "contextmenu", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]);
+var SVGNamespace = {
   xlink: "http://www.w3.org/1999/xlink",
   xml: "http://www.w3.org/XML/1998/namespace"
 };
 function reconcileArrays(parentNode, a, b) {
-  let bLength = b.length,
-    aEnd = a.length,
-    bEnd = bLength,
-    aStart = 0,
-    bStart = 0,
-    after = a[aEnd - 1].nextSibling,
-    map = null;
+  let bLength = b.length, aEnd = a.length, bEnd = bLength, aStart = 0, bStart = 0, after = a[aEnd - 1].nextSibling, map = null;
   while (aStart < aEnd || bStart < bEnd) {
     if (a[aStart] === b[bStart]) {
       aStart++;
@@ -917,10 +1175,12 @@ function reconcileArrays(parentNode, a, b) {
     }
     if (aEnd === aStart) {
       const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] : after;
-      while (bStart < bEnd) parentNode.insertBefore(b[bStart++], node);
+      while (bStart < bEnd)
+        parentNode.insertBefore(b[bStart++], node);
     } else if (bEnd === bStart) {
       while (aStart < aEnd) {
-        if (!map || !map.has(a[aStart])) a[aStart].remove();
+        if (!map || !map.has(a[aStart]))
+          a[aStart].remove();
         aStart++;
       }
     } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
@@ -930,35 +1190,39 @@ function reconcileArrays(parentNode, a, b) {
       a[aEnd] = b[bEnd];
     } else {
       if (!map) {
-        map = new Map();
+        map = /* @__PURE__ */ new Map();
         let i = bStart;
-        while (i < bEnd) map.set(b[i], i++);
+        while (i < bEnd)
+          map.set(b[i], i++);
       }
       const index = map.get(a[aStart]);
       if (index != null) {
         if (bStart < index && index < bEnd) {
-          let i = aStart,
-            sequence = 1,
-            t;
+          let i = aStart, sequence = 1, t;
           while (++i < aEnd && i < bEnd) {
-            if ((t = map.get(a[i])) == null || t !== index + sequence) break;
+            if ((t = map.get(a[i])) == null || t !== index + sequence)
+              break;
             sequence++;
           }
           if (sequence > index - bStart) {
             const node = a[aStart];
-            while (bStart < index) parentNode.insertBefore(b[bStart++], node);
-          } else parentNode.replaceChild(b[bStart++], a[aStart++]);
-        } else aStart++;
-      } else a[aStart++].remove();
+            while (bStart < index)
+              parentNode.insertBefore(b[bStart++], node);
+          } else
+            parentNode.replaceChild(b[bStart++], a[aStart++]);
+        } else
+          aStart++;
+      } else
+        a[aStart++].remove();
     }
   }
 }
-const $$EVENTS = "_$DX_DELEGATE";
+var $$EVENTS = "_$DX_DELEGATE";
 function render(code, element, init, options = {}) {
   let disposer;
-  createRoot(dispose => {
-    disposer = dispose;
-    element === document ? code() : insert(element, code(), element.firstChild ? null : undefined, init);
+  createRoot((dispose2) => {
+    disposer = dispose2;
+    element === document ? code() : insert(element, code(), element.firstChild ? null : void 0, init);
   }, options.owner);
   return () => {
     disposer();
@@ -968,65 +1232,83 @@ function render(code, element, init, options = {}) {
 function template(html, check, isSVG) {
   const t = document.createElement("template");
   t.innerHTML = html;
-  if (check && t.innerHTML.split("<").length - 1 !== check) throw `The browser resolved template HTML does not match JSX input:\n${t.innerHTML}\n\n${html}. Is your HTML properly formed?`;
+  if (check && t.innerHTML.split("<").length - 1 !== check)
+    throw `The browser resolved template HTML does not match JSX input:
+${t.innerHTML}
+
+${html}. Is your HTML properly formed?`;
   let node = t.content.firstChild;
-  if (isSVG) node = node.firstChild;
+  if (isSVG)
+    node = node.firstChild;
   return node;
 }
-function delegateEvents(eventNames, document = window.document) {
-  const e = document[$$EVENTS] || (document[$$EVENTS] = new Set());
+function delegateEvents(eventNames, document2 = window.document) {
+  const e = document2[$$EVENTS] || (document2[$$EVENTS] = /* @__PURE__ */ new Set());
   for (let i = 0, l = eventNames.length; i < l; i++) {
     const name = eventNames[i];
     if (!e.has(name)) {
       e.add(name);
-      document.addEventListener(name, eventHandler);
+      document2.addEventListener(name, eventHandler);
     }
   }
 }
 function setAttribute(node, name, value) {
-  if (value == null) node.removeAttribute(name);else node.setAttribute(name, value);
+  if (value == null)
+    node.removeAttribute(name);
+  else
+    node.setAttribute(name, value);
 }
 function setAttributeNS(node, namespace, name, value) {
-  if (value == null) node.removeAttributeNS(namespace, name);else node.setAttributeNS(namespace, name, value);
+  if (value == null)
+    node.removeAttributeNS(namespace, name);
+  else
+    node.setAttributeNS(namespace, name, value);
 }
 function className(node, value) {
-  if (value == null) node.removeAttribute("class");else node.className = value;
+  if (value == null)
+    node.removeAttribute("class");
+  else
+    node.className = value;
 }
 function addEventListener(node, name, handler, delegate) {
   if (delegate) {
     if (Array.isArray(handler)) {
       node[`$$${name}`] = handler[0];
       node[`$$${name}Data`] = handler[1];
-    } else node[`$$${name}`] = handler;
+    } else
+      node[`$$${name}`] = handler;
   } else if (Array.isArray(handler)) {
     const handlerFn = handler[0];
-    node.addEventListener(name, handler[0] = e => handlerFn.call(node, handler[1], e));
-  } else node.addEventListener(name, handler);
+    node.addEventListener(name, handler[0] = (e) => handlerFn.call(node, handler[1], e));
+  } else
+    node.addEventListener(name, handler);
 }
 function classList(node, value, prev = {}) {
-  const classKeys = Object.keys(value || {}),
-    prevKeys = Object.keys(prev);
+  const classKeys = Object.keys(value || {}), prevKeys = Object.keys(prev);
   let i, len;
   for (i = 0, len = prevKeys.length; i < len; i++) {
     const key = prevKeys[i];
-    if (!key || key === "undefined" || value[key]) continue;
+    if (!key || key === "undefined" || value[key])
+      continue;
     toggleClassKey(node, key, false);
     delete prev[key];
   }
   for (i = 0, len = classKeys.length; i < len; i++) {
-    const key = classKeys[i],
-      classValue = !!value[key];
-    if (!key || key === "undefined" || prev[key] === classValue || !classValue) continue;
+    const key = classKeys[i], classValue = !!value[key];
+    if (!key || key === "undefined" || prev[key] === classValue || !classValue)
+      continue;
     toggleClassKey(node, key, true);
     prev[key] = classValue;
   }
   return prev;
 }
 function style(node, value, prev) {
-  if (!value) return prev ? setAttribute(node, "style") : value;
+  if (!value)
+    return prev ? setAttribute(node, "style") : value;
   const nodeStyle = node.style;
-  if (typeof value === "string") return nodeStyle.cssText = value;
-  typeof prev === "string" && (nodeStyle.cssText = prev = undefined);
+  if (typeof value === "string")
+    return nodeStyle.cssText = value;
+  typeof prev === "string" && (nodeStyle.cssText = prev = void 0);
   prev || (prev = {});
   value || (value = {});
   let v, s;
@@ -1056,21 +1338,25 @@ function use(fn, element, arg) {
   return untrack(() => fn(element, arg));
 }
 function insert(parent, accessor, marker, initial) {
-  if (marker !== undefined && !initial) initial = [];
-  if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
-  createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
+  if (marker !== void 0 && !initial)
+    initial = [];
+  if (typeof accessor !== "function")
+    return insertExpression(parent, accessor, initial, marker);
+  createRenderEffect((current) => insertExpression(parent, accessor(), current, marker), initial);
 }
 function assign(node, props, isSVG, skipChildren, prevProps = {}, skipRef = false) {
   props || (props = {});
   for (const prop in prevProps) {
     if (!(prop in props)) {
-      if (prop === "children") continue;
+      if (prop === "children")
+        continue;
       prevProps[prop] = assignProp(node, prop, null, prevProps[prop], isSVG, skipRef);
     }
   }
   for (const prop in props) {
     if (prop === "children") {
-      if (!skipChildren) insertExpression(node, props.children);
+      if (!skipChildren)
+        insertExpression(node, props.children);
       continue;
     }
     const value = props[prop];
@@ -1082,15 +1368,20 @@ function toPropertyName(name) {
 }
 function toggleClassKey(node, key, value) {
   const classNames = key.trim().split(/\s+/);
-  for (let i = 0, nameLen = classNames.length; i < nameLen; i++) node.classList.toggle(classNames[i], value);
+  for (let i = 0, nameLen = classNames.length; i < nameLen; i++)
+    node.classList.toggle(classNames[i], value);
 }
 function assignProp(node, prop, value, prev, isSVG, skipRef) {
   let isCE, isProp, isChildProp;
-  if (prop === "style") return style(node, value, prev);
-  if (prop === "classList") return classList(node, value, prev);
-  if (value === prev) return prev;
+  if (prop === "style")
+    return style(node, value, prev);
+  if (prop === "classList")
+    return classList(node, value, prev);
+  if (value === prev)
+    return prev;
   if (prop === "ref") {
-    if (!skipRef) value(node);
+    if (!skipRef)
+      value(node);
   } else if (prop.slice(0, 3) === "on:") {
     const e = prop.slice(3);
     prev && node.removeEventListener(e, prev);
@@ -1111,10 +1402,18 @@ function assignProp(node, prop, value, prev, isSVG, skipRef) {
       delegate && delegateEvents([name]);
     }
   } else if ((isChildProp = ChildProperties.has(prop)) || !isSVG && (PropAliases[prop] || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-"))) {
-    if (prop === "class" || prop === "className") className(node, value);else if (isCE && !isProp && !isChildProp) node[toPropertyName(prop)] = value;else node[PropAliases[prop] || prop] = value;
+    if (prop === "class" || prop === "className")
+      className(node, value);
+    else if (isCE && !isProp && !isChildProp)
+      node[toPropertyName(prop)] = value;
+    else
+      node[PropAliases[prop] || prop] = value;
   } else {
     const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
-    if (ns) setAttributeNS(node, ns, prop, value);else setAttribute(node, Aliases[prop] || prop, value);
+    if (ns)
+      setAttributeNS(node, ns, prop, value);
+    else
+      setAttribute(node, Aliases[prop] || prop, value);
   }
   return value;
 }
@@ -1135,7 +1434,7 @@ function eventHandler(e) {
   });
   if (sharedConfig.registry && !sharedConfig.done) {
     sharedConfig.done = true;
-    document.querySelectorAll("[id^=pl-]").forEach(elem => {
+    document.querySelectorAll("[id^=pl-]").forEach((elem) => {
       while (elem && elem.nodeType !== 8 && elem.nodeValue !== "pl-" + e) {
         let x = elem.nextSibling;
         elem.remove();
@@ -1148,40 +1447,49 @@ function eventHandler(e) {
     const handler = node[key];
     if (handler && !node.disabled) {
       const data = node[`${key}Data`];
-      data !== undefined ? handler.call(node, data, e) : handler.call(node, e);
-      if (e.cancelBubble) return;
+      data !== void 0 ? handler.call(node, data, e) : handler.call(node, e);
+      if (e.cancelBubble)
+        return;
     }
     node = node._$host || node.parentNode || node.host;
   }
 }
 function insertExpression(parent, value, current, marker, unwrapArray) {
-  if (sharedConfig.context && !current) current = [...parent.childNodes];
-  while (typeof current === "function") current = current();
-  if (value === current) return current;
-  const t = typeof value,
-    multi = marker !== undefined;
+  if (sharedConfig.context && !current)
+    current = [...parent.childNodes];
+  while (typeof current === "function")
+    current = current();
+  if (value === current)
+    return current;
+  const t = typeof value, multi = marker !== void 0;
   parent = multi && current[0] && current[0].parentNode || parent;
   if (t === "string" || t === "number") {
-    if (sharedConfig.context) return current;
-    if (t === "number") value = value.toString();
+    if (sharedConfig.context)
+      return current;
+    if (t === "number")
+      value = value.toString();
     if (multi) {
       let node = current[0];
       if (node && node.nodeType === 3) {
         node.data = value;
-      } else node = document.createTextNode(value);
+      } else
+        node = document.createTextNode(value);
       current = cleanChildren(parent, current, marker, node);
     } else {
       if (current !== "" && typeof current === "string") {
         current = parent.firstChild.data = value;
-      } else current = parent.textContent = value;
+      } else
+        current = parent.textContent = value;
     }
   } else if (value == null || t === "boolean") {
-    if (sharedConfig.context) return current;
+    if (sharedConfig.context)
+      return current;
     current = cleanChildren(parent, current, marker);
   } else if (t === "function") {
     createRenderEffect(() => {
       let v = value();
-      while (typeof v === "function") v = v();
+      while (typeof v === "function")
+        v = v();
       current = insertExpression(parent, v, current, marker);
     });
     return () => current;
@@ -1193,47 +1501,57 @@ function insertExpression(parent, value, current, marker, unwrapArray) {
       return () => current;
     }
     if (sharedConfig.context) {
-      if (!array.length) return current;
+      if (!array.length)
+        return current;
       for (let i = 0; i < array.length; i++) {
-        if (array[i].parentNode) return current = array;
+        if (array[i].parentNode)
+          return current = array;
       }
     }
     if (array.length === 0) {
       current = cleanChildren(parent, current, marker);
-      if (multi) return current;
+      if (multi)
+        return current;
     } else if (currentArray) {
       if (current.length === 0) {
         appendNodes(parent, array, marker);
-      } else reconcileArrays(parent, current, array);
+      } else
+        reconcileArrays(parent, current, array);
     } else {
       current && cleanChildren(parent);
       appendNodes(parent, array);
     }
     current = array;
   } else if (value instanceof Node) {
-    if (sharedConfig.context && value.parentNode) return current = multi ? [value] : value;
+    if (sharedConfig.context && value.parentNode)
+      return current = multi ? [value] : value;
     if (Array.isArray(current)) {
-      if (multi) return current = cleanChildren(parent, current, marker, value);
+      if (multi)
+        return current = cleanChildren(parent, current, marker, value);
       cleanChildren(parent, current, null, value);
     } else if (current == null || current === "" || !parent.firstChild) {
       parent.appendChild(value);
-    } else parent.replaceChild(value, parent.firstChild);
+    } else
+      parent.replaceChild(value, parent.firstChild);
     current = value;
-  } else console.warn(`Unrecognized value. Skipped inserting`, value);
+  } else
+    ;
   return current;
 }
 function normalizeIncomingArray(normalized, array, current, unwrap) {
   let dynamic = false;
   for (let i = 0, len = array.length; i < len; i++) {
-    let item = array[i],
-      prev = current && current[i];
+    let item = array[i], prev = current && current[i];
     if (item instanceof Node) {
       normalized.push(item);
-    } else if (item == null || item === true || item === false) ;else if (Array.isArray(item)) {
+    } else if (item == null || item === true || item === false)
+      ;
+    else if (Array.isArray(item)) {
       dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
     } else if (typeof item === "function") {
       if (unwrap) {
-        while (typeof item === "function") item = item();
+        while (typeof item === "function")
+          item = item();
         dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item], Array.isArray(prev) ? prev : [prev]) || dynamic;
       } else {
         normalized.push(item);
@@ -1242,20 +1560,24 @@ function normalizeIncomingArray(normalized, array, current, unwrap) {
     } else {
       const value = String(item);
       if (value === "<!>") {
-        if (prev && prev.nodeType === 8) normalized.push(prev);
+        if (prev && prev.nodeType === 8)
+          normalized.push(prev);
       } else if (prev && prev.nodeType === 3) {
         prev.data = value;
         normalized.push(prev);
-      } else normalized.push(document.createTextNode(value));
+      } else
+        normalized.push(document.createTextNode(value));
     }
   }
   return dynamic;
 }
 function appendNodes(parent, array, marker = null) {
-  for (let i = 0, len = array.length; i < len; i++) parent.insertBefore(array[i], marker);
+  for (let i = 0, len = array.length; i < len; i++)
+    parent.insertBefore(array[i], marker);
 }
 function cleanChildren(parent, current, marker, replacement) {
-  if (marker === undefined) return parent.textContent = "";
+  if (marker === void 0)
+    return parent.textContent = "";
   const node = replacement || document.createTextNode("");
   if (current.length) {
     let inserted = false;
@@ -1263,107 +1585,17 @@ function cleanChildren(parent, current, marker, replacement) {
       const el = current[i];
       if (node !== el) {
         const isParent = el.parentNode === parent;
-        if (!inserted && !i) isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);else isParent && el.remove();
-      } else inserted = true;
+        if (!inserted && !i)
+          isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);
+        else
+          isParent && el.remove();
+      } else
+        inserted = true;
     }
-  } else parent.insertBefore(node, marker);
+  } else
+    parent.insertBefore(node, marker);
   return [node];
 }
+var isServer = false;
 
-class TanstackQueryDevtools {
-  isMounted = false;
-  constructor(config) {
-    const {
-      client,
-      queryFlavor,
-      version,
-      onlineManager,
-      buttonPosition,
-      position,
-      initialIsOpen,
-      errorTypes
-    } = config;
-    this.client = createSignal(client);
-    this.queryFlavor = queryFlavor;
-    this.version = version;
-    this.onlineManager = onlineManager;
-    this.buttonPosition = createSignal(buttonPosition);
-    this.position = createSignal(position);
-    this.initialIsOpen = createSignal(initialIsOpen);
-    this.errorTypes = createSignal(errorTypes);
-  }
-  setButtonPosition(position) {
-    this.buttonPosition[1](position);
-  }
-  setPosition(position) {
-    this.position[1](position);
-  }
-  setInitialIsOpen(isOpen) {
-    this.initialIsOpen[1](isOpen);
-  }
-  setErrorTypes(errorTypes) {
-    this.errorTypes[1](errorTypes);
-  }
-  setClient(client) {
-    this.client[1](client);
-  }
-  mount(el) {
-    if (this.isMounted) {
-      throw new Error('Devtools is already mounted');
-    }
-    const dispose = render(() => {
-      const [btnPosition] = this.buttonPosition;
-      const [pos] = this.position;
-      const [isOpen] = this.initialIsOpen;
-      const [errors] = this.errorTypes;
-      const [queryClient] = this.client;
-      let Devtools;
-      if (this.Component) {
-        Devtools = this.Component;
-      } else {
-        Devtools = lazy(() => import('./Devtools-26de9f2c.js'));
-        this.Component = Devtools;
-      }
-      const _self$ = this;
-      return createComponent(Devtools, mergeProps({
-        get queryFlavor() {
-          return _self$.queryFlavor;
-        },
-        get version() {
-          return _self$.version;
-        },
-        get onlineManager() {
-          return _self$.onlineManager;
-        }
-      }, {
-        get client() {
-          return queryClient();
-        },
-        get buttonPosition() {
-          return btnPosition();
-        },
-        get position() {
-          return pos();
-        },
-        get initialIsOpen() {
-          return isOpen();
-        },
-        get errorTypes() {
-          return errors();
-        }
-      }));
-    }, el);
-    this.isMounted = true;
-    this.dispose = dispose;
-  }
-  unmount() {
-    if (!this.isMounted) {
-      throw new Error('Devtools is not mounted');
-    }
-    this.dispose?.();
-    this.isMounted = false;
-  }
-}
-
-export { $TRACK as $, For as F, Index as I, Match as M, Show as S, TanstackQueryDevtools as T, createMemo as a, useTransition as b, createSignal as c, createRoot as d, onMount as e, createEffect as f, createRenderEffect as g, delegateEvents as h, insert as i, createComponent as j, className as k, addEventListener as l, Switch as m, useContext as n, onCleanup as o, createContext as p, on as q, spread as r, setAttribute as s, template as t, untrack as u, mergeProps as v, use as w };
-//# sourceMappingURL=index-7c6d68e3.js.map
+export { $TRACK, For, Index, Match, Show, Switch, addEventListener, className, createComponent, createContext, createEffect, createMemo, createRenderEffect, createRoot, createSignal, delegateEvents, insert, isServer, lazy, mergeProps, on, onCleanup, onMount, render, setAttribute, spread, template, untrack, use, useContext, useTransition };