@tanstack/query-devtools 5.0.0-alpha.86 → 5.0.0-alpha.88

package/{dist/cjs/index-94a2ab18.cjs → build/chunk/YHTPXJWR.js}

@@ -1,43 +1,48 @@
-'use strict';
-
-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 {
@@ -53,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);
 }
@@ -82,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) {
@@ -99,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);
           }
@@ -157,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;
@@ -179,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: {
@@ -196,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 {
@@ -223,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;
@@ -242,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() {
@@ -270,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);
@@ -309,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);
@@ -338,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;
 }
@@ -354,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;
@@ -365,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,
@@ -384,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);
@@ -413,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);
     }
   }
@@ -478,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;
@@ -492,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) {
@@ -534,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);
@@ -576,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();
           });
@@ -593,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) {
@@ -626,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);
@@ -645,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() || [];
@@ -667,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();
           });
@@ -704,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,
@@ -751,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);
@@ -772,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;
             }
           }
         });
@@ -790,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);
@@ -815,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(() => {
@@ -845,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",
@@ -894,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++;
@@ -919,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]) {
@@ -932,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();
@@ -970,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;
@@ -1058,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];
@@ -1084,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);
@@ -1113,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;
 }
@@ -1137,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();
@@ -1150,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;
@@ -1195,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
+    console.warn(`Unrecognized value. Skipped inserting`, value);
   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);
@@ -1244,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;
@@ -1265,135 +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(() => Promise.resolve().then(function () { return require('./Devtools-5eee2153.cjs'); }));
-        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;
-  }
-}
-
-exports.$TRACK = $TRACK;
-exports.For = For;
-exports.Index = Index;
-exports.Match = Match;
-exports.Show = Show;
-exports.Switch = Switch;
-exports.TanstackQueryDevtools = TanstackQueryDevtools;
-exports.addEventListener = addEventListener;
-exports.className = className;
-exports.createComponent = createComponent;
-exports.createContext = createContext;
-exports.createEffect = createEffect;
-exports.createMemo = createMemo;
-exports.createRenderEffect = createRenderEffect;
-exports.createRoot = createRoot;
-exports.createSignal = createSignal;
-exports.delegateEvents = delegateEvents;
-exports.insert = insert;
-exports.mergeProps = mergeProps;
-exports.on = on;
-exports.onCleanup = onCleanup;
-exports.onMount = onMount;
-exports.setAttribute = setAttribute;
-exports.spread = spread;
-exports.template = template;
-exports.untrack = untrack;
-exports.use = use;
-exports.useContext = useContext;
-exports.useTransition = useTransition;
-//# sourceMappingURL=index-94a2ab18.cjs.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 };