@tanstack/query-devtools 5.101.4 → 5.102.1

package/build/utils-BLwigsFG.cjs

@@ -0,0 +1,2942 @@
+//#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
+Object.defineProperty(exports, "$TRACK", {
+	enumerable: true,
+	get: function() {
+		return $TRACK;
+	}
+});
+Object.defineProperty(exports, "Dynamic", {
+	enumerable: true,
+	get: function() {
+		return Dynamic;
+	}
+});
+Object.defineProperty(exports, "For", {
+	enumerable: true,
+	get: function() {
+		return For;
+	}
+});
+Object.defineProperty(exports, "Index", {
+	enumerable: true,
+	get: function() {
+		return Index;
+	}
+});
+Object.defineProperty(exports, "Match", {
+	enumerable: true,
+	get: function() {
+		return Match;
+	}
+});
+Object.defineProperty(exports, "Portal", {
+	enumerable: true,
+	get: function() {
+		return Portal;
+	}
+});
+Object.defineProperty(exports, "Show", {
+	enumerable: true,
+	get: function() {
+		return Show;
+	}
+});
+Object.defineProperty(exports, "Switch", {
+	enumerable: true,
+	get: function() {
+		return Switch;
+	}
+});
+Object.defineProperty(exports, "addEventListener", {
+	enumerable: true,
+	get: function() {
+		return addEventListener;
+	}
+});
+Object.defineProperty(exports, "batch", {
+	enumerable: true,
+	get: function() {
+		return batch;
+	}
+});
+Object.defineProperty(exports, "className", {
+	enumerable: true,
+	get: function() {
+		return className;
+	}
+});
+Object.defineProperty(exports, "clearDelegatedEvents", {
+	enumerable: true,
+	get: function() {
+		return clearDelegatedEvents;
+	}
+});
+Object.defineProperty(exports, "convertRemToPixels", {
+	enumerable: true,
+	get: function() {
+		return convertRemToPixels;
+	}
+});
+Object.defineProperty(exports, "createComponent", {
+	enumerable: true,
+	get: function() {
+		return createComponent;
+	}
+});
+Object.defineProperty(exports, "createComputed", {
+	enumerable: true,
+	get: function() {
+		return createComputed;
+	}
+});
+Object.defineProperty(exports, "createContext", {
+	enumerable: true,
+	get: function() {
+		return createContext;
+	}
+});
+Object.defineProperty(exports, "createEffect", {
+	enumerable: true,
+	get: function() {
+		return createEffect;
+	}
+});
+Object.defineProperty(exports, "createMemo", {
+	enumerable: true,
+	get: function() {
+		return createMemo;
+	}
+});
+Object.defineProperty(exports, "createRenderEffect", {
+	enumerable: true,
+	get: function() {
+		return createRenderEffect;
+	}
+});
+Object.defineProperty(exports, "createRoot", {
+	enumerable: true,
+	get: function() {
+		return createRoot;
+	}
+});
+Object.defineProperty(exports, "createSignal", {
+	enumerable: true,
+	get: function() {
+		return createSignal;
+	}
+});
+Object.defineProperty(exports, "createUniqueId", {
+	enumerable: true,
+	get: function() {
+		return createUniqueId;
+	}
+});
+Object.defineProperty(exports, "delegateEvents", {
+	enumerable: true,
+	get: function() {
+		return delegateEvents;
+	}
+});
+Object.defineProperty(exports, "deleteNestedDataByPath", {
+	enumerable: true,
+	get: function() {
+		return deleteNestedDataByPath;
+	}
+});
+Object.defineProperty(exports, "displayValue", {
+	enumerable: true,
+	get: function() {
+		return displayValue;
+	}
+});
+Object.defineProperty(exports, "getMutationStatusColor", {
+	enumerable: true,
+	get: function() {
+		return getMutationStatusColor;
+	}
+});
+Object.defineProperty(exports, "getOwner", {
+	enumerable: true,
+	get: function() {
+		return getOwner;
+	}
+});
+Object.defineProperty(exports, "getPreferredColorScheme", {
+	enumerable: true,
+	get: function() {
+		return getPreferredColorScheme;
+	}
+});
+Object.defineProperty(exports, "getQueryStatusColor", {
+	enumerable: true,
+	get: function() {
+		return getQueryStatusColor;
+	}
+});
+Object.defineProperty(exports, "getQueryStatusColorByLabel", {
+	enumerable: true,
+	get: function() {
+		return getQueryStatusColorByLabel;
+	}
+});
+Object.defineProperty(exports, "getQueryStatusLabel", {
+	enumerable: true,
+	get: function() {
+		return getQueryStatusLabel;
+	}
+});
+Object.defineProperty(exports, "getSidedProp", {
+	enumerable: true,
+	get: function() {
+		return getSidedProp;
+	}
+});
+Object.defineProperty(exports, "insert", {
+	enumerable: true,
+	get: function() {
+		return insert;
+	}
+});
+Object.defineProperty(exports, "lazy", {
+	enumerable: true,
+	get: function() {
+		return lazy;
+	}
+});
+Object.defineProperty(exports, "memo", {
+	enumerable: true,
+	get: function() {
+		return memo;
+	}
+});
+Object.defineProperty(exports, "mergeProps", {
+	enumerable: true,
+	get: function() {
+		return mergeProps;
+	}
+});
+Object.defineProperty(exports, "mutationSortFns", {
+	enumerable: true,
+	get: function() {
+		return mutationSortFns;
+	}
+});
+Object.defineProperty(exports, "on", {
+	enumerable: true,
+	get: function() {
+		return on;
+	}
+});
+Object.defineProperty(exports, "onCleanup", {
+	enumerable: true,
+	get: function() {
+		return onCleanup;
+	}
+});
+Object.defineProperty(exports, "onMount", {
+	enumerable: true,
+	get: function() {
+		return onMount;
+	}
+});
+Object.defineProperty(exports, "render", {
+	enumerable: true,
+	get: function() {
+		return render;
+	}
+});
+Object.defineProperty(exports, "serialize", {
+	enumerable: true,
+	get: function() {
+		return serialize;
+	}
+});
+Object.defineProperty(exports, "setAttribute", {
+	enumerable: true,
+	get: function() {
+		return setAttribute;
+	}
+});
+Object.defineProperty(exports, "setStyleProperty", {
+	enumerable: true,
+	get: function() {
+		return setStyleProperty;
+	}
+});
+Object.defineProperty(exports, "setupStyleSheet", {
+	enumerable: true,
+	get: function() {
+		return setupStyleSheet;
+	}
+});
+Object.defineProperty(exports, "sortFns", {
+	enumerable: true,
+	get: function() {
+		return sortFns;
+	}
+});
+Object.defineProperty(exports, "splitProps", {
+	enumerable: true,
+	get: function() {
+		return splitProps;
+	}
+});
+Object.defineProperty(exports, "spread", {
+	enumerable: true,
+	get: function() {
+		return spread;
+	}
+});
+Object.defineProperty(exports, "stringify", {
+	enumerable: true,
+	get: function() {
+		return stringify;
+	}
+});
+Object.defineProperty(exports, "template", {
+	enumerable: true,
+	get: function() {
+		return template;
+	}
+});
+Object.defineProperty(exports, "untrack", {
+	enumerable: true,
+	get: function() {
+		return untrack;
+	}
+});
+Object.defineProperty(exports, "updateNestedDataByPath", {
+	enumerable: true,
+	get: function() {
+		return updateNestedDataByPath;
+	}
+});
+Object.defineProperty(exports, "use", {
+	enumerable: true,
+	get: function() {
+		return use;
+	}
+});
+Object.defineProperty(exports, "useContext", {
+	enumerable: true,
+	get: function() {
+		return useContext;
+	}
+});
+Object.defineProperty(exports, "useTransition", {
+	enumerable: true,
+	get: function() {
+		return useTransition;
+	}
+});