@tanstack/query-devtools 5.101.3 → 5.102.0

package/build/utils-CESniQp_.js

@@ -0,0 +1,2613 @@
+//#region ../../node_modules/.pnpm/solid-js@1.9.12/node_modules/solid-js/dist/solid.js
+const sharedConfig = {
+	context: void 0,
+	registry: void 0,
+	effects: void 0,
+	done: false,
+	getContextId() {
+		return getContextId(this.context.count);
+	},
+	getNextContextId() {
+		return getContextId(this.context.count++);
+	}
+};
+function getContextId(count) {
+	const num = String(count), len = num.length - 1;
+	return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
+}
+function setHydrateContext(context) {
+	sharedConfig.context = context;
+}
+const equalFn = (a, b) => a === b;
+const $PROXY = Symbol("solid-proxy");
+const SUPPORTS_PROXY = typeof Proxy === "function";
+const $TRACK = Symbol("solid-track");
+const signalOptions = { equals: equalFn };
+let runEffects = runQueue;
+const STALE = 1;
+const PENDING = 2;
+const UNOWNED = {
+	owned: null,
+	cleanups: null,
+	context: null,
+	owner: null
+};
+const NO_INIT = {};
+var Owner = null;
+let Transition = null;
+let Listener = null;
+let Updates = null;
+let Effects = null;
+let ExecCount = 0;
+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 = (value) => {
+		if (typeof value === "function") {
+			if (Transition && Transition.running && Transition.sources.has(s)) value = value(s.tValue);
+			else value = value(s.value);
+		}
+		return writeSignal(s, value);
+	};
+	return [readSignal.bind(s), setter];
+}
+function createComputed(fn, value, options) {
+	updateComputation(createComputation(fn, value, true, STALE));
+}
+function createRenderEffect(fn, value, options) {
+	updateComputation(createComputation(fn, value, false, STALE));
+}
+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;
+	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 (typeof pFetcher === "function") {
+		source = pSource;
+		fetcher = pFetcher;
+		options = pOptions || {};
+	} else {
+		source = true;
+		fetcher = pSource;
+		options = pFetcher || {};
+	}
+	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.getNextContextId();
+		if (options.ssrLoadFrom === "initial") initP = options.initialValue;
+		else if (sharedConfig.load && sharedConfig.has(id)) initP = sharedConfig.load(id);
+	}
+	function loadEnd(p, v, error, 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, error);
+				}, false);
+			} else completeLoad(v, error);
+		}
+		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);
+		let error;
+		const p = initP !== NO_INIT ? initP : untrack(() => {
+			try {
+				return fetcher(lookup, {
+					value: value(),
+					refetching
+				});
+			} catch (fetcherError) {
+				error = fetcherError;
+			}
+		});
+		if (error !== void 0) {
+			loadEnd(pr, void 0, castError(error), lookup);
+			return;
+		} else if (!isPromise(p)) {
+			loadEnd(pr, p, void 0, lookup);
+			return p;
+		}
+		pr = p;
+		if ("v" in p) {
+			if (p.s === 1) loadEnd(pr, p.v, void 0, lookup);
+			else loadEnd(pr, void 0, castError(p.v), lookup);
+			return 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();
+		} }
+	});
+	let owner = Owner;
+	if (dynamic) createComputed(() => (owner = Owner, load(false)));
+	else load(false);
+	return [read, {
+		refetch: (info) => runWithOwner(owner, () => load(info)),
+		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 isArray = Array.isArray(deps);
+	let prevInput;
+	let defer = options && options.defer;
+	return (prevValue) => {
+		let input;
+		if (isArray) {
+			input = Array(deps.length);
+			for (let i = 0; i < deps.length; i++) input[i] = deps[i]();
+		} else input = deps();
+		if (defer) {
+			defer = false;
+			return prevValue;
+		}
+		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 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 (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;
+	});
+}
+const [transPending, setTransPending] = /*@__PURE__*/ createSignal(false);
+function useTransition() {
+	return [transPending, startTransition];
+}
+function createContext(defaultValue, options) {
+	const id = Symbol("context");
+	return {
+		id,
+		Provider: createProvider(id),
+		defaultValue
+	};
+}
+function useContext(context) {
+	let value;
+	return Owner && Owner.context && (value = Owner.context[context.id]) !== void 0 ? value : context.defaultValue;
+}
+function children(fn) {
+	const children = createMemo(fn);
+	const memo = createMemo(() => resolveChildren(children()));
+	memo.toArray = () => {
+		const c = memo();
+		return Array.isArray(c) ? c : c != null ? [c] : [];
+	};
+	return memo;
+}
+let 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 = [];
+				throw new Error();
+			}
+		}, false);
+	}
+	return value;
+}
+function updateComputation(node) {
+	if (!node.fn) return;
+	cleanNode(node);
+	const time = ExecCount;
+	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);
+	});
+}
+function runComputation(node, value, time) {
+	let nextValue;
+	const owner = Owner, listener = Listener;
+	Listener = Owner = node;
+	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);
+	} finally {
+		Listener = listener;
+		Owner = owner;
+	}
+	if (!node.updatedAt || node.updatedAt <= time) {
+		if (node.updatedAt != null && "observers" in node) writeSignal(node, nextValue, true);
+		else if (Transition && Transition.running && node.pure) {
+			if (!Transition.sources.has(node)) node.value = nextValue;
+			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);
+	}
+	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) {
+		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 e of Effects) {
+				"tState" in e && (e.state = e.tState);
+				delete e.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 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;
+		}
+		setHydrateContext();
+	}
+	if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
+		queue = [...sharedConfig.effects, ...queue];
+		userLength += sharedConfig.effects.length;
+		delete sharedConfig.effects;
+	}
+	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 (node.tOwned) {
+		for (i = node.tOwned.length - 1; i >= 0; i--) cleanNode(node.tOwned[i]);
+		delete node.tOwned;
+	}
+	if (Transition && Transition.running && node.pure) 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 handleError(err, owner = Owner) {
+	throw castError(err);
+}
+function resolveChildren(children) {
+	if (typeof children === "function" && !children.length) return resolveChildren(children());
+	if (Array.isArray(children)) {
+		const results = [];
+		for (let i = 0; i < children.length; i++) {
+			const result = resolveChildren(children[i]);
+			Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+		}
+		return results;
+	}
+	return children;
+}
+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;
+	};
+}
+const 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() || [], newLen = newItems.length, i, j;
+		newItems[$TRACK];
+		return untrack(() => {
+			let 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() || [], newLen = newItems.length;
+		newItems[$TRACK];
+		return untrack(() => {
+			if (newLen === 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 < newLen; 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 = newLen;
+			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);
+		}
+	};
+}
+function createComponent(Comp, props) {
+	return untrack(() => Comp(props || {}));
+}
+function trueFn() {
+	return true;
+}
+const 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 (SUPPORTS_PROXY && 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 sourcesMap = {};
+	const defined = Object.create(null);
+	for (let i = sources.length - 1; i >= 0; i--) {
+		const source = sources[i];
+		if (!source) continue;
+		const sourceKeys = Object.getOwnPropertyNames(source);
+		for (let i = sourceKeys.length - 1; i >= 0; i--) {
+			const key = sourceKeys[i];
+			if (key === "__proto__" || key === "constructor") continue;
+			const desc = Object.getOwnPropertyDescriptor(source, key);
+			if (!defined[key]) defined[key] = desc.get ? {
+				enumerable: true,
+				configurable: true,
+				get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
+			} : desc.value !== void 0 ? desc : void 0;
+			else {
+				const sources = sourcesMap[key];
+				if (sources) {
+					if (desc.get) sources.push(desc.get.bind(source));
+					else if (desc.value !== void 0) sources.push(() => desc.value);
+				}
+			}
+		}
+	}
+	const target = {};
+	const definedKeys = Object.keys(defined);
+	for (let i = definedKeys.length - 1; i >= 0; i--) {
+		const key = definedKeys[i], desc = defined[key];
+		if (desc && desc.get) Object.defineProperty(target, key, desc);
+		else target[key] = desc ? desc.value : void 0;
+	}
+	return target;
+}
+function splitProps(props, ...keys) {
+	const len = keys.length;
+	if (SUPPORTS_PROXY && $PROXY in props) {
+		const blocked = len > 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.includes(property) ? void 0 : props[property];
+			},
+			has(property) {
+				return blocked.includes(property) ? false : property in props;
+			},
+			keys() {
+				return Object.keys(props).filter((k) => !blocked.includes(k));
+			}
+		}, propTraps));
+		return res;
+	}
+	const objects = [];
+	for (let i = 0; i <= len; i++) objects[i] = {};
+	for (const propName of Object.getOwnPropertyNames(props)) {
+		let keyIndex = len;
+		for (let i = 0; i < keys.length; i++) if (keys[i].includes(propName)) {
+			keyIndex = i;
+			break;
+		}
+		const desc = Object.getOwnPropertyDescriptor(props, propName);
+		!desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable ? objects[keyIndex][propName] = desc.value : Object.defineProperty(objects[keyIndex], propName, desc);
+	}
+	return objects;
+}
+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) => {
+				!sharedConfig.done && 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 (!ctx || sharedConfig.done) 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;
+}
+let counter = 0;
+function createUniqueId() {
+	return sharedConfig.context ? sharedConfig.getNextContextId() : `cl-${counter++}`;
+}
+const 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 conditionValue = createMemo(() => props.when, void 0, void 0);
+	const condition = keyed ? conditionValue : createMemo(conditionValue, void 0, { equals: (a, b) => !a === !b });
+	return createMemo(() => {
+		const c = condition();
+		if (c) {
+			const child = props.children;
+			return typeof child === "function" && child.length > 0 ? untrack(() => child(keyed ? c : () => {
+				if (!untrack(condition)) throw narrowedError("Show");
+				return conditionValue();
+			})) : child;
+		}
+		return props.fallback;
+	}, void 0, void 0);
+}
+function Switch(props) {
+	const chs = children(() => props.children);
+	const switchFunc = createMemo(() => {
+		const ch = chs();
+		const mps = Array.isArray(ch) ? ch : [ch];
+		let func = () => void 0;
+		for (let i = 0; i < mps.length; i++) {
+			const index = i;
+			const mp = mps[i];
+			const prevFunc = func;
+			const conditionValue = createMemo(() => prevFunc() ? void 0 : mp.when, void 0, void 0);
+			const condition = mp.keyed ? conditionValue : createMemo(conditionValue, void 0, { equals: (a, b) => !a === !b });
+			func = () => prevFunc() || (condition() ? [
+				index,
+				conditionValue,
+				mp
+			] : void 0);
+		}
+		return func;
+	});
+	return createMemo(() => {
+		const sel = switchFunc()();
+		if (!sel) return props.fallback;
+		const [index, conditionValue, mp] = sel;
+		const child = mp.children;
+		return typeof child === "function" && child.length > 0 ? untrack(() => child(mp.keyed ? conditionValue() : () => {
+			if (untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
+			return conditionValue();
+		})) : child;
+	}, void 0, void 0);
+}
+function Match(props) {
+	return props;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/solid-js@1.9.12/node_modules/solid-js/web/dist/web.js
+const Properties = /*#__PURE__*/ new Set([
+	"className",
+	"value",
+	"readOnly",
+	"noValidate",
+	"formNoValidate",
+	"isMap",
+	"noModule",
+	"playsInline",
+	"adAuctionHeaders",
+	"allowFullscreen",
+	"browsingTopics",
+	"defaultChecked",
+	"defaultMuted",
+	"defaultSelected",
+	"disablePictureInPicture",
+	"disableRemotePlayback",
+	"preservesPitch",
+	"shadowRootClonable",
+	"shadowRootCustomElementRegistry",
+	"shadowRootDelegatesFocus",
+	"shadowRootSerializable",
+	"sharedStorageWritable",
+	...[
+		"allowfullscreen",
+		"async",
+		"alpha",
+		"autofocus",
+		"autoplay",
+		"checked",
+		"controls",
+		"default",
+		"disabled",
+		"formnovalidate",
+		"hidden",
+		"indeterminate",
+		"inert",
+		"ismap",
+		"loop",
+		"multiple",
+		"muted",
+		"nomodule",
+		"novalidate",
+		"open",
+		"playsinline",
+		"readonly",
+		"required",
+		"reversed",
+		"seamless",
+		"selected",
+		"adauctionheaders",
+		"browsingtopics",
+		"credentialless",
+		"defaultchecked",
+		"defaultmuted",
+		"defaultselected",
+		"defer",
+		"disablepictureinpicture",
+		"disableremoteplayback",
+		"preservespitch",
+		"shadowrootclonable",
+		"shadowrootcustomelementregistry",
+		"shadowrootdelegatesfocus",
+		"shadowrootserializable",
+		"sharedstoragewritable"
+	]
+]);
+const ChildProperties = /*#__PURE__*/ new Set([
+	"innerHTML",
+	"textContent",
+	"innerText",
+	"children"
+]);
+const Aliases = /*#__PURE__*/ Object.assign(Object.create(null), {
+	className: "class",
+	htmlFor: "for"
+});
+const PropAliases = /*#__PURE__*/ Object.assign(Object.create(null), {
+	class: "className",
+	novalidate: {
+		$: "noValidate",
+		FORM: 1
+	},
+	formnovalidate: {
+		$: "formNoValidate",
+		BUTTON: 1,
+		INPUT: 1
+	},
+	ismap: {
+		$: "isMap",
+		IMG: 1
+	},
+	nomodule: {
+		$: "noModule",
+		SCRIPT: 1
+	},
+	playsinline: {
+		$: "playsInline",
+		VIDEO: 1
+	},
+	readonly: {
+		$: "readOnly",
+		INPUT: 1,
+		TEXTAREA: 1
+	},
+	adauctionheaders: {
+		$: "adAuctionHeaders",
+		IFRAME: 1
+	},
+	allowfullscreen: {
+		$: "allowFullscreen",
+		IFRAME: 1
+	},
+	browsingtopics: {
+		$: "browsingTopics",
+		IMG: 1
+	},
+	defaultchecked: {
+		$: "defaultChecked",
+		INPUT: 1
+	},
+	defaultmuted: {
+		$: "defaultMuted",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	defaultselected: {
+		$: "defaultSelected",
+		OPTION: 1
+	},
+	disablepictureinpicture: {
+		$: "disablePictureInPicture",
+		VIDEO: 1
+	},
+	disableremoteplayback: {
+		$: "disableRemotePlayback",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	preservespitch: {
+		$: "preservesPitch",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	shadowrootclonable: {
+		$: "shadowRootClonable",
+		TEMPLATE: 1
+	},
+	shadowrootdelegatesfocus: {
+		$: "shadowRootDelegatesFocus",
+		TEMPLATE: 1
+	},
+	shadowrootserializable: {
+		$: "shadowRootSerializable",
+		TEMPLATE: 1
+	},
+	sharedstoragewritable: {
+		$: "sharedStorageWritable",
+		IFRAME: 1,
+		IMG: 1
+	}
+});
+function getPropAlias(prop, tagName) {
+	const a = PropAliases[prop];
+	return typeof a === "object" ? a[tagName] ? a["$"] : void 0 : a;
+}
+const DelegatedEvents = /*#__PURE__*/ new Set([
+	"beforeinput",
+	"click",
+	"dblclick",
+	"contextmenu",
+	"focusin",
+	"focusout",
+	"input",
+	"keydown",
+	"keyup",
+	"mousedown",
+	"mousemove",
+	"mouseout",
+	"mouseover",
+	"mouseup",
+	"pointerdown",
+	"pointermove",
+	"pointerout",
+	"pointerover",
+	"pointerup",
+	"touchend",
+	"touchmove",
+	"touchstart"
+]);
+const 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",
+	"feDropShadow",
+	"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"
+]);
+const SVGNamespace = {
+	xlink: "http://www.w3.org/1999/xlink",
+	xml: "http://www.w3.org/XML/1998/namespace"
+};
+const memo = (fn) => createMemo(() => fn());
+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();
+		}
+	}
+}
+const $$EVENTS = "_$DX_DELEGATE";
+function render(code, element, init, options = {}) {
+	let disposer;
+	createRoot((dispose) => {
+		disposer = dispose;
+		element === document ? code() : insert(element, code(), element.firstChild ? null : void 0, init);
+	}, options.owner);
+	return () => {
+		disposer();
+		element.textContent = "";
+	};
+}
+function template(html, isImportNode, isSVG, isMathML) {
+	let node;
+	const create = () => {
+		const t = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "template") : document.createElement("template");
+		t.innerHTML = html;
+		return isSVG ? t.content.firstChild.firstChild : isMathML ? t.firstChild : t.content.firstChild;
+	};
+	const fn = isImportNode ? () => untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+	fn.cloneNode = fn;
+	return fn;
+}
+function delegateEvents(eventNames, document = window.document) {
+	const e = document[$$EVENTS] || (document[$$EVENTS] = /* @__PURE__ */ new Set());
+	for (let i = 0, l = eventNames.length; i < l; i++) {
+		const name = eventNames[i];
+		if (!e.has(name)) {
+			e.add(name);
+			document.addEventListener(name, eventHandler);
+		}
+	}
+}
+function clearDelegatedEvents(document = window.document) {
+	if (document[$$EVENTS]) {
+		for (let name of document[$$EVENTS].keys()) document.removeEventListener(name, eventHandler);
+		delete document[$$EVENTS];
+	}
+}
+function setAttribute(node, name, value) {
+	if (isHydrating(node)) return;
+	if (value == null) node.removeAttribute(name);
+	else node.setAttribute(name, value);
+}
+function setAttributeNS(node, namespace, name, value) {
+	if (isHydrating(node)) return;
+	if (value == null) node.removeAttributeNS(namespace, name);
+	else node.setAttributeNS(namespace, name, value);
+}
+function setBoolAttribute(node, name, value) {
+	if (isHydrating(node)) return;
+	value ? node.setAttribute(name, "") : node.removeAttribute(name);
+}
+function className(node, value) {
+	if (isHydrating(node)) 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, typeof handler !== "function" && 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] ?? 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 setStyleProperty(node, name, value) {
+	value != null ? node.style.setProperty(name, value) : node.style.removeProperty(name);
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+	const prevProps = {};
+	if (!skipChildren) createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+	createRenderEffect(() => typeof props.ref === "function" && use(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$1(node, prop, null, prevProps[prop], isSVG, skipRef, props);
+	}
+	for (const prop in props) {
+		if (prop === "children") {
+			if (!skipChildren) insertExpression(node, props.children);
+			continue;
+		}
+		const value = props[prop];
+		prevProps[prop] = assignProp$1(node, prop, value, prevProps[prop], isSVG, skipRef, props);
+	}
+}
+function getNextElement(template) {
+	let node, key;
+	if (!isHydrating() || !(node = sharedConfig.registry.get(key = getHydrationKey()))) return template();
+	if (sharedConfig.completed) sharedConfig.completed.add(node);
+	sharedConfig.registry.delete(key);
+	return node;
+}
+function isHydrating(node) {
+	return !!sharedConfig.context && !sharedConfig.done && (!node || node.isConnected);
+}
+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$1(node, prop, value, prev, isSVG, skipRef, props) {
+	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, typeof prev !== "function" && prev);
+		value && node.addEventListener(e, value, typeof value !== "function" && 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 (prop.slice(0, 5) === "bool:") setBoolAttribute(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("-") || "is" in props)) {
+		if (forceProp) {
+			prop = prop.slice(5);
+			isProp = true;
+		} else if (isHydrating(node)) 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) {
+	if (sharedConfig.registry && sharedConfig.events) {
+		if (sharedConfig.events.find(([el, ev]) => ev === e)) return;
+	}
+	let node = e.target;
+	const key = `$$${e.type}`;
+	const oriTarget = e.target;
+	const oriCurrentTarget = e.currentTarget;
+	const retarget = (value) => Object.defineProperty(e, "target", {
+		configurable: true,
+		value
+	});
+	const handleNode = () => {
+		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.host && typeof node.host !== "string" && !node.host._$host && node.contains(e.target) && retarget(node.host);
+		return true;
+	};
+	const walkUpTree = () => {
+		while (handleNode() && (node = node._$host || node.parentNode || node.host));
+	};
+	Object.defineProperty(e, "currentTarget", {
+		configurable: true,
+		get() {
+			return node || document;
+		}
+	});
+	if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = _$HY.done = true;
+	if (e.composedPath) {
+		const path = e.composedPath();
+		retarget(path[0]);
+		for (let i = 0; i < path.length - 2; i++) {
+			node = path[i];
+			if (!handleNode()) break;
+			if (node._$host) {
+				node = node._$host;
+				walkUpTree();
+				break;
+			}
+			if (node.parentNode === oriCurrentTarget) break;
+		}
+	} else walkUpTree();
+	retarget(oriTarget);
+}
+function insertExpression(parent, value, current, marker, unwrapArray) {
+	const hydrating = isHydrating(parent);
+	if (hydrating) {
+		!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 (hydrating) return current;
+		if (t === "number") {
+			value = value.toString();
+			if (value === current) return current;
+		}
+		if (multi) {
+			let node = current[0];
+			if (node && node.nodeType === 3) node.data !== value && (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 (hydrating) 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 (hydrating) {
+			if (!array.length) return current;
+			if (marker === void 0) return current = [...parent.childNodes];
+			let node = array[0];
+			if (node.parentNode !== parent) return current;
+			const 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 (hydrating && 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;
+	}
+	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[normalized.length], 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() {
+	return sharedConfig.getNextContextId();
+}
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function createElement(tagName, isSVG = false, is = void 0) {
+	return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName, { is });
+}
+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((dispose) => insert(el, () => !clean() ? content() : dispose(), 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 createDynamic(component, props) {
+	const cached = createMemo(component);
+	return createMemo(() => {
+		const component = cached();
+		switch (typeof component) {
+			case "function": return untrack(() => component(props));
+			case "string":
+				const isSvg = SVGElements.has(component);
+				const el = sharedConfig.context ? getNextElement() : createElement(component, isSvg, untrack(() => props.is));
+				spread(el, props, isSvg);
+				return el;
+		}
+	});
+}
+function Dynamic(props) {
+	const [, others] = splitProps(props, ["component"]);
+	return createDynamic(() => props.component, others);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/double-indexed-kv.js
+var DoubleIndexedKV = class {
+	constructor() {
+		this.keyToValue = /* @__PURE__ */ new Map();
+		this.valueToKey = /* @__PURE__ */ new Map();
+	}
+	set(key, value) {
+		this.keyToValue.set(key, value);
+		this.valueToKey.set(value, key);
+	}
+	getByKey(key) {
+		return this.keyToValue.get(key);
+	}
+	getByValue(value) {
+		return this.valueToKey.get(value);
+	}
+	clear() {
+		this.keyToValue.clear();
+		this.valueToKey.clear();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/registry.js
+var Registry = class {
+	constructor(generateIdentifier) {
+		this.generateIdentifier = generateIdentifier;
+		this.kv = new DoubleIndexedKV();
+	}
+	register(value, identifier) {
+		if (this.kv.getByValue(value)) return;
+		if (!identifier) identifier = this.generateIdentifier(value);
+		this.kv.set(identifier, value);
+	}
+	clear() {
+		this.kv.clear();
+	}
+	getIdentifier(value) {
+		return this.kv.getByValue(value);
+	}
+	getValue(identifier) {
+		return this.kv.getByKey(identifier);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/class-registry.js
+var ClassRegistry = class extends Registry {
+	constructor() {
+		super((c) => c.name);
+		this.classToAllowedProps = /* @__PURE__ */ new Map();
+	}
+	register(value, options) {
+		if (typeof options === "object") {
+			if (options.allowProps) this.classToAllowedProps.set(value, options.allowProps);
+			super.register(value, options.identifier);
+		} else super.register(value, options);
+	}
+	getAllowedProps(value) {
+		return this.classToAllowedProps.get(value);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/util.js
+function valuesOfObj(record) {
+	if ("values" in Object) return Object.values(record);
+	const values = [];
+	for (const key in record) if (record.hasOwnProperty(key)) values.push(record[key]);
+	return values;
+}
+function find(record, predicate) {
+	const values = valuesOfObj(record);
+	if ("find" in values) return values.find(predicate);
+	const valuesNotNever = values;
+	for (let i = 0; i < valuesNotNever.length; i++) {
+		const value = valuesNotNever[i];
+		if (predicate(value)) return value;
+	}
+}
+function forEach(record, run) {
+	Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+function includes(arr, value) {
+	return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+	for (let i = 0; i < record.length; i++) {
+		const value = record[i];
+		if (predicate(value)) return value;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/custom-transformer-registry.js
+var CustomTransformerRegistry = class {
+	constructor() {
+		this.transfomers = {};
+	}
+	register(transformer) {
+		this.transfomers[transformer.name] = transformer;
+	}
+	findApplicable(v) {
+		return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+	}
+	findByName(name) {
+		return this.transfomers[name];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/is.js
+const getType$1 = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+const isUndefined = (payload) => typeof payload === "undefined";
+const isNull = (payload) => payload === null;
+const isPlainObject$1 = (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;
+};
+const isEmptyObject = (payload) => isPlainObject$1(payload) && Object.keys(payload).length === 0;
+const isArray$1 = (payload) => Array.isArray(payload);
+const isString = (payload) => typeof payload === "string";
+const isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+const isBoolean = (payload) => typeof payload === "boolean";
+const isRegExp = (payload) => payload instanceof RegExp;
+const isMap = (payload) => payload instanceof Map;
+const isSet = (payload) => payload instanceof Set;
+const isSymbol = (payload) => getType$1(payload) === "Symbol";
+const isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+const isError = (payload) => payload instanceof Error;
+const isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+const isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+const isBigint = (payload) => typeof payload === "bigint";
+const isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+const isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+const isURL = (payload) => payload instanceof URL;
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/pathstringifier.js
+const escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+const stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+const parsePath = (string, legacyPaths) => {
+	const result = [];
+	let segment = "";
+	for (let i = 0; i < string.length; i++) {
+		let char = string.charAt(i);
+		if (!legacyPaths && char === "\\") {
+			const escaped = string.charAt(i + 1);
+			if (escaped === "\\") {
+				segment += "\\";
+				i++;
+				continue;
+			} else if (escaped !== ".") throw Error("invalid path");
+		}
+		if (char === "\\" && string.charAt(i + 1) === ".") {
+			segment += ".";
+			i++;
+			continue;
+		}
+		if (char === ".") {
+			result.push(segment);
+			segment = "";
+			continue;
+		}
+		segment += char;
+	}
+	const lastSegment = segment;
+	result.push(lastSegment);
+	return result;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/transformer.js
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+	return {
+		isApplicable,
+		annotation,
+		transform,
+		untransform
+	};
+}
+const simpleRules = [
+	simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
+	simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
+		if (typeof BigInt !== "undefined") return BigInt(v);
+		console.error("Please add a BigInt polyfill.");
+		return v;
+	}),
+	simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
+	simpleTransformation(isError, "Error", (v, superJson) => {
+		const baseError = {
+			name: v.name,
+			message: v.message
+		};
+		if ("cause" in v) baseError.cause = v.cause;
+		superJson.allowedErrorProps.forEach((prop) => {
+			baseError[prop] = v[prop];
+		});
+		return baseError;
+	}, (v, superJson) => {
+		const e = new Error(v.message, { cause: v.cause });
+		e.name = v.name;
+		e.stack = v.stack;
+		superJson.allowedErrorProps.forEach((prop) => {
+			e[prop] = v[prop];
+		});
+		return e;
+	}),
+	simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
+		const body = regex.slice(1, regex.lastIndexOf("/"));
+		const flags = regex.slice(regex.lastIndexOf("/") + 1);
+		return new RegExp(body, flags);
+	}),
+	simpleTransformation(isSet, "set", (v) => [...v.values()], (v) => new Set(v)),
+	simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
+	simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
+		if (isNaNValue(v)) return "NaN";
+		if (v > 0) return "Infinity";
+		else return "-Infinity";
+	}, Number),
+	simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
+		return "-0";
+	}, Number),
+	simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+	return {
+		isApplicable,
+		annotation,
+		transform,
+		untransform
+	};
+}
+const symbolRule = compositeTransformation((s, superJson) => {
+	if (isSymbol(s)) return !!superJson.symbolRegistry.getIdentifier(s);
+	return false;
+}, (s, superJson) => {
+	return ["symbol", superJson.symbolRegistry.getIdentifier(s)];
+}, (v) => v.description, (_, a, superJson) => {
+	const value = superJson.symbolRegistry.getValue(a[1]);
+	if (!value) throw new Error("Trying to deserialize unknown symbol");
+	return value;
+});
+const constructorToName = [
+	Int8Array,
+	Uint8Array,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	Uint8ClampedArray
+].reduce((obj, ctor) => {
+	obj[ctor.name] = ctor;
+	return obj;
+}, {});
+const typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
+	const 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?.constructor) return !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+	return false;
+}
+const classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+	return ["class", superJson.classRegistry.getIdentifier(clazz.constructor)];
+}, (clazz, superJson) => {
+	const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+	if (!allowedProps) return { ...clazz };
+	const result = {};
+	allowedProps.forEach((prop) => {
+		result[prop] = clazz[prop];
+	});
+	return result;
+}, (v, a, superJson) => {
+	const clazz = superJson.classRegistry.getValue(a[1]);
+	if (!clazz) throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+	return Object.assign(Object.create(clazz.prototype), v);
+});
+const customRule = compositeTransformation((value, superJson) => {
+	return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+	return ["custom", superJson.customTransformerRegistry.findApplicable(value).name];
+}, (value, superJson) => {
+	return superJson.customTransformerRegistry.findApplicable(value).serialize(value);
+}, (v, a, superJson) => {
+	const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+	if (!transformer) throw new Error("Trying to deserialize unknown custom value");
+	return transformer.deserialize(v);
+});
+const compositeRules = [
+	classRule,
+	symbolRule,
+	customRule,
+	typedArrayRule
+];
+const transformValue = (value, superJson) => {
+	const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
+	if (applicableCompositeRule) return {
+		value: applicableCompositeRule.transform(value, superJson),
+		type: applicableCompositeRule.annotation(value, superJson)
+	};
+	const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
+	if (applicableSimpleRule) return {
+		value: applicableSimpleRule.transform(value, superJson),
+		type: applicableSimpleRule.annotation
+	};
+};
+const simpleRulesByAnnotation = {};
+simpleRules.forEach((rule) => {
+	simpleRulesByAnnotation[rule.annotation] = rule;
+});
+const untransformValue = (json, type, superJson) => {
+	if (isArray$1(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 {
+		const transformation = simpleRulesByAnnotation[type];
+		if (!transformation) throw new Error("Unknown transformation: " + type);
+		return transformation.untransform(json, superJson);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/accessDeep.js
+const getNthKey = (value, n) => {
+	if (n > value.size) throw new Error("index out of bounds");
+	const 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");
+}
+const getDeep = (object, path) => {
+	validatePath(path);
+	for (let i = 0; i < path.length; i++) {
+		const key = path[i];
+		if (isSet(object)) object = getNthKey(object, +key);
+		else if (isMap(object)) {
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(object, row);
+			switch (type) {
+				case "key":
+					object = keyOfRow;
+					break;
+				case "value": object = object.get(keyOfRow);
+			}
+		} else object = object[key];
+	}
+	return object;
+};
+const setDeep = (object, path, mapper) => {
+	validatePath(path);
+	if (path.length === 0) return mapper(object);
+	let parent = object;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		if (isArray$1(parent)) {
+			const index = +key;
+			parent = parent[index];
+		} else if (isPlainObject$1(parent)) parent = parent[key];
+		else if (isSet(parent)) {
+			const row = +key;
+			parent = getNthKey(parent, row);
+		} else if (isMap(parent)) {
+			if (i === path.length - 2) break;
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(parent, row);
+			switch (type) {
+				case "key":
+					parent = keyOfRow;
+					break;
+				case "value": parent = parent.get(keyOfRow);
+			}
+		}
+	}
+	const lastKey = path[path.length - 1];
+	if (isArray$1(parent)) parent[+lastKey] = mapper(parent[+lastKey]);
+	else if (isPlainObject$1(parent)) parent[lastKey] = mapper(parent[lastKey]);
+	if (isSet(parent)) {
+		const oldValue = getNthKey(parent, +lastKey);
+		const newValue = mapper(oldValue);
+		if (oldValue !== newValue) {
+			parent.delete(oldValue);
+			parent.add(newValue);
+		}
+	}
+	if (isMap(parent)) {
+		const row = +path[path.length - 2];
+		const keyToRow = getNthKey(parent, row);
+		switch (+lastKey === 0 ? "key" : "value") {
+			case "key": {
+				const 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)));
+		}
+	}
+	return object;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/plainer.js
+const enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker, version, origin = []) {
+	if (!tree) return;
+	const legacyPaths = enableLegacyPaths(version);
+	if (!isArray$1(tree)) {
+		forEach(tree, (subtree, key) => traverse(subtree, walker, version, [...origin, ...parsePath(key, legacyPaths)]));
+		return;
+	}
+	const [nodeValue, children] = tree;
+	if (children) forEach(children, (child, key) => {
+		traverse(child, walker, version, [...origin, ...parsePath(key, legacyPaths)]);
+	});
+	walker(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+	traverse(annotations, (type, path) => {
+		plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+	}, version);
+	return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+	const legacyPaths = enableLegacyPaths(version);
+	function apply(identicalPaths, path) {
+		const object = getDeep(plain, parsePath(path, legacyPaths));
+		identicalPaths.map((path) => parsePath(path, legacyPaths)).forEach((identicalObjectPath) => {
+			plain = setDeep(plain, identicalObjectPath, () => object);
+		});
+	}
+	if (isArray$1(annotations)) {
+		const [root, other] = annotations;
+		root.forEach((identicalPath) => {
+			plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+		});
+		if (other) forEach(other, apply);
+	} else forEach(annotations, apply);
+	return plain;
+}
+const isDeep = (object, superJson) => isPlainObject$1(object) || isArray$1(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+	const existingSet = identities.get(object);
+	if (existingSet) existingSet.push(path);
+	else identities.set(object, [path]);
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+	const result = {};
+	let rootEqualityPaths = void 0;
+	identitites.forEach((paths) => {
+		if (paths.length <= 1) return;
+		if (!dedupe) paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
+		const [representativePath, ...identicalPaths] = paths;
+		if (representativePath.length === 0) rootEqualityPaths = identicalPaths.map(stringifyPath);
+		else result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+	});
+	if (rootEqualityPaths) {
+		if (isEmptyObject(result)) return [rootEqualityPaths];
+		else return [rootEqualityPaths, result];
+	} else return isEmptyObject(result) ? void 0 : result;
+}
+const walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+	const primitive = isPrimitive(object);
+	if (!primitive) {
+		addIdentity(object, path, identities);
+		const seen = seenObjects.get(object);
+		if (seen) return dedupe ? { transformedValue: null } : seen;
+	}
+	if (!isDeep(object, superJson)) {
+		const transformed = transformValue(object, superJson);
+		const result = transformed ? {
+			transformedValue: transformed.value,
+			annotations: [transformed.type]
+		} : { transformedValue: object };
+		if (!primitive) seenObjects.set(object, result);
+		return result;
+	}
+	if (includes(objectsInThisPath, object)) return { transformedValue: null };
+	const transformationResult = transformValue(object, superJson);
+	const transformed = transformationResult?.value ?? object;
+	const transformedValue = isArray$1(transformed) ? [] : {};
+	const innerAnnotations = {};
+	forEach(transformed, (value, index) => {
+		if (index === "__proto__" || index === "constructor" || index === "prototype") throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+		const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+		transformedValue[index] = recursiveResult.transformedValue;
+		if (isArray$1(recursiveResult.annotations)) innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+		else if (isPlainObject$1(recursiveResult.annotations)) forEach(recursiveResult.annotations, (tree, key) => {
+			innerAnnotations[escapeKey(index) + "." + key] = tree;
+		});
+	});
+	const result = isEmptyObject(innerAnnotations) ? {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type] : void 0
+	} : {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+	};
+	if (!primitive) seenObjects.set(object, result);
+	return result;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/getType.js
+/** Returns the object type of the given payload */
+function getType(payload) {
+	return Object.prototype.toString.call(payload).slice(8, -1);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isArray.js
+/** Returns whether the payload is an array */
+function isArray(payload) {
+	return getType(payload) === "Array";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isPlainObject.js
+/**
+* Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+* with other prototypes)
+*/
+function isPlainObject(payload) {
+	if (getType(payload) !== "Object") return false;
+	const prototype = Object.getPrototypeOf(payload);
+	return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/copy-anything@4.0.5/node_modules/copy-anything/dist/index.js
+function assignProp(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
+	});
+}
+/**
+* Copy (clone) an object and all its props recursively to get rid of any prop referenced of the
+* original object. Arrays are also cloned, however objects inside arrays are still linked.
+*
+* @param target Target can be anything
+* @param [options={}] See type {@link Options} for more details.
+*
+*   - `{ props: ['key1'] }` will only copy the `key1` property. When using this you will need to cast
+*       the return type manually (in order to keep the TS implementation in here simple I didn't
+*       built a complex auto resolved type for those few cases people want to use this option)
+*   - `{ nonenumerable: true }` will copy all non-enumerable properties. Default is `{}`
+*
+* @returns The target with replaced values
+*/
+function copy(target, options = {}) {
+	if (isArray(target)) return target.map((item) => copy(item, options));
+	if (!isPlainObject(target)) return target;
+	const props = Object.getOwnPropertyNames(target);
+	const symbols = Object.getOwnPropertySymbols(target);
+	return [...props, ...symbols].reduce((carry, key) => {
+		if (key === "__proto__") return carry;
+		if (isArray(options.props) && !options.props.includes(key)) return carry;
+		const val = target[key];
+		assignProp(carry, key, copy(val, options), target, options.nonenumerable);
+		return carry;
+	}, {});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/index.js
+var SuperJSON = class {
+	/**
+	* @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+	*/
+	constructor({ dedupe = false } = {}) {
+		this.classRegistry = new ClassRegistry();
+		this.symbolRegistry = new Registry((s) => s.description ?? "");
+		this.customTransformerRegistry = new CustomTransformerRegistry();
+		this.allowedErrorProps = [];
+		this.dedupe = dedupe;
+	}
+	serialize(object) {
+		const identities = /* @__PURE__ */ new Map();
+		const output = walker(object, identities, this, this.dedupe);
+		const res = { json: output.transformedValue };
+		if (output.annotations) res.meta = {
+			...res.meta,
+			values: output.annotations
+		};
+		const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+		if (equalityAnnotations) res.meta = {
+			...res.meta,
+			referentialEqualities: equalityAnnotations
+		};
+		if (res.meta) res.meta.v = 1;
+		return res;
+	}
+	deserialize(payload, options) {
+		const { json, meta } = payload;
+		let result = options?.inPlace ? json : copy(json);
+		if (meta?.values) result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
+		if (meta?.referentialEqualities) result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
+		return result;
+	}
+	stringify(object) {
+		return JSON.stringify(this.serialize(object));
+	}
+	parse(string) {
+		return this.deserialize(JSON.parse(string), { inPlace: true });
+	}
+	registerClass(v, options) {
+		this.classRegistry.register(v, options);
+	}
+	registerSymbol(v, identifier) {
+		this.symbolRegistry.register(v, identifier);
+	}
+	registerCustom(transformer, name) {
+		this.customTransformerRegistry.register({
+			name,
+			...transformer
+		});
+	}
+	allowErrorProps(...props) {
+		this.allowedErrorProps.push(...props);
+	}
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+const serialize = SuperJSON.serialize;
+SuperJSON.deserialize;
+const stringify = SuperJSON.stringify;
+SuperJSON.parse;
+SuperJSON.registerClass;
+SuperJSON.registerCustom;
+SuperJSON.registerSymbol;
+SuperJSON.allowErrorProps;
+//#endregion
+//#region 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";
+}
+/**
+* Displays a string regardless the type of the data
+* @param {unknown} value Value to be stringified
+* @param {boolean} beautify Formats json to multiline
+*/
+const displayValue = (value, beautify = false) => {
+	const { json } = serialize(value);
+	return JSON.stringify(json, null, beautify ? 2 : void 0);
+};
+const getStatusRank = (q) => q.state.fetchStatus !== "idle" ? 0 : !q.getObserversCount() ? 3 : q.isStale() ? 2 : 1;
+const queryHashSort = (a, b) => a.queryHash.localeCompare(b.queryHash);
+const dateSort = (a, b) => {
+	const diff = b.state.dataUpdatedAt - a.state.dataUpdatedAt;
+	return diff < 0 ? -1 : diff > 0 ? 1 : 0;
+};
+const statusAndDateSort = (a, b) => {
+	if (getStatusRank(a) === getStatusRank(b)) return dateSort(a, b);
+	return getStatusRank(a) > getStatusRank(b) ? 1 : -1;
+};
+const sortFns = {
+	status: statusAndDateSort,
+	"query hash": queryHashSort,
+	"last updated": dateSort
+};
+const getMutationStatusRank = (m) => m.state.isPaused ? 0 : m.state.status === "error" ? 2 : m.state.status === "pending" ? 1 : 3;
+const mutationDateSort = (a, b) => a.state.submittedAt < b.state.submittedAt ? 1 : -1;
+const mutationStatusSort = (a, b) => {
+	if (getMutationStatusRank(a) === getMutationStatusRank(b)) return mutationDateSort(a, b);
+	return getMutationStatusRank(a) > getMutationStatusRank(b) ? 1 : -1;
+};
+const mutationSortFns = {
+	status: mutationStatusSort,
+	"last updated": mutationDateSort
+};
+const convertRemToPixels = (rem) => {
+	return rem * parseFloat(getComputedStyle(document.documentElement).fontSize);
+};
+const 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;
+};
+/**
+* updates nested data by path
+*
+* @param {unknown} oldData Data to be updated
+* @param {Array<string>} updatePath Path to the data to be updated
+* @param {unknown} value New value
+*/
+const 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;
+};
+/**
+* Deletes nested data by path
+*
+* @param {unknown} oldData Data to be updated
+* @param {Array<string>} deletePath Path to the data to be deleted
+* @returns newData without the deleted items by path
+*/
+const 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;
+};
+const setupStyleSheet = (nonce, target) => {
+	if (!nonce) return;
+	window.__nonce__ = nonce;
+	const root = target ?? document.head;
+	if (root.querySelector("#_goober")) return;
+	const styleTag = document.createElement("style");
+	const textNode = document.createTextNode("");
+	styleTag.appendChild(textNode);
+	styleTag.id = "_goober";
+	styleTag.setAttribute("nonce", nonce);
+	root.appendChild(styleTag);
+};
+//#endregion
+export { untrack as $, $TRACK as A, createEffect as B, memo as C, spread as D, setStyleProperty as E, Switch as F, createUniqueId as G, createRenderEffect as H, batch as I, mergeProps as J, getOwner as K, createComponent as L, Index as M, Match as N, template as O, Show as P, splitProps as Q, createComputed as R, insert as S, setAttribute as T, createRoot as U, createMemo as V, createSignal as W, onCleanup as X, on as Y, onMount as Z, Portal as _, getPreferredColorScheme as a, clearDelegatedEvents as b, getQueryStatusLabel as c, setupStyleSheet as d, useContext as et, sortFns as f, Dynamic as g, stringify as h, getMutationStatusColor as i, For as j, use as k, getSidedProp as l, serialize as m, deleteNestedDataByPath as n, getQueryStatusColor as o, updateNestedDataByPath as p, lazy as q, displayValue as r, getQueryStatusColorByLabel as s, convertRemToPixels as t, useTransition as tt, mutationSortFns as u, addEventListener as v, render as w, delegateEvents as x, className as y, createContext as z };