@tanstack/query-devtools 5.1.0 → 5.7.4

package/build/chunk/SPPEWFNK.jsx

@@ -0,0 +1,3295 @@
+// ../../node_modules/.pnpm/solid-js@1.8.1/node_modules/solid-js/dist/solid.js
+var sharedConfig = {
+  context: void 0,
+  registry: void 0
+};
+function setHydrateContext(context) {
+  sharedConfig.context = context;
+}
+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 $DEVCOMP = Symbol("solid-dev-component");
+var signalOptions = {
+  equals: equalFn
+};
+var ERROR = null;
+var runEffects = runQueue;
+var STALE = 1;
+var PENDING = 2;
+var UNOWNED = {
+  owned: null,
+  cleanups: null,
+  context: null,
+  owner: null
+};
+var NO_INIT = {};
+var Owner = null;
+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, current = detachedOwner === void 0 ? owner : detachedOwner, root = unowned ? UNOWNED : {
+    owned: null,
+    cleanups: null,
+    context: current ? current.context : null,
+    owner: current
+  }, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
+  Owner = root;
+  Listener = null;
+  try {
+    return runUpdates(updateFn, true);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+}
+function createSignal(value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const s = {
+    value,
+    observers: null,
+    observerSlots: null,
+    comparator: options.equals || void 0
+  };
+  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, value2);
+  };
+  return [readSignal.bind(s), setter];
+}
+function createComputed(fn, value, options) {
+  const c = createComputation(fn, value, true, STALE);
+  if (Scheduler && Transition && Transition.running)
+    Updates.push(c);
+  else
+    updateComputation(c);
+}
+function createRenderEffect(fn, value, options) {
+  const c = createComputation(fn, value, false, STALE);
+  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), s = SuspenseContext && useContext(SuspenseContext);
+  if (s)
+    c.suspense = s;
+  if (!options || !options.render)
+    c.user = true;
+  Effects ? Effects.push(c) : updateComputation(c);
+}
+function createMemo(fn, value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const c = createComputation(fn, value, true, 0);
+  c.observers = null;
+  c.observerSlots = null;
+  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 isPromise(v) {
+  return v && typeof v === "object" && "then" in v;
+}
+function createResource(pSource, pFetcher, pOptions) {
+  let source;
+  let fetcher;
+  let options;
+  if (arguments.length === 2 && typeof pFetcher === "object" || arguments.length === 1) {
+    source = true;
+    fetcher = pSource;
+    options = pFetcher || {};
+  } else {
+    source = pSource;
+    fetcher = pFetcher;
+    options = pOptions || {};
+  }
+  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 = isPromise(v) && "value" in v ? v.value : v;
+  }
+  function loadEnd(p, v, error2, key) {
+    if (pr === p) {
+      pr = null;
+      key !== void 0 && (resolved = true);
+      if ((p === initP || v === initP) && options.onHydrated)
+        queueMicrotask(
+          () => options.onHydrated(key, {
+            value: v
+          })
+        );
+      initP = NO_INIT;
+      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 === void 0)
+        setValue(() => v);
+      setState(err !== void 0 ? "errored" : resolved ? "ready" : "unresolved");
+      setError(err);
+      for (const c of contexts.keys())
+        c.decrement();
+      contexts.clear();
+    }, false);
+  }
+  function read() {
+    const c = SuspenseContext && useContext(SuspenseContext), v = value(), err = error();
+    if (err !== void 0 && !pr)
+      throw err;
+    if (Listener && !Listener.user && c) {
+      createComputed(() => {
+        track();
+        if (pr) {
+          if (c.resolved && Transition && loadedUnderTransition)
+            Transition.promises.add(pr);
+          else if (!contexts.has(c)) {
+            c.increment();
+            contexts.add(c);
+          }
+        }
+      });
+    }
+    return v;
+  }
+  function load(refetching = true) {
+    if (refetching !== false && scheduled)
+      return;
+    scheduled = false;
+    const lookup = dynamic ? dynamic() : source;
+    loadedUnderTransition = Transition && Transition.running;
+    if (lookup == null || lookup === false) {
+      loadEnd(pr, untrack(value));
+      return;
+    }
+    if (Transition && pr)
+      Transition.promises.delete(pr);
+    const p = initP !== NO_INIT ? initP : untrack(
+      () => fetcher(lookup, {
+        value: value(),
+        refetching
+      })
+    );
+    if (!isPromise(p)) {
+      loadEnd(pr, p, void 0, lookup);
+      return p;
+    }
+    pr = p;
+    scheduled = true;
+    queueMicrotask(() => scheduled = false);
+    runUpdates(() => {
+      setState(resolved ? "refreshing" : "pending");
+      trigger();
+    }, false);
+    return p.then(
+      (v) => loadEnd(p, v, void 0, lookup),
+      (e) => loadEnd(p, void 0, castError(e), lookup)
+    );
+  }
+  Object.defineProperties(read, {
+    state: {
+      get: () => state()
+    },
+    error: {
+      get: () => error()
+    },
+    loading: {
+      get() {
+        const s = state();
+        return s === "pending" || s === "refreshing";
+      }
+    },
+    latest: {
+      get() {
+        if (!resolved)
+          return read();
+        const err = error();
+        if (err && !pr)
+          throw err;
+        return value();
+      }
+    }
+  });
+  if (dynamic)
+    createComputed(() => load(false));
+  else
+    load(false);
+  return [
+    read,
+    {
+      refetch: load,
+      mutate: setValue
+    }
+  ];
+}
+function batch(fn) {
+  return runUpdates(fn, false);
+}
+function untrack(fn) {
+  if (Listener === null)
+    return fn();
+  const listener = Listener;
+  Listener = null;
+  try {
+    return fn();
+  } finally {
+    Listener = listener;
+  }
+}
+function on(deps, fn, options) {
+  const isArray3 = Array.isArray(deps);
+  let prevInput;
+  let defer = options && options.defer;
+  return (prevValue) => {
+    let input;
+    if (isArray3) {
+      input = Array(deps.length);
+      for (let i = 0; i < deps.length; i++)
+        input[i] = deps[i]();
+    } else
+      input = deps();
+    if (defer) {
+      defer = false;
+      return void 0;
+    }
+    const result = untrack(() => fn(input, prevInput, prevValue));
+    prevInput = input;
+    return result;
+  };
+}
+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);
+  return fn;
+}
+function getListener() {
+  return Listener;
+}
+function getOwner() {
+  return Owner;
+}
+function runWithOwner(o, fn) {
+  const prev = Owner;
+  const prevListener = Listener;
+  Owner = o;
+  Listener = null;
+  try {
+    return runUpdates(fn, true);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = prev;
+    Listener = prevListener;
+  }
+}
+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 : void 0;
+  });
+}
+function useTransition() {
+  return [transPending, startTransition];
+}
+function createContext(defaultValue, options) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id),
+    defaultValue
+  };
+}
+function useContext(context) {
+  return Owner && Owner.context && Owner.context[context.id] !== void 0 ? Owner.context[context.id] : context.defaultValue;
+}
+function children(fn) {
+  const children2 = createMemo(fn);
+  const memo = createMemo(() => resolveChildren(children2()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+var SuspenseContext;
+function readSignal() {
+  const runningTransition = Transition && Transition.running;
+  if (this.sources && (runningTransition ? this.tState : this.state)) {
+    if ((runningTransition ? this.tState : this.state) === STALE)
+      updateComputation(this);
+    else {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(this), false);
+      Updates = updates;
+    }
+  }
+  if (Listener) {
+    const sSlot = this.observers ? this.observers.length : 0;
+    if (!Listener.sources) {
+      Listener.sources = [this];
+      Listener.sourceSlots = [sSlot];
+    } else {
+      Listener.sources.push(this);
+      Listener.sourceSlots.push(sSlot);
+    }
+    if (!this.observers) {
+      this.observers = [Listener];
+      this.observerSlots = [Listener.sources.length - 1];
+    } else {
+      this.observers.push(Listener);
+      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 = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+  if (!node.comparator || !node.comparator(current, 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))
+            continue;
+          if (TransitionRunning ? !o.tState : !o.state) {
+            if (o.pure)
+              Updates.push(o);
+            else
+              Effects.push(o);
+            if (o.observers)
+              markDownstream(o);
+          }
+          if (!TransitionRunning)
+            o.state = STALE;
+          else
+            o.tState = STALE;
+        }
+        if (Updates.length > 1e6) {
+          Updates = [];
+          if (false)
+            ;
+          throw new Error();
+        }
+      }, false);
+    }
+  }
+  return value;
+}
+function updateComputation(node) {
+  if (!node.fn)
+    return;
+  cleanNode(node);
+  const owner = Owner, listener = Listener, time = ExecCount;
+  Listener = Owner = node;
+  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;
+}
+function runComputation(node, value, time) {
+  let nextValue;
+  try {
+    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;
+      }
+    }
+    node.updatedAt = time + 1;
+    return handleError(err);
+  }
+  if (!node.updatedAt || node.updatedAt <= time) {
+    if (node.updatedAt != null && "observers" in node) {
+      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,
+    updatedAt: null,
+    owned: null,
+    sources: null,
+    sourceSlots: null,
+    cleanups: null,
+    value: init,
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    pure
+  };
+  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 && Transition.running;
+  if ((runningTransition ? node.tState : node.state) === 0)
+    return;
+  if ((runningTransition ? node.tState : node.state) === 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 (runningTransition && Transition.disposed.has(node))
+      return;
+    if (runningTransition ? node.tState : node.state)
+      ancestors.push(node);
+  }
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    node = ancestors[i];
+    if (runningTransition) {
+      let top = node, prev = ancestors[i + 1];
+      while ((top = top.owner) && top !== prev) {
+        if (Transition.disposed.has(top))
+          return;
+      }
+    }
+    if ((runningTransition ? node.tState : node.state) === STALE) {
+      updateComputation(node);
+    } else if ((runningTransition ? node.tState : node.state) === PENDING) {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(node, ancestors[0]), false);
+      Updates = updates;
+    }
+  }
+}
+function runUpdates(fn, init) {
+  if (Updates)
+    return fn();
+  let wait = false;
+  if (!init)
+    Updates = [];
+  if (Effects)
+    wait = true;
+  else
+    Effects = [];
+  ExecCount++;
+  try {
+    const res = fn();
+    completeUpdates(wait);
+    return res;
+  } catch (err) {
+    if (!wait)
+      Effects = null;
+    Updates = null;
+    handleError(err);
+  }
+}
+function completeUpdates(wait) {
+  if (Updates) {
+    if (Scheduler && Transition && Transition.running)
+      scheduleQueue(Updates);
+    else
+      runQueue(Updates);
+    Updates = null;
+  }
+  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 (res)
+    res();
+}
+function runQueue(queue) {
+  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;
+  for (i = 0; i < queue.length; i++) {
+    const e = queue[i];
+    if (!e.user)
+      runTop(e);
+    else
+      queue[userLength++] = e;
+  }
+  if (sharedConfig.context) {
+    if (sharedConfig.count) {
+      sharedConfig.effects || (sharedConfig.effects = []);
+      sharedConfig.effects.push(...queue.slice(0, userLength));
+      return;
+    } else if (sharedConfig.effects) {
+      queue = [...sharedConfig.effects, ...queue];
+      userLength += sharedConfig.effects.length;
+      delete sharedConfig.effects;
+    }
+    setHydrateContext();
+  }
+  for (i = 0; i < userLength; i++)
+    runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+  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) {
+      const state = runningTransition ? source.tState : source.state;
+      if (state === STALE) {
+        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount))
+          runTop(source);
+      } else if (state === PENDING)
+        lookUpstream(source, ignore);
+    }
+  }
+}
+function markDownstream(node) {
+  const runningTransition = Transition && Transition.running;
+  for (let i = 0; i < node.observers.length; i += 1) {
+    const o = node.observers[i];
+    if (runningTransition ? !o.tState : !o.state) {
+      if (runningTransition)
+        o.tState = PENDING;
+      else
+        o.state = PENDING;
+      if (o.pure)
+        Updates.push(o);
+      else
+        Effects.push(o);
+      o.observers && markDownstream(o);
+    }
+  }
+}
+function cleanNode(node) {
+  let i;
+  if (node.sources) {
+    while (node.sources.length) {
+      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+      if (obs && obs.length) {
+        const n = obs.pop(), s = source.observerSlots.pop();
+        if (index < obs.length) {
+          n.sourceSlots[s] = index;
+          obs[index] = n;
+          source.observerSlots[index] = s;
+        }
+      }
+    }
+  }
+  if (Transition && Transition.running && node.pure) {
+    if (node.tOwned) {
+      for (i = node.tOwned.length - 1; i >= 0; i--)
+        cleanNode(node.tOwned[i]);
+      delete node.tOwned;
+    }
+    reset(node, true);
+  } else if (node.owned) {
+    for (i = node.owned.length - 1; i >= 0; i--)
+      cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (i = node.cleanups.length - 1; i >= 0; i--)
+      node.cleanups[i]();
+    node.cleanups = null;
+  }
+  if (Transition && Transition.running)
+    node.tState = 0;
+  else
+    node.state = 0;
+}
+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)
+    return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function runErrors(err, fns, owner) {
+  try {
+    for (const f of fns)
+      f(err);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+function handleError(err, owner = Owner) {
+  const fns = ERROR && owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns)
+    throw error;
+  if (Effects)
+    Effects.push({
+      fn() {
+        runErrors(error, fns, owner);
+      },
+      state: STALE
+    });
+  else
+    runErrors(error, fns, owner);
+}
+function resolveChildren(children2) {
+  if (typeof children2 === "function" && !children2.length)
+    return resolveChildren(children2());
+  if (Array.isArray(children2)) {
+    const results = [];
+    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 children2;
+}
+function createProvider(id, options) {
+  return function provider(props) {
+    let res;
+    createRenderEffect(
+      () => res = untrack(() => {
+        Owner.context = {
+          ...Owner.context,
+          [id]: props.value
+        };
+        return children(() => props.children);
+      }),
+      void 0
+    );
+    return res;
+  };
+}
+var FALLBACK = Symbol("fallback");
+function dispose(d) {
+  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;
+  onCleanup(() => dispose(disposers));
+  return () => {
+    let newItems = list() || [], i, j;
+    newItems[$TRACK];
+    return untrack(() => {
+      let newLen = newItems.length, newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
+      if (newLen === 0) {
+        if (len !== 0) {
+          dispose(disposers);
+          disposers = [];
+          items = [];
+          mapped = [];
+          len = 0;
+          indexes && (indexes = []);
+        }
+        if (options.fallback) {
+          items = [FALLBACK];
+          mapped[0] = createRoot((disposer) => {
+            disposers[0] = disposer;
+            return options.fallback();
+          });
+          len = 1;
+        }
+      } else if (len === 0) {
+        mapped = new Array(newLen);
+        for (j = 0; j < newLen; j++) {
+          items[j] = newItems[j];
+          mapped[j] = createRoot(mapper);
+        }
+        len = newLen;
+      } else {
+        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 (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 = /* @__PURE__ */ new Map();
+        newIndicesNext = new Array(newEnd + 1);
+        for (j = newEnd; j >= start; j--) {
+          item = newItems[j];
+          i = newIndices.get(item);
+          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 !== 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]();
+        }
+        for (j = start; j < newLen; j++) {
+          if (j in temp) {
+            mapped[j] = temp[j];
+            disposers[j] = tempdisposers[j];
+            if (indexes) {
+              indexes[j] = tempIndexes[j];
+              indexes[j](j);
+            }
+          } else
+            mapped[j] = createRoot(mapper);
+        }
+        mapped = mapped.slice(0, len = newLen);
+        items = newItems.slice(0);
+      }
+      return mapped;
+    });
+    function mapper(disposer) {
+      disposers[j] = disposer;
+      if (indexes) {
+        const [s, set] = createSignal(j);
+        indexes[j] = set;
+        return mapFn(newItems[j], s);
+      }
+      return mapFn(newItems[j]);
+    }
+  };
+}
+function indexArray(list, mapFn, options = {}) {
+  let items = [], mapped = [], disposers = [], signals = [], len = 0, i;
+  onCleanup(() => dispose(disposers));
+  return () => {
+    const newItems = list() || [];
+    newItems[$TRACK];
+    return untrack(() => {
+      if (newItems.length === 0) {
+        if (len !== 0) {
+          dispose(disposers);
+          disposers = [];
+          items = [];
+          mapped = [];
+          len = 0;
+          signals = [];
+        }
+        if (options.fallback) {
+          items = [FALLBACK];
+          mapped[0] = createRoot((disposer) => {
+            disposers[0] = disposer;
+            return options.fallback();
+          });
+          len = 1;
+        }
+        return mapped;
+      }
+      if (items[0] === FALLBACK) {
+        disposers[0]();
+        disposers = [];
+        items = [];
+        mapped = [];
+        len = 0;
+      }
+      for (i = 0; i < newItems.length; i++) {
+        if (i < items.length && items[i] !== newItems[i]) {
+          signals[i](() => newItems[i]);
+        } else if (i >= items.length) {
+          mapped[i] = createRoot(mapper);
+        }
+      }
+      for (; i < items.length; i++) {
+        disposers[i]();
+      }
+      len = signals.length = disposers.length = newItems.length;
+      items = newItems.slice(0);
+      return mapped = mapped.slice(0, len);
+    });
+    function mapper(disposer) {
+      disposers[i] = disposer;
+      const [s, set] = createSignal(newItems[i]);
+      signals[i] = set;
+      return mapFn(s, i);
+    }
+  };
+}
+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;
+}
+var propTraps = {
+  get(_, property, receiver) {
+    if (property === $PROXY)
+      return receiver;
+    return _.get(property);
+  },
+  has(_, property) {
+    if (property === $PROXY)
+      return true;
+    return _.has(property);
+  },
+  set: trueFn,
+  deleteProperty: trueFn,
+  getOwnPropertyDescriptor(_, property) {
+    return {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return _.get(property);
+      },
+      set: trueFn,
+      deleteProperty: trueFn
+    };
+  },
+  ownKeys(_) {
+    return _.keys();
+  }
+};
+function resolveSource(s) {
+  return !(s = typeof s === "function" ? s() : s) ? {} : s;
+}
+function resolveSources() {
+  for (let i = 0, length = this.length; i < length; ++i) {
+    const v = this[i]();
+    if (v !== void 0)
+      return v;
+  }
+}
+function mergeProps(...sources) {
+  let proxy = false;
+  for (let i = 0; i < sources.length; i++) {
+    const s = sources[i];
+    proxy = proxy || !!s && $PROXY in s;
+    sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
+  }
+  if (proxy) {
+    return new Proxy(
+      {
+        get(property) {
+          for (let i = sources.length - 1; i >= 0; i--) {
+            const v = resolveSource(sources[i])[property];
+            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;
+          }
+          return false;
+        },
+        keys() {
+          const keys = [];
+          for (let i = 0; i < sources.length; i++)
+            keys.push(...Object.keys(resolveSource(sources[i])));
+          return [...new Set(keys)];
+        }
+      },
+      propTraps
+    );
+  }
+  const target = {};
+  const sourcesMap = {};
+  const defined = /* @__PURE__ */ new Set();
+  for (let i = sources.length - 1; i >= 0; i--) {
+    const source = sources[i];
+    if (!source)
+      continue;
+    const sourceKeys = Object.getOwnPropertyNames(source);
+    for (let i2 = 0, length = sourceKeys.length; i2 < length; i2++) {
+      const key = sourceKeys[i2];
+      if (key === "__proto__" || key === "constructor")
+        continue;
+      const desc = Object.getOwnPropertyDescriptor(source, key);
+      if (!defined.has(key)) {
+        if (desc.get) {
+          defined.add(key);
+          Object.defineProperty(target, key, {
+            enumerable: true,
+            configurable: true,
+            get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
+          });
+        } else {
+          if (desc.value !== void 0)
+            defined.add(key);
+          target[key] = desc.value;
+        }
+      } else {
+        const sources2 = sourcesMap[key];
+        if (sources2) {
+          if (desc.get) {
+            sources2.push(desc.get.bind(source));
+          } else if (desc.value !== void 0) {
+            sources2.push(() => desc.value);
+          }
+        } else if (target[key] === void 0)
+          target[key] = desc.value;
+      }
+    }
+  }
+  return target;
+}
+function splitProps(props, ...keys) {
+  if ($PROXY in props) {
+    const blocked = new Set(keys.length > 1 ? keys.flat() : keys[0]);
+    const res = keys.map((k) => {
+      return new Proxy(
+        {
+          get(property) {
+            return k.includes(property) ? props[property] : void 0;
+          },
+          has(property) {
+            return k.includes(property) && property in props;
+          },
+          keys() {
+            return k.filter((property) => property in props);
+          }
+        },
+        propTraps
+      );
+    });
+    res.push(
+      new Proxy(
+        {
+          get(property) {
+            return blocked.has(property) ? void 0 : props[property];
+          },
+          has(property) {
+            return blocked.has(property) ? false : property in props;
+          },
+          keys() {
+            return Object.keys(props).filter((k) => !blocked.has(k));
+          }
+        },
+        propTraps
+      )
+    );
+    return res;
+  }
+  const otherObject = {};
+  const objects = keys.map(() => ({}));
+  for (const propName of Object.getOwnPropertyNames(props)) {
+    const desc = Object.getOwnPropertyDescriptor(props, propName);
+    const isDefaultDesc = !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable;
+    let blocked = false;
+    let objectIndex = 0;
+    for (const k of keys) {
+      if (k.includes(propName)) {
+        blocked = true;
+        isDefaultDesc ? objects[objectIndex][propName] = desc.value : Object.defineProperty(objects[objectIndex], propName, desc);
+      }
+      ++objectIndex;
+    }
+    if (!blocked) {
+      isDefaultDesc ? otherObject[propName] = desc.value : Object.defineProperty(otherObject, propName, desc);
+    }
+  }
+  return [...objects, otherObject];
+}
+function lazy(fn) {
+  let comp;
+  let p;
+  const wrap = (props) => {
+    const ctx = sharedConfig.context;
+    if (ctx) {
+      const [s, set] = createSignal();
+      sharedConfig.count || (sharedConfig.count = 0);
+      sharedConfig.count++;
+      (p || (p = fn())).then((mod) => {
+        setHydrateContext(ctx);
+        sharedConfig.count--;
+        set(() => mod.default);
+        setHydrateContext();
+      });
+      comp = s;
+    } else if (!comp) {
+      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);
+        const c = sharedConfig.context;
+        setHydrateContext(ctx);
+        const r = Comp(props);
+        setHydrateContext(c);
+        return r;
+      })
+    );
+  };
+  wrap.preload = () => p || ((p = fn()).then((mod) => comp = () => mod.default), p);
+  return wrap;
+}
+var counter = 0;
+function createUniqueId() {
+  const ctx = sharedConfig.context;
+  return ctx ? `${ctx.id}${ctx.count++}` : `cl-${counter++}`;
+}
+var narrowedError = (name) => `Stale read from <${name}>.`;
+function For(props) {
+  const fallback = "fallback" in props && {
+    fallback: () => props.fallback
+  };
+  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 || void 0));
+}
+function Show(props) {
+  const keyed = props.keyed;
+  const condition = createMemo(() => props.when, void 0, {
+    equals: (a, b) => keyed ? a === b : !a === !b
+  });
+  return createMemo(
+    () => {
+      const c = condition();
+      if (c) {
+        const child = props.children;
+        const fn = typeof child === "function" && child.length > 0;
+        return fn ? untrack(
+          () => child(
+            keyed ? c : () => {
+              if (!untrack(condition))
+                throw narrowedError("Show");
+              return props.when;
+            }
+          )
+        ) : child;
+      }
+      return props.fallback;
+    },
+    void 0,
+    void 0
+  );
+}
+function Switch(props) {
+  let keyed = false;
+  const equals = (a, b) => a[0] === b[0] && (keyed ? 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]];
+        }
+      }
+      return [-1];
+    },
+    void 0,
+    {
+      equals
+    }
+  );
+  return createMemo(
+    () => {
+      const [index, when, cond] = evalConditions();
+      if (index < 0)
+        return props.fallback;
+      const c = cond.children;
+      const fn = typeof c === "function" && c.length > 0;
+      return fn ? untrack(
+        () => c(
+          keyed ? when : () => {
+            if (untrack(evalConditions)[0] !== index)
+              throw narrowedError("Match");
+            return cond.when;
+          }
+        )
+      ) : c;
+    },
+    void 0,
+    void 0
+  );
+}
+function Match(props) {
+  return props;
+}
+var SuspenseListContext = createContext();
+var DEV = void 0;
+
+// ../../node_modules/.pnpm/solid-js@1.8.1/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"
+});
+var PropAliases = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(null), {
+  class: "className",
+  formnovalidate: {
+    $: "formNoValidate",
+    BUTTON: 1,
+    INPUT: 1
+  },
+  ismap: {
+    $: "isMap",
+    IMG: 1
+  },
+  nomodule: {
+    $: "noModule",
+    SCRIPT: 1
+  },
+  playsinline: {
+    $: "playsInline",
+    VIDEO: 1
+  },
+  readonly: {
+    $: "readOnly",
+    INPUT: 1,
+    TEXTAREA: 1
+  }
+});
+function getPropAlias(prop, tagName) {
+  const a = PropAliases[prop];
+  return typeof a === "object" ? a[tagName] ? a["$"] : void 0 : a;
+}
+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 SVGElements = /* @__PURE__ */ new Set([
+  "altGlyph",
+  "altGlyphDef",
+  "altGlyphItem",
+  "animate",
+  "animateColor",
+  "animateMotion",
+  "animateTransform",
+  "circle",
+  "clipPath",
+  "color-profile",
+  "cursor",
+  "defs",
+  "desc",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "font",
+  "font-face",
+  "font-face-format",
+  "font-face-name",
+  "font-face-src",
+  "font-face-uri",
+  "foreignObject",
+  "g",
+  "glyph",
+  "glyphRef",
+  "hkern",
+  "image",
+  "line",
+  "linearGradient",
+  "marker",
+  "mask",
+  "metadata",
+  "missing-glyph",
+  "mpath",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "set",
+  "stop",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "textPath",
+  "tref",
+  "tspan",
+  "use",
+  "view",
+  "vkern"
+]);
+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;
+  while (aStart < aEnd || bStart < bEnd) {
+    if (a[aStart] === b[bStart]) {
+      aStart++;
+      bStart++;
+      continue;
+    }
+    while (a[aEnd - 1] === b[bEnd - 1]) {
+      aEnd--;
+      bEnd--;
+    }
+    if (aEnd === aStart) {
+      const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] : after;
+      while (bStart < bEnd)
+        parentNode.insertBefore(b[bStart++], node);
+    } else if (bEnd === bStart) {
+      while (aStart < aEnd) {
+        if (!map || !map.has(a[aStart]))
+          a[aStart].remove();
+        aStart++;
+      }
+    } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+      const node = a[--aEnd].nextSibling;
+      parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling);
+      parentNode.insertBefore(b[--bEnd], node);
+      a[aEnd] = b[bEnd];
+    } else {
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        let i = bStart;
+        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;
+          while (++i < aEnd && i < bEnd) {
+            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();
+    }
+  }
+}
+var $$EVENTS = "_$DX_DELEGATE";
+function render(code, element, init, options = {}) {
+  let disposer;
+  createRoot((dispose2) => {
+    disposer = dispose2;
+    element === document ? code() : insert(element, code(), element.firstChild ? null : void 0, init);
+  }, options.owner);
+  return () => {
+    disposer();
+    element.textContent = "";
+  };
+}
+function template(html, isCE, isSVG) {
+  let node;
+  const create = () => {
+    const t = document.createElement("template");
+    t.innerHTML = html;
+    return isSVG ? t.content.firstChild.firstChild : t.content.firstChild;
+  };
+  const fn = isCE ? () => untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+  fn.cloneNode = fn;
+  return fn;
+}
+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);
+      document2.addEventListener(name, eventHandler);
+    }
+  }
+}
+function setAttribute(node, name, value) {
+  if (sharedConfig.context)
+    return;
+  if (value == null)
+    node.removeAttribute(name);
+  else
+    node.setAttribute(name, value);
+}
+function setAttributeNS(node, namespace, name, value) {
+  if (sharedConfig.context)
+    return;
+  if (value == null)
+    node.removeAttributeNS(namespace, name);
+  else
+    node.setAttributeNS(namespace, name, value);
+}
+function className(node, value) {
+  if (sharedConfig.context)
+    return;
+  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 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);
+}
+function classList(node, value, 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;
+    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;
+    toggleClassKey(node, key, true);
+    prev[key] = classValue;
+  }
+  return prev;
+}
+function style(node, value, prev) {
+  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 = void 0);
+  prev || (prev = {});
+  value || (value = {});
+  let v, s;
+  for (s in prev) {
+    value[s] == null && nodeStyle.removeProperty(s);
+    delete prev[s];
+  }
+  for (s in value) {
+    v = value[s];
+    if (v !== prev[s]) {
+      nodeStyle.setProperty(s, v);
+      prev[s] = v;
+    }
+  }
+  return prev;
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+  const prevProps = {};
+  if (!skipChildren) {
+    createRenderEffect(
+      () => prevProps.children = insertExpression(node, props.children, prevProps.children)
+    );
+  }
+  createRenderEffect(() => props.ref && props.ref(node));
+  createRenderEffect(() => assign(node, props, isSVG, true, prevProps, true));
+  return prevProps;
+}
+function use(fn, element, arg) {
+  return untrack(() => fn(element, arg));
+}
+function insert(parent, accessor, 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;
+      prevProps[prop] = assignProp(node, prop, null, prevProps[prop], isSVG, skipRef);
+    }
+  }
+  for (const prop in props) {
+    if (prop === "children") {
+      if (!skipChildren)
+        insertExpression(node, props.children);
+      continue;
+    }
+    const value = props[prop];
+    prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG, skipRef);
+  }
+}
+function getNextElement(template2) {
+  let node, key;
+  if (!sharedConfig.context || !(node = sharedConfig.registry.get(key = getHydrationKey()))) {
+    return template2();
+  }
+  if (sharedConfig.completed)
+    sharedConfig.completed.add(node);
+  sharedConfig.registry.delete(key);
+  return node;
+}
+function toPropertyName(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+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);
+}
+function assignProp(node, prop, value, prev, isSVG, skipRef) {
+  let isCE, isProp, isChildProp, propAlias, forceProp;
+  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);
+  } else if (prop.slice(0, 3) === "on:") {
+    const e = prop.slice(3);
+    prev && node.removeEventListener(e, prev);
+    value && node.addEventListener(e, value);
+  } else if (prop.slice(0, 10) === "oncapture:") {
+    const e = prop.slice(10);
+    prev && node.removeEventListener(e, prev, true);
+    value && node.addEventListener(e, value, true);
+  } else if (prop.slice(0, 2) === "on") {
+    const name = prop.slice(2).toLowerCase();
+    const delegate = DelegatedEvents.has(name);
+    if (!delegate && prev) {
+      const h = Array.isArray(prev) ? prev[0] : prev;
+      node.removeEventListener(name, h);
+    }
+    if (delegate || value) {
+      addEventListener(node, name, value, delegate);
+      delegate && delegateEvents([name]);
+    }
+  } else if (prop.slice(0, 5) === "attr:") {
+    setAttribute(node, prop.slice(5), value);
+  } else if ((forceProp = prop.slice(0, 5) === "prop:") || (isChildProp = ChildProperties.has(prop)) || !isSVG && ((propAlias = getPropAlias(prop, node.tagName)) || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-"))) {
+    if (forceProp) {
+      prop = prop.slice(5);
+      isProp = true;
+    } else if (sharedConfig.context)
+      return value;
+    if (prop === "class" || prop === "className")
+      className(node, value);
+    else if (isCE && !isProp && !isChildProp)
+      node[toPropertyName(prop)] = value;
+    else
+      node[propAlias || 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);
+  }
+  return value;
+}
+function eventHandler(e) {
+  const key = `$$${e.type}`;
+  let node = e.composedPath && e.composedPath()[0] || e.target;
+  if (e.target !== node) {
+    Object.defineProperty(e, "target", {
+      configurable: true,
+      value: node
+    });
+  }
+  Object.defineProperty(e, "currentTarget", {
+    configurable: true,
+    get() {
+      return node || document;
+    }
+  });
+  if (sharedConfig.registry && !sharedConfig.done)
+    sharedConfig.done = _$HY.done = true;
+  while (node) {
+    const handler = node[key];
+    if (handler && !node.disabled) {
+      const data = node[`${key}Data`];
+      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]);
+    let cleaned = [];
+    for (let i = 0; i < current.length; i++) {
+      const node = current[i];
+      if (node.nodeType === 8 && node.data.slice(0, 2) === "!$")
+        node.remove();
+      else
+        cleaned.push(node);
+    }
+    current = cleaned;
+  }
+  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 (multi) {
+      let node = current[0];
+      if (node && node.nodeType === 3) {
+        node.data = 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 if (value == null || t === "boolean") {
+    if (sharedConfig.context)
+      return current;
+    current = cleanChildren(parent, current, marker);
+  } else if (t === "function") {
+    createRenderEffect(() => {
+      let v = value();
+      while (typeof v === "function")
+        v = v();
+      current = insertExpression(parent, v, current, marker);
+    });
+    return () => current;
+  } else if (Array.isArray(value)) {
+    const array = [];
+    const currentArray = current && Array.isArray(current);
+    if (normalizeIncomingArray(array, value, current, unwrapArray)) {
+      createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+      return () => current;
+    }
+    if (sharedConfig.context) {
+      if (!array.length)
+        return current;
+      if (marker === void 0)
+        return [...parent.childNodes];
+      let node = array[0];
+      let nodes = [node];
+      while ((node = node.nextSibling) !== marker)
+        nodes.push(node);
+      return current = nodes;
+    }
+    if (array.length === 0) {
+      current = cleanChildren(parent, current, marker);
+      if (multi)
+        return current;
+    } else if (currentArray) {
+      if (current.length === 0) {
+        appendNodes(parent, array, marker);
+      } else
+        reconcileArrays(parent, current, array);
+    } else {
+      current && cleanChildren(parent);
+      appendNodes(parent, array);
+    }
+    current = array;
+  } else if (value.nodeType) {
+    if (sharedConfig.context && value.parentNode)
+      return current = multi ? [value] : value;
+    if (Array.isArray(current)) {
+      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);
+    current = 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], t;
+    if (item == null || item === true || item === false)
+      ;
+    else if ((t = typeof item) === "object" && item.nodeType) {
+      normalized.push(item);
+    } else if (Array.isArray(item)) {
+      dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
+    } else if (t === "function") {
+      if (unwrap) {
+        while (typeof item === "function")
+          item = item();
+        dynamic = normalizeIncomingArray(
+          normalized,
+          Array.isArray(item) ? item : [item],
+          Array.isArray(prev) ? prev : [prev]
+        ) || dynamic;
+      } else {
+        normalized.push(item);
+        dynamic = true;
+      }
+    } else {
+      const value = String(item);
+      if (prev && prev.nodeType === 3 && prev.data === value)
+        normalized.push(prev);
+      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);
+}
+function cleanChildren(parent, current, marker, replacement) {
+  if (marker === void 0)
+    return parent.textContent = "";
+  const node = replacement || document.createTextNode("");
+  if (current.length) {
+    let inserted = false;
+    for (let i = current.length - 1; i >= 0; i--) {
+      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;
+    }
+  } else
+    parent.insertBefore(node, marker);
+  return [node];
+}
+function getHydrationKey() {
+  const hydrate = sharedConfig.context;
+  return `${hydrate.id}${hydrate.count++}`;
+}
+var isServer = false;
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function createElement(tagName, isSVG = false) {
+  return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName);
+}
+function Portal(props) {
+  const { useShadow } = props, marker = document.createTextNode(""), mount = () => props.mount || document.body, owner = getOwner();
+  let content;
+  let hydrating = !!sharedConfig.context;
+  createEffect(
+    () => {
+      if (hydrating)
+        getOwner().user = hydrating = false;
+      content || (content = runWithOwner(owner, () => createMemo(() => props.children)));
+      const el = mount();
+      if (el instanceof HTMLHeadElement) {
+        const [clean, setClean] = createSignal(false);
+        const cleanup = () => setClean(true);
+        createRoot((dispose2) => insert(el, () => !clean() ? content() : dispose2(), null));
+        onCleanup(cleanup);
+      } else {
+        const container = createElement(props.isSVG ? "g" : "div", props.isSVG), renderRoot = useShadow && container.attachShadow ? container.attachShadow({
+          mode: "open"
+        }) : container;
+        Object.defineProperty(container, "_$host", {
+          get() {
+            return marker.parentNode;
+          },
+          configurable: true
+        });
+        insert(renderRoot, content);
+        el.appendChild(container);
+        props.ref && props.ref(container);
+        onCleanup(() => el.removeChild(container));
+      }
+    },
+    void 0,
+    {
+      render: !hydrating
+    }
+  );
+  return marker;
+}
+function Dynamic(props) {
+  const [p, others] = splitProps(props, ["component"]);
+  const cached = createMemo(() => p.component);
+  return createMemo(() => {
+    const component = cached();
+    switch (typeof component) {
+      case "function":
+        return untrack(() => component(others));
+      case "string":
+        const isSvg = SVGElements.has(component);
+        const el = sharedConfig.context ? getNextElement() : createElement(component, isSvg);
+        spread(el, others, isSvg);
+        return el;
+    }
+  });
+}
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/double-indexed-kv.js
+var DoubleIndexedKV = (
+  /** @class */
+  function() {
+    function DoubleIndexedKV2() {
+      this.keyToValue = /* @__PURE__ */ new Map();
+      this.valueToKey = /* @__PURE__ */ new Map();
+    }
+    DoubleIndexedKV2.prototype.set = function(key, value) {
+      this.keyToValue.set(key, value);
+      this.valueToKey.set(value, key);
+    };
+    DoubleIndexedKV2.prototype.getByKey = function(key) {
+      return this.keyToValue.get(key);
+    };
+    DoubleIndexedKV2.prototype.getByValue = function(value) {
+      return this.valueToKey.get(value);
+    };
+    DoubleIndexedKV2.prototype.clear = function() {
+      this.keyToValue.clear();
+      this.valueToKey.clear();
+    };
+    return DoubleIndexedKV2;
+  }()
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/registry.js
+var Registry = (
+  /** @class */
+  function() {
+    function Registry2(generateIdentifier) {
+      this.generateIdentifier = generateIdentifier;
+      this.kv = new DoubleIndexedKV();
+    }
+    Registry2.prototype.register = function(value, identifier) {
+      if (this.kv.getByValue(value)) {
+        return;
+      }
+      if (!identifier) {
+        identifier = this.generateIdentifier(value);
+      }
+      this.kv.set(identifier, value);
+    };
+    Registry2.prototype.clear = function() {
+      this.kv.clear();
+    };
+    Registry2.prototype.getIdentifier = function(value) {
+      return this.kv.getByValue(value);
+    };
+    Registry2.prototype.getValue = function(identifier) {
+      return this.kv.getByKey(identifier);
+    };
+    return Registry2;
+  }()
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/class-registry.js
+var __extends = function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2)
+        if (Object.prototype.hasOwnProperty.call(b2, p))
+          d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var ClassRegistry = (
+  /** @class */
+  function(_super) {
+    __extends(ClassRegistry2, _super);
+    function ClassRegistry2() {
+      var _this = _super.call(this, function(c) {
+        return c.name;
+      }) || this;
+      _this.classToAllowedProps = /* @__PURE__ */ new Map();
+      return _this;
+    }
+    ClassRegistry2.prototype.register = function(value, options) {
+      if (typeof options === "object") {
+        if (options.allowProps) {
+          this.classToAllowedProps.set(value, options.allowProps);
+        }
+        _super.prototype.register.call(this, value, options.identifier);
+      } else {
+        _super.prototype.register.call(this, value, options);
+      }
+    };
+    ClassRegistry2.prototype.getAllowedProps = function(value) {
+      return this.classToAllowedProps.get(value);
+    };
+    return ClassRegistry2;
+  }(Registry)
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/util.js
+var __read = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  var values = [];
+  for (var key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  var values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  var valuesNotNever = values;
+  for (var i = 0; i < valuesNotNever.length; i++) {
+    var value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(function(_a) {
+    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    return run(value, key);
+  });
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (var i = 0; i < record.length; i++) {
+    var value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/custom-transformer-registry.js
+var CustomTransformerRegistry = (
+  /** @class */
+  function() {
+    function CustomTransformerRegistry2() {
+      this.transfomers = {};
+    }
+    CustomTransformerRegistry2.prototype.register = function(transformer) {
+      this.transfomers[transformer.name] = transformer;
+    };
+    CustomTransformerRegistry2.prototype.findApplicable = function(v) {
+      return find(this.transfomers, function(transformer) {
+        return transformer.isApplicable(v);
+      });
+    };
+    CustomTransformerRegistry2.prototype.findByName = function(name) {
+      return this.transfomers[name];
+    };
+    return CustomTransformerRegistry2;
+  }()
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/is.js
+var getType = function(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+};
+var isUndefined = function(payload) {
+  return typeof payload === "undefined";
+};
+var isNull = function(payload) {
+  return payload === null;
+};
+var isPlainObject = function(payload) {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = function(payload) {
+  return isPlainObject(payload) && Object.keys(payload).length === 0;
+};
+var isArray = function(payload) {
+  return Array.isArray(payload);
+};
+var isString = function(payload) {
+  return typeof payload === "string";
+};
+var isNumber = function(payload) {
+  return typeof payload === "number" && !isNaN(payload);
+};
+var isBoolean = function(payload) {
+  return typeof payload === "boolean";
+};
+var isRegExp = function(payload) {
+  return payload instanceof RegExp;
+};
+var isMap = function(payload) {
+  return payload instanceof Map;
+};
+var isSet = function(payload) {
+  return payload instanceof Set;
+};
+var isSymbol = function(payload) {
+  return getType(payload) === "Symbol";
+};
+var isDate = function(payload) {
+  return payload instanceof Date && !isNaN(payload.valueOf());
+};
+var isError = function(payload) {
+  return payload instanceof Error;
+};
+var isNaNValue = function(payload) {
+  return typeof payload === "number" && isNaN(payload);
+};
+var isPrimitive = function(payload) {
+  return isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+};
+var isBigint = function(payload) {
+  return typeof payload === "bigint";
+};
+var isInfinite = function(payload) {
+  return payload === Infinity || payload === -Infinity;
+};
+var isTypedArray = function(payload) {
+  return ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+};
+var isURL = function(payload) {
+  return payload instanceof URL;
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/pathstringifier.js
+var escapeKey = function(key) {
+  return key.replace(/\./g, "\\.");
+};
+var stringifyPath = function(path) {
+  return path.map(String).map(escapeKey).join(".");
+};
+var parsePath = function(string) {
+  var result = [];
+  var segment = "";
+  for (var i = 0; i < string.length; i++) {
+    var char = string.charAt(i);
+    var isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i++;
+      continue;
+    }
+    var isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  var lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/transformer.js
+var __assign = function() {
+  __assign = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __read2 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = function(to, from) {
+  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+    to[j] = from[i];
+  return to;
+};
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var simpleRules = [
+  simpleTransformation(isUndefined, "undefined", function() {
+    return null;
+  }, function() {
+    return void 0;
+  }),
+  simpleTransformation(isBigint, "bigint", function(v) {
+    return v.toString();
+  }, function(v) {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    console.error("Please add a BigInt polyfill.");
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", function(v) {
+    return v.toISOString();
+  }, function(v) {
+    return new Date(v);
+  }),
+  simpleTransformation(isError, "Error", function(v, superJson) {
+    var baseError = {
+      name: v.name,
+      message: v.message
+    };
+    superJson.allowedErrorProps.forEach(function(prop) {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, function(v, superJson) {
+    var e = new Error(v.message);
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach(function(prop) {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", function(v) {
+    return "" + v;
+  }, function(regex) {
+    var body = regex.slice(1, regex.lastIndexOf("/"));
+    var flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    function(v) {
+      return __spreadArray([], __read2(v.values()));
+    },
+    function(v) {
+      return new Set(v);
+    }
+  ),
+  simpleTransformation(isMap, "map", function(v) {
+    return __spreadArray([], __read2(v.entries()));
+  }, function(v) {
+    return new Map(v);
+  }),
+  simpleTransformation(function(v) {
+    return isNaNValue(v) || isInfinite(v);
+  }, "number", function(v) {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation(function(v) {
+    return v === 0 && 1 / v === -Infinity;
+  }, "number", function() {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", function(v) {
+    return v.toString();
+  }, function(v) {
+    return new URL(v);
+  })
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var symbolRule = compositeTransformation(function(s, superJson) {
+  if (isSymbol(s)) {
+    var isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+    return isRegistered;
+  }
+  return false;
+}, function(s, superJson) {
+  var identifier = superJson.symbolRegistry.getIdentifier(s);
+  return ["symbol", identifier];
+}, function(v) {
+  return v.description;
+}, function(_, a, superJson) {
+  var value = superJson.symbolRegistry.getValue(a[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+var constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce(function(obj, ctor) {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+var typedArrayRule = compositeTransformation(isTypedArray, function(v) {
+  return ["typed-array", v.constructor.name];
+}, function(v) {
+  return __spreadArray([], __read2(v));
+}, function(v, a) {
+  var ctor = constructorToName[a[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass === null || potentialClass === void 0 ? void 0 : potentialClass.constructor) {
+    var isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+var classRule = compositeTransformation(isInstanceOfRegisteredClass, function(clazz, superJson) {
+  var identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, function(clazz, superJson) {
+  var allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return __assign({}, clazz);
+  }
+  var result = {};
+  allowedProps.forEach(function(prop) {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, function(v, a, superJson) {
+  var clazz = superJson.classRegistry.getValue(a[1]);
+  if (!clazz) {
+    throw new Error("Trying to deserialize unknown class - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564");
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+var customRule = compositeTransformation(function(value, superJson) {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, function(value, superJson) {
+  var transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, function(value, superJson) {
+  var transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, function(v, a, superJson) {
+  var transformer = superJson.customTransformerRegistry.findByName(a[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+var transformValue = function(value, superJson) {
+  var applicableCompositeRule = findArr(compositeRules, function(rule) {
+    return rule.isApplicable(value, superJson);
+  });
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  var applicableSimpleRule = findArr(simpleRules, function(rule) {
+    return rule.isApplicable(value, superJson);
+  });
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+var simpleRulesByAnnotation = {};
+simpleRules.forEach(function(rule) {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+var untransformValue = function(json, type, superJson) {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    var transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/accessDeep.js
+var getNthKey = function(value, n) {
+  var keys = value.keys();
+  while (n > 0) {
+    keys.next();
+    n--;
+  }
+  return keys.next().value;
+};
+function validatePath(path) {
+  if (includes(path, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+var getDeep = function(object, path) {
+  validatePath(path);
+  for (var i = 0; i < path.length; i++) {
+    var key = path[i];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      var row = +key;
+      var type = +path[++i] === 0 ? "key" : "value";
+      var keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+var setDeep = function(object, path, mapper) {
+  validatePath(path);
+  if (path.length === 0) {
+    return mapper(object);
+  }
+  var parent = object;
+  for (var i = 0; i < path.length - 1; i++) {
+    var key = path[i];
+    if (isArray(parent)) {
+      var index = +key;
+      parent = parent[index];
+    } else if (isPlainObject(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      var row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      var isEnd = i === path.length - 2;
+      if (isEnd) {
+        break;
+      }
+      var row = +key;
+      var type = +path[++i] === 0 ? "key" : "value";
+      var keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  var lastKey = path[path.length - 1];
+  if (isArray(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    var oldValue = getNthKey(parent, +lastKey);
+    var newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent["delete"](oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    var row = +path[path.length - 2];
+    var keyToRow = getNthKey(parent, row);
+    var type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        var newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent["delete"](keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/plainer.js
+var __read3 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray2 = function(to, from) {
+  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+    to[j] = from[i];
+  return to;
+};
+function traverse(tree, walker2, origin) {
+  if (origin === void 0) {
+    origin = [];
+  }
+  if (!tree) {
+    return;
+  }
+  if (!isArray(tree)) {
+    forEach(tree, function(subtree, key) {
+      return traverse(subtree, walker2, __spreadArray2(__spreadArray2([], __read3(origin)), __read3(parsePath(key))));
+    });
+    return;
+  }
+  var _a = __read3(tree, 2), nodeValue = _a[0], children2 = _a[1];
+  if (children2) {
+    forEach(children2, function(child, key) {
+      traverse(child, walker2, __spreadArray2(__spreadArray2([], __read3(origin)), __read3(parsePath(key))));
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, superJson) {
+  traverse(annotations, function(type, path) {
+    plain = setDeep(plain, path, function(v) {
+      return untransformValue(v, type, superJson);
+    });
+  });
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations) {
+  function apply(identicalPaths, path) {
+    var object = getDeep(plain, parsePath(path));
+    identicalPaths.map(parsePath).forEach(function(identicalObjectPath) {
+      plain = setDeep(plain, identicalObjectPath, function() {
+        return object;
+      });
+    });
+  }
+  if (isArray(annotations)) {
+    var _a = __read3(annotations, 2), root = _a[0], other = _a[1];
+    root.forEach(function(identicalPath) {
+      plain = setDeep(plain, parsePath(identicalPath), function() {
+        return plain;
+      });
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+var isDeep = function(object, superJson) {
+  return isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
+};
+function addIdentity(object, path, identities) {
+  var existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path);
+  } else {
+    identities.set(object, [path]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites) {
+  var result = {};
+  var rootEqualityPaths = void 0;
+  identitites.forEach(function(paths) {
+    if (paths.length <= 1) {
+      return;
+    }
+    var _a = __read3(paths.map(function(path) {
+      return path.map(String);
+    }).sort(function(a, b) {
+      return a.length - b.length;
+    })), shortestPath = _a[0], identicalPaths = _a.slice(1);
+    if (shortestPath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(shortestPath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+var walker = function(object, identities, superJson, path, objectsInThisPath) {
+  var _a;
+  if (path === void 0) {
+    path = [];
+  }
+  if (objectsInThisPath === void 0) {
+    objectsInThisPath = [];
+  }
+  if (!isPrimitive(object)) {
+    addIdentity(object, path, identities);
+  }
+  if (!isDeep(object, superJson)) {
+    var transformed_1 = transformValue(object, superJson);
+    if (transformed_1) {
+      return {
+        transformedValue: transformed_1.value,
+        annotations: [transformed_1.type]
+      };
+    } else {
+      return {
+        transformedValue: object
+      };
+    }
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  var transformationResult = transformValue(object, superJson);
+  var transformed = (_a = transformationResult === null || transformationResult === void 0 ? void 0 : transformationResult.value) !== null && _a !== void 0 ? _a : object;
+  if (!isPrimitive(object)) {
+    objectsInThisPath = __spreadArray2(__spreadArray2([], __read3(objectsInThisPath)), [object]);
+  }
+  var transformedValue = isArray(transformed) ? [] : {};
+  var innerAnnotations = {};
+  forEach(transformed, function(value, index) {
+    var recursiveResult = walker(value, identities, superJson, __spreadArray2(__spreadArray2([], __read3(path)), [index]), objectsInThisPath);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray(recursiveResult.annotations)) {
+      innerAnnotations[index] = recursiveResult.annotations;
+    } else if (isPlainObject(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, function(tree, key) {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  if (isEmptyObject(innerAnnotations)) {
+    return {
+      transformedValue,
+      annotations: !!transformationResult ? [transformationResult.type] : void 0
+    };
+  } else {
+    return {
+      transformedValue,
+      annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/is-what@4.1.15/node_modules/is-what/dist/index.js
+function getType2(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+function isUndefined2(payload) {
+  return getType2(payload) === "Undefined";
+}
+function isNull2(payload) {
+  return getType2(payload) === "Null";
+}
+function isPlainObject2(payload) {
+  if (getType2(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+function isArray2(payload) {
+  return getType2(payload) === "Array";
+}
+var isNullOrUndefined = isOneOf(isNull2, isUndefined2);
+function isOneOf(a, b, c, d, e) {
+  return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
+}
+
+// ../../node_modules/.pnpm/copy-anything@3.0.5/node_modules/copy-anything/dist/index.js
+function assignProp2(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target, options = {}) {
+  if (isArray2(target)) {
+    return target.map((item) => copy(item, options));
+  }
+  if (!isPlainObject2(target)) {
+    return target;
+  }
+  const props = Object.getOwnPropertyNames(target);
+  const symbols = Object.getOwnPropertySymbols(target);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (isArray2(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target[key];
+    const newVal = copy(val, options);
+    assignProp2(carry, key, newVal, target, options.nonenumerable);
+    return carry;
+  }, {});
+}
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/index.js
+var __assign2 = function() {
+  __assign2 = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign2.apply(this, arguments);
+};
+var __read4 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray3 = function(to, from) {
+  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+    to[j] = from[i];
+  return to;
+};
+var SuperJSON = (
+  /** @class */
+  function() {
+    function SuperJSON2() {
+      this.classRegistry = new ClassRegistry();
+      this.symbolRegistry = new Registry(function(s) {
+        var _a;
+        return (_a = s.description) !== null && _a !== void 0 ? _a : "";
+      });
+      this.customTransformerRegistry = new CustomTransformerRegistry();
+      this.allowedErrorProps = [];
+    }
+    SuperJSON2.prototype.serialize = function(object) {
+      var identities = /* @__PURE__ */ new Map();
+      var output = walker(object, identities, this);
+      var res = {
+        json: output.transformedValue
+      };
+      if (output.annotations) {
+        res.meta = __assign2(__assign2({}, res.meta), { values: output.annotations });
+      }
+      var equalityAnnotations = generateReferentialEqualityAnnotations(identities);
+      if (equalityAnnotations) {
+        res.meta = __assign2(__assign2({}, res.meta), { referentialEqualities: equalityAnnotations });
+      }
+      return res;
+    };
+    SuperJSON2.prototype.deserialize = function(payload) {
+      var json = payload.json, meta = payload.meta;
+      var result = copy(json);
+      if (meta === null || meta === void 0 ? void 0 : meta.values) {
+        result = applyValueAnnotations(result, meta.values, this);
+      }
+      if (meta === null || meta === void 0 ? void 0 : meta.referentialEqualities) {
+        result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+      }
+      return result;
+    };
+    SuperJSON2.prototype.stringify = function(object) {
+      return JSON.stringify(this.serialize(object));
+    };
+    SuperJSON2.prototype.parse = function(string) {
+      return this.deserialize(JSON.parse(string));
+    };
+    SuperJSON2.prototype.registerClass = function(v, options) {
+      this.classRegistry.register(v, options);
+    };
+    SuperJSON2.prototype.registerSymbol = function(v, identifier) {
+      this.symbolRegistry.register(v, identifier);
+    };
+    SuperJSON2.prototype.registerCustom = function(transformer, name) {
+      this.customTransformerRegistry.register(__assign2({ name }, transformer));
+    };
+    SuperJSON2.prototype.allowErrorProps = function() {
+      var _a;
+      var props = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        props[_i] = arguments[_i];
+      }
+      (_a = this.allowedErrorProps).push.apply(_a, __spreadArray3([], __read4(props)));
+    };
+    SuperJSON2.defaultInstance = new SuperJSON2();
+    SuperJSON2.serialize = SuperJSON2.defaultInstance.serialize.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.deserialize = SuperJSON2.defaultInstance.deserialize.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.stringify = SuperJSON2.defaultInstance.stringify.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.parse = SuperJSON2.defaultInstance.parse.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.registerClass = SuperJSON2.defaultInstance.registerClass.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.registerSymbol = SuperJSON2.defaultInstance.registerSymbol.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.registerCustom = SuperJSON2.defaultInstance.registerCustom.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.allowErrorProps = SuperJSON2.defaultInstance.allowErrorProps.bind(SuperJSON2.defaultInstance);
+    return SuperJSON2;
+  }()
+);
+var serialize = SuperJSON.serialize;
+var deserialize = SuperJSON.deserialize;
+var stringify = SuperJSON.stringify;
+var parse = SuperJSON.parse;
+var registerClass = SuperJSON.registerClass;
+var registerCustom = SuperJSON.registerCustom;
+var registerSymbol = SuperJSON.registerSymbol;
+var allowErrorProps = SuperJSON.allowErrorProps;
+
+// src/utils.tsx
+function getQueryStatusLabel(query) {
+  return query.state.fetchStatus === "fetching" ? "fetching" : !query.getObserversCount() ? "inactive" : query.state.fetchStatus === "paused" ? "paused" : query.isStale() ? "stale" : "fresh";
+}
+function getSidedProp(prop, side) {
+  return `${prop}${side.charAt(0).toUpperCase() + side.slice(1)}`;
+}
+function getQueryStatusColor({
+  queryState,
+  observerCount,
+  isStale
+}) {
+  return queryState.fetchStatus === "fetching" ? "blue" : !observerCount ? "gray" : queryState.fetchStatus === "paused" ? "purple" : isStale ? "yellow" : "green";
+}
+function getMutationStatusColor({
+  status,
+  isPaused
+}) {
+  return isPaused ? "purple" : status === "error" ? "red" : status === "pending" ? "yellow" : status === "success" ? "green" : "gray";
+}
+function getQueryStatusColorByLabel(label) {
+  return label === "fresh" ? "green" : label === "stale" ? "yellow" : label === "paused" ? "purple" : label === "inactive" ? "gray" : "blue";
+}
+var displayValue = (value, beautify = false) => {
+  const { json } = serialize(value);
+  return JSON.stringify(json, null, beautify ? 2 : void 0);
+};
+var getStatusRank = (q) => q.state.fetchStatus !== "idle" ? 0 : !q.getObserversCount() ? 3 : q.isStale() ? 2 : 1;
+var queryHashSort = (a, b) => a.queryHash.localeCompare(b.queryHash);
+var dateSort = (a, b) => a.state.dataUpdatedAt < b.state.dataUpdatedAt ? 1 : -1;
+var statusAndDateSort = (a, b) => {
+  if (getStatusRank(a) === getStatusRank(b)) {
+    return dateSort(a, b);
+  }
+  return getStatusRank(a) > getStatusRank(b) ? 1 : -1;
+};
+var sortFns = {
+  status: statusAndDateSort,
+  "query hash": queryHashSort,
+  "last updated": dateSort
+};
+var getMutationStatusRank = (m) => m.state.isPaused ? 0 : m.state.status === "error" ? 2 : m.state.status === "pending" ? 1 : 3;
+var mutationDateSort = (a, b) => a.state.submittedAt < b.state.submittedAt ? 1 : -1;
+var mutationStatusSort = (a, b) => {
+  if (getMutationStatusRank(a) === getMutationStatusRank(b)) {
+    return mutationDateSort(a, b);
+  }
+  return getMutationStatusRank(a) > getMutationStatusRank(b) ? 1 : -1;
+};
+var mutationSortFns = {
+  status: mutationStatusSort,
+  "last updated": mutationDateSort
+};
+var convertRemToPixels = (rem) => {
+  return rem * parseFloat(getComputedStyle(document.documentElement).fontSize);
+};
+var getPreferredColorScheme = () => {
+  const [colorScheme, setColorScheme] = createSignal("dark");
+  onMount(() => {
+    const query = window.matchMedia("(prefers-color-scheme: dark)");
+    setColorScheme(query.matches ? "dark" : "light");
+    const listener = (e) => {
+      setColorScheme(e.matches ? "dark" : "light");
+    };
+    query.addEventListener("change", listener);
+    onCleanup(() => query.removeEventListener("change", listener));
+  });
+  return colorScheme;
+};
+var updateNestedDataByPath = (oldData, updatePath, value) => {
+  if (updatePath.length === 0) {
+    return value;
+  }
+  if (oldData instanceof Map) {
+    const newData = new Map(oldData);
+    if (updatePath.length === 1) {
+      newData.set(updatePath[0], value);
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    newData.set(head, updateNestedDataByPath(newData.get(head), tail, value));
+    return newData;
+  }
+  if (oldData instanceof Set) {
+    const setAsArray = updateNestedDataByPath(
+      Array.from(oldData),
+      updatePath,
+      value
+    );
+    return new Set(setAsArray);
+  }
+  if (Array.isArray(oldData)) {
+    const newData = [...oldData];
+    if (updatePath.length === 1) {
+      newData[updatePath[0]] = value;
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    newData[head] = updateNestedDataByPath(newData[head], tail, value);
+    return newData;
+  }
+  if (oldData instanceof Object) {
+    const newData = { ...oldData };
+    if (updatePath.length === 1) {
+      newData[updatePath[0]] = value;
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    newData[head] = updateNestedDataByPath(newData[head], tail, value);
+    return newData;
+  }
+  return oldData;
+};
+var deleteNestedDataByPath = (oldData, deletePath) => {
+  if (oldData instanceof Map) {
+    const newData = new Map(oldData);
+    if (deletePath.length === 1) {
+      newData.delete(deletePath[0]);
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    newData.set(head, deleteNestedDataByPath(newData.get(head), tail));
+    return newData;
+  }
+  if (oldData instanceof Set) {
+    const setAsArray = deleteNestedDataByPath(Array.from(oldData), deletePath);
+    return new Set(setAsArray);
+  }
+  if (Array.isArray(oldData)) {
+    const newData = [...oldData];
+    if (deletePath.length === 1) {
+      return newData.filter((_, idx) => idx.toString() !== deletePath[0]);
+    }
+    const [head, ...tail] = deletePath;
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  if (oldData instanceof Object) {
+    const newData = { ...oldData };
+    if (deletePath.length === 1) {
+      delete newData[deletePath[0]];
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  return oldData;
+};
+var setupStyleSheet = (nonce) => {
+  if (!nonce)
+    return;
+  const styleExists = document.querySelector("#_goober");
+  if (styleExists)
+    return;
+  const styleTag = document.createElement("style");
+  const textNode = document.createTextNode("");
+  styleTag.appendChild(textNode);
+  styleTag.id = "_goober";
+  styleTag.setAttribute("nonce", nonce);
+  document.head.appendChild(styleTag);
+};
+
+export {
+  $PROXY,
+  $TRACK,
+  createRoot,
+  createSignal,
+  createComputed,
+  createRenderEffect,
+  createEffect,
+  createMemo,
+  batch,
+  untrack,
+  on,
+  onMount,
+  onCleanup,
+  getListener,
+  getOwner,
+  useTransition,
+  createContext,
+  useContext,
+  children,
+  createComponent,
+  mergeProps,
+  splitProps,
+  lazy,
+  createUniqueId,
+  For,
+  Index,
+  Show,
+  Switch,
+  Match,
+  DEV,
+  render,
+  template,
+  delegateEvents,
+  setAttribute,
+  spread,
+  use,
+  isServer,
+  Portal,
+  Dynamic,
+  stringify,
+  getQueryStatusLabel,
+  getSidedProp,
+  getQueryStatusColor,
+  getMutationStatusColor,
+  getQueryStatusColorByLabel,
+  displayValue,
+  sortFns,
+  mutationSortFns,
+  convertRemToPixels,
+  getPreferredColorScheme,
+  updateNestedDataByPath,
+  deleteNestedDataByPath,
+  setupStyleSheet
+};