gemi 0.52.0 → 0.54.0

package/dist/chunks/ThemeProvider-Bk1eZymb.js

@@ -0,0 +1,2901 @@
+import { Component, createContext, createElement, lazy, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { createPortal } from "react-dom";
+//#region utils/Subject.ts
+var Subject = class {
+	subscribers = /* @__PURE__ */ new Set();
+	value;
+	constructor(initialValue) {
+		this.value = initialValue;
+		this.subscribe = this.subscribe.bind(this);
+		this.next = this.next.bind(this);
+		this.getValue = this.getValue.bind(this);
+	}
+	subscribe(subscriber) {
+		this.subscribers.add(subscriber);
+		return () => {
+			this.subscribers.delete(subscriber);
+		};
+	}
+	next(value) {
+		this.value = value;
+		this.subscribers.forEach((subscriber) => subscriber(value));
+	}
+	getValue() {
+		return this.value;
+	}
+};
+//#endregion
+//#region client/QueryError.ts
+/**
+* An HTTP failure from a query endpoint, in a shape an error boundary can
+* work with. `resolveVariant` used to store the parsed response body as the
+* error; boundaries expect an `Error`, so the body moves to a field.
+*/
+var QueryError = class extends Error {
+	path;
+	variantKey;
+	status;
+	body;
+	constructor(path, variantKey, status, body) {
+		super(typeof body?.message === "string" ? body.message : `Request to /api${path} failed with status ${status}`);
+		this.path = path;
+		this.variantKey = variantKey;
+		this.status = status;
+		this.body = body;
+		this.name = "QueryError";
+	}
+};
+//#endregion
+//#region client/QueryResource.ts
+var DEFAULT_STALE_TIME = 5e3;
+var QueryResource = class {
+	store;
+	staleVariants = /* @__PURE__ */ new Set();
+	lastFetchRecord = /* @__PURE__ */ new Map();
+	key;
+	/**
+	* Variants with a request on the wire. React discards and retries a
+	* suspended render, so `read` runs many times for one commit — this is what
+	* collapses those attempts onto a single fetch. The `loading` flag can't do
+	* it: render-initiated fetches are silent and never write to the store.
+	*/
+	inflight = /* @__PURE__ */ new Set();
+	/**
+	* One promise per suspended variant, handed to `use()`. Settled by whatever
+	* write lands first — the variant's own fetch or a `hydrate` from a route
+	* payload — so a prefetch that arrives mid-suspension wakes the reader
+	* without waiting on the wire.
+	*/
+	pending = /* @__PURE__ */ new Map();
+	constructor(key, initialState) {
+		this.key = key;
+		this.store = new Subject(/* @__PURE__ */ new Map());
+		this.hydrate(initialState);
+	}
+	/**
+	* Adopt server-prefetched data into the cache.
+	*
+	* Called once from the constructor for the SSR payload, and again on every
+	* client-side navigation with the `prefetchedData` the server just produced —
+	* otherwise the resource cache (which is keyed by path for the lifetime of
+	* the app) would keep serving the first payload and revalidate it over `/api`.
+	*/
+	hydrate(initialState) {
+		const store = this.store.getValue();
+		const now = Date.now();
+		let changed = false;
+		for (const [variantKey, data] of Object.entries(initialState ?? {})) {
+			if (data === void 0) continue;
+			const current = store.get(variantKey);
+			if (current?.loading) continue;
+			if (current?.hasData && current.data === data) continue;
+			store.set(variantKey, {
+				loading: false,
+				data,
+				hasData: true,
+				error: null,
+				version: now
+			});
+			this.staleVariants.delete(variantKey);
+			this.lastFetchRecord.set(variantKey, now);
+			this.settle(variantKey);
+			changed = true;
+		}
+		if (changed) this.store.next(store);
+	}
+	pendingFor(variantKey) {
+		let deferred = this.pending.get(variantKey);
+		if (!deferred) {
+			let resolve;
+			deferred = {
+				promise: new Promise((r) => {
+					resolve = r;
+				}),
+				resolve
+			};
+			this.pending.set(variantKey, deferred);
+		}
+		return deferred;
+	}
+	settle(variantKey) {
+		const deferred = this.pending.get(variantKey);
+		if (deferred) {
+			this.pending.delete(variantKey);
+			deferred.resolve();
+		}
+	}
+	isStale(variantKey, staleTime) {
+		if (this.staleVariants.has(variantKey)) return true;
+		const now = Date.now();
+		return now - (this.lastFetchRecord.get(variantKey) ?? now) >= staleTime;
+	}
+	/**
+	* The cached state for a variant, or `undefined` — a plain read that never
+	* fetches and never revalidates.
+	*
+	* `getVariant` is the read that keeps the cache honest, and it starts a
+	* request when it has to. That makes it the wrong thing to call while
+	* rendering: React throws away a render whose subtree suspends and retries
+	* it, so every discarded attempt would leak a request. Renders read with
+	* this; effects, which only run for a render that committed, use
+	* `getVariant`.
+	*/
+	peek(variantKey) {
+		return this.store.getValue().get(variantKey);
+	}
+	/**
+	* The read a render performs. Never suspends when data is in hand (stale
+	* data revalidates in the background instead), dedupes across the render
+	* attempts React throws away, and hands back a promise that resolves off
+	* any write to the variant — its own fetch or a `hydrate`.
+	*
+	* Safe during render: it never writes to the store synchronously, so the
+	* snapshot `useSyncExternalStore` read stays valid for the whole attempt.
+	*/
+	read(variantKey, staleTime = DEFAULT_STALE_TIME) {
+		const state = this.peek(variantKey);
+		if (state?.hasData) {
+			if (!this.inflight.has(variantKey) && this.isStale(variantKey, staleTime)) {
+				this.lastFetchRecord.set(variantKey, Date.now());
+				this.resolveVariant(variantKey, true);
+			}
+			return { state };
+		}
+		if (state?.error) return { state };
+		if (typeof window === "undefined") return { state };
+		const deferred = this.pendingFor(variantKey);
+		if (!this.inflight.has(variantKey)) this.resolveVariant(variantKey, true);
+		return {
+			state,
+			promise: deferred.promise
+		};
+	}
+	getVariant(variantKey, staleTime = DEFAULT_STALE_TIME) {
+		const store = this.store.getValue();
+		if (!store.has(variantKey)) {
+			if (!this.inflight.has(variantKey)) this.resolveVariant(variantKey);
+		} else {
+			const variant = store.get(variantKey);
+			if (!variant.loading && !this.inflight.has(variantKey)) {
+				if (!variant.hasData) {
+					this.resolveVariant(variantKey);
+					return store.get(variantKey);
+				}
+				if (this.isStale(variantKey, staleTime)) {
+					this.lastFetchRecord.set(variantKey, Date.now());
+					this.resolveVariant(variantKey, true);
+					return store.get(variantKey);
+				}
+			}
+		}
+		return store.get(variantKey);
+	}
+	/**
+	* Drop the error for one variant (or every variant when omitted), so an
+	* error boundary reset re-renders into a clean read instead of instantly
+	* re-throwing the stored failure.
+	*/
+	clearError(variantKey) {
+		const store = this.store.getValue();
+		let changed = false;
+		for (const [key, state] of store) {
+			if (variantKey !== void 0 && key !== variantKey) continue;
+			if (state.error) {
+				store.set(key, {
+					...state,
+					error: null
+				});
+				changed = true;
+			}
+		}
+		if (changed) this.store.next(store);
+	}
+	mutate(variantKey, fn = (data) => data) {
+		const cacheKey = [
+			typeof window !== "undefined" && window.location?.origin ? window.location.origin : "",
+			this.key,
+			variantKey
+		].filter((s) => s.length > 0).join("?");
+		try {
+			if (caches) caches?.delete(cacheKey);
+		} catch (err) {}
+		const store = this.store.getValue();
+		const state = store.get(variantKey);
+		if (!state || !state.hasData) {
+			this.resolveVariant(variantKey, false, false);
+			return;
+		}
+		const data = fn(state.data);
+		this.staleVariants.add(variantKey);
+		this.store.next(store.set(variantKey, {
+			loading: false,
+			data,
+			hasData: true,
+			error: null,
+			version: state.version
+		}));
+		this.resolveVariant(variantKey, false, false);
+	}
+	refetch(variantKey) {
+		this.resolveVariant(variantKey, false, false);
+	}
+	async resolveVariant(variantKey, silent = false, cache = true) {
+		if (typeof window === "undefined") return;
+		this.inflight.add(variantKey);
+		try {
+			const store = this.store.getValue();
+			const previousState = store.get(variantKey);
+			if (!silent) store.set(variantKey, {
+				loading: true,
+				data: previousState?.data,
+				hasData: previousState?.hasData ?? false,
+				error: previousState?.error,
+				version: previousState?.version
+			});
+			let data = null;
+			let response = null;
+			const fullUrl = [this.key, variantKey].filter((s) => s.length).join("?");
+			try {
+				response = await fetch(`/api${fullUrl}`, { cache: cache ? "default" : "reload" });
+				data = await response.json();
+			} catch (error) {
+				console.error(`Error fetching url /api${fullUrl}`, error);
+				this.store.next(store.set(variantKey, {
+					loading: false,
+					data: previousState?.data,
+					hasData: previousState?.hasData ?? false,
+					error,
+					version: previousState?.version
+				}));
+				return;
+			}
+			if (response.ok) {
+				this.store.next(store.set(variantKey, {
+					loading: false,
+					data,
+					hasData: true,
+					error: null,
+					version: Date.now()
+				}));
+				this.staleVariants.delete(variantKey);
+				this.lastFetchRecord.set(variantKey, Date.now());
+			} else this.store.next(store.set(variantKey, {
+				loading: false,
+				data: previousState?.data,
+				hasData: previousState?.hasData ?? false,
+				error: new QueryError(this.key, variantKey, response.status, data),
+				version: previousState?.version
+			}));
+		} finally {
+			this.inflight.delete(variantKey);
+			this.settle(variantKey);
+		}
+	}
+};
+//#endregion
+//#region client/QueryManagerContext.tsx
+var QueryConfigContext = createContext(null);
+/**
+* The runtime mirror of the `QueryConfig` type: TS excess-property checking
+* only fires on fresh object literals, so a dynamically built (or plain-JS)
+* config could smuggle call-site-only keys (`lazy`, `fallbackData`,
+* `refetchUntil`) into every query. The provider picks these keys — and only
+* these — before the value enters the context. Keys whose value is
+* `undefined` are dropped too, so an absent value (e.g. an unset env-derived
+* `staleTime`) falls through to the framework default instead of shadowing it.
+*/
+var APP_WIDE_QUERY_CONFIG_KEYS = [
+	"suspense",
+	"staleTime",
+	"keepPreviousData",
+	"retryIntervalOnError",
+	"refreshInterval"
+];
+function pickAppWideQueryConfig(queryConfig) {
+	if (!queryConfig) return null;
+	const picked = {};
+	for (const key of APP_WIDE_QUERY_CONFIG_KEYS) if (queryConfig[key] !== void 0) picked[key] = queryConfig[key];
+	return picked;
+}
+var QueryManagerContext = createContext({
+	getResource: (key, initialState = {}) => {
+		return new QueryResource(key, initialState);
+	},
+	hydrate: () => {},
+	clearErrors: () => {}
+});
+var QueryManagerProvider = ({ children, queryConfig = null }) => {
+	const resourcesRef = useRef(/* @__PURE__ */ new Map());
+	const appQueryConfig = useMemo(() => pickAppWideQueryConfig(queryConfig), [queryConfig]);
+	const getResource = useCallback((key, initialState) => {
+		let resource = resourcesRef.current.get(key);
+		if (!resource) {
+			resource = new QueryResource(key, initialState ?? {});
+			resourcesRef.current.set(key, resource);
+		}
+		return resource;
+	}, []);
+	const hydrate = useCallback((prefetchedData) => {
+		if (!prefetchedData) return;
+		for (const [key, initialState] of Object.entries(prefetchedData)) {
+			if (!initialState || typeof initialState !== "object") continue;
+			const resource = resourcesRef.current.get(key);
+			if (resource) resource.hydrate(initialState);
+			else resourcesRef.current.set(key, new QueryResource(key, initialState));
+		}
+	}, []);
+	const clearErrors = useCallback(() => {
+		for (const resource of resourcesRef.current.values()) resource.clearError();
+	}, []);
+	const drainedStreamRef = useRef(false);
+	if (typeof window !== "undefined" && !drainedStreamRef.current) {
+		drainedStreamRef.current = true;
+		const w = window;
+		const adopt = ([path, variantKey, data]) => {
+			hydrate({ [path]: { [variantKey]: data } });
+		};
+		const buffered = Array.isArray(w.__GEMI_STREAM__) ? w.__GEMI_STREAM__ : [];
+		w.__GEMI_STREAM__ = { push: adopt };
+		for (const payload of buffered) adopt(payload);
+	}
+	const value = useMemo(() => ({
+		getResource,
+		hydrate,
+		clearErrors
+	}), [
+		getResource,
+		hydrate,
+		clearErrors
+	]);
+	return /* @__PURE__ */ jsx(QueryManagerContext.Provider, {
+		value,
+		children: /* @__PURE__ */ jsx(QueryConfigContext.Provider, {
+			value: appQueryConfig,
+			children
+		})
+	});
+};
+//#endregion
+//#region utils/applyParams.ts
+function applyParams(url, params) {
+	return url.replace(/:([^/]+[*?]?)/g, (_, key) => {
+		const hasSuffix = key.endsWith("?") || key.endsWith("*");
+		const paramName = hasSuffix ? key.slice(0, -1) : key;
+		const value = params[paramName];
+		if (value === void 0) {
+			if (hasSuffix) return "";
+			console.error(`Missing parameter: ${paramName} in URL: ${url}`);
+		}
+		return String(value);
+	}).replace(/\/\//g, "/").replace(/\/$/, "");
+}
+//#endregion
+//#region utils/omitNullishValues.ts
+function omitNullishValues(input) {
+	return Object.fromEntries(Object.entries(input).filter(([, value]) => {
+		return value !== null && value !== void 0;
+	}));
+}
+//#endregion
+//#region utils/variantKey.ts
+/**
+* The key one search-param combination is cached under, inside a query's
+* resource: the params sorted and serialized, empty when there are none.
+*
+* Sorted because `?b=2&a=1` and `?a=1&b=2` are the same request, and a cache
+* that keyed them separately would fetch twice and hydrate one of them from a
+* payload the server produced for the other. Nullish values are dropped for
+* the same reason: an optional filter left `undefined` is absent, not the
+* string `"undefined"`.
+*
+* Every site that reads or writes the cache derives its key from here —
+* `useQuery` (the read), `useMutate` (the write), and `gemi/testing`'s `<Page>`
+* (the seed). They used to hold a copy each, which is the kind of duplication
+* that fails quietly: a seed built by an old copy simply misses, and the test
+* that should have read it fetches over the network and asserts an empty state
+* with nothing pointing at the mismatch.
+*/
+function toVariantKey(search) {
+	const searchParams = new URLSearchParams(typeof search === "string" ? search : omitNullishValues(search ?? {}));
+	searchParams.sort();
+	return searchParams.toString();
+}
+//#endregion
+//#region client/RouteStateContext.tsx
+var RouteStateContext = createContext({});
+var RouteStateProvider = (props) => {
+	return /* @__PURE__ */ jsx(RouteStateContext.Provider, {
+		value: props.state,
+		children: props.children
+	});
+};
+//#endregion
+//#region client/useParams.ts
+function useParams() {
+	const { params = {} } = useContext(RouteStateContext);
+	return params;
+}
+//#endregion
+//#region ../../node_modules/.bun/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+	return _extends = Object.assign ? Object.assign.bind() : function(n) {
+		for (var e = 1; e < arguments.length; e++) {
+			var t = arguments[e];
+			for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+		}
+		return n;
+	}, _extends.apply(null, arguments);
+}
+//#endregion
+//#region ../../node_modules/.bun/history@5.3.0/node_modules/history/index.js
+/**
+* Actions represent the type of change to a location value.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action
+*/
+var Action;
+(function(Action) {
+	/**
+	* A POP indicates a change to an arbitrary index in the history stack, such
+	* as a back or forward navigation. It does not describe the direction of the
+	* navigation, only that the current index changed.
+	*
+	* Note: This is the default action for newly created history objects.
+	*/
+	Action["Pop"] = "POP";
+	/**
+	* A PUSH indicates a new entry being added to the history stack, such as when
+	* a link is clicked and a new page loads. When this happens, all subsequent
+	* entries in the stack are lost.
+	*/
+	Action["Push"] = "PUSH";
+	/**
+	* A REPLACE indicates the entry at the current index in the history stack
+	* being replaced by a new one.
+	*/
+	Action["Replace"] = "REPLACE";
+})(Action || (Action = {}));
+var readOnly = process.env.NODE_ENV !== "production" ? function(obj) {
+	return Object.freeze(obj);
+} : function(obj) {
+	return obj;
+};
+function warning(cond, message) {
+	if (!cond) {
+		if (typeof console !== "undefined") console.warn(message);
+		try {
+			throw new Error(message);
+		} catch (e) {}
+	}
+}
+var BeforeUnloadEventType = "beforeunload";
+var PopStateEventType = "popstate";
+/**
+* Browser history stores the location in regular URLs. This is the standard for
+* most web apps, but it requires some configuration on the server to ensure you
+* serve the same app at multiple URLs.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+*/
+function createBrowserHistory(options) {
+	if (options === void 0) options = {};
+	var _options$window = options.window, window = _options$window === void 0 ? document.defaultView : _options$window;
+	var globalHistory = window.history;
+	function getIndexAndLocation() {
+		var _window$location = window.location, pathname = _window$location.pathname, search = _window$location.search, hash = _window$location.hash;
+		var state = globalHistory.state || {};
+		return [state.idx, readOnly({
+			pathname,
+			search,
+			hash,
+			state: state.usr || null,
+			key: state.key || "default"
+		})];
+	}
+	var blockedPopTx = null;
+	function handlePop() {
+		if (blockedPopTx) {
+			blockers.call(blockedPopTx);
+			blockedPopTx = null;
+		} else {
+			var nextAction = Action.Pop;
+			var _getIndexAndLocation = getIndexAndLocation(), nextIndex = _getIndexAndLocation[0], nextLocation = _getIndexAndLocation[1];
+			if (blockers.length) if (nextIndex != null) {
+				var delta = index - nextIndex;
+				if (delta) {
+					blockedPopTx = {
+						action: nextAction,
+						location: nextLocation,
+						retry: function retry() {
+							go(delta * -1);
+						}
+					};
+					go(delta);
+				}
+			} else process.env.NODE_ENV !== "production" && warning(false, "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail silently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directly) to avoid this situation.");
+			else applyTx(nextAction);
+		}
+	}
+	window.addEventListener(PopStateEventType, handlePop);
+	var action = Action.Pop;
+	var _getIndexAndLocation2 = getIndexAndLocation(), index = _getIndexAndLocation2[0], location = _getIndexAndLocation2[1];
+	var listeners = createEvents();
+	var blockers = createEvents();
+	if (index == null) {
+		index = 0;
+		globalHistory.replaceState(_extends({}, globalHistory.state, { idx: index }), "");
+	}
+	function createHref(to) {
+		return typeof to === "string" ? to : createPath(to);
+	}
+	function getNextLocation(to, state) {
+		if (state === void 0) state = null;
+		return readOnly(_extends({
+			pathname: location.pathname,
+			hash: "",
+			search: ""
+		}, typeof to === "string" ? parsePath(to) : to, {
+			state,
+			key: createKey()
+		}));
+	}
+	function getHistoryStateAndUrl(nextLocation, index) {
+		return [{
+			usr: nextLocation.state,
+			key: nextLocation.key,
+			idx: index
+		}, createHref(nextLocation)];
+	}
+	function allowTx(action, location, retry) {
+		return !blockers.length || (blockers.call({
+			action,
+			location,
+			retry
+		}), false);
+	}
+	function applyTx(nextAction) {
+		action = nextAction;
+		var _getIndexAndLocation3 = getIndexAndLocation();
+		index = _getIndexAndLocation3[0];
+		location = _getIndexAndLocation3[1];
+		listeners.call({
+			action,
+			location
+		});
+	}
+	function push(to, state) {
+		var nextAction = Action.Push;
+		var nextLocation = getNextLocation(to, state);
+		function retry() {
+			push(to, state);
+		}
+		if (allowTx(nextAction, nextLocation, retry)) {
+			var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1), historyState = _getHistoryStateAndUr[0], url = _getHistoryStateAndUr[1];
+			try {
+				globalHistory.pushState(historyState, "", url);
+			} catch (error) {
+				window.location.assign(url);
+			}
+			applyTx(nextAction);
+		}
+	}
+	function replace(to, state) {
+		var nextAction = Action.Replace;
+		var nextLocation = getNextLocation(to, state);
+		function retry() {
+			replace(to, state);
+		}
+		if (allowTx(nextAction, nextLocation, retry)) {
+			var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index), historyState = _getHistoryStateAndUr2[0], url = _getHistoryStateAndUr2[1];
+			globalHistory.replaceState(historyState, "", url);
+			applyTx(nextAction);
+		}
+	}
+	function go(delta) {
+		globalHistory.go(delta);
+	}
+	return {
+		get action() {
+			return action;
+		},
+		get location() {
+			return location;
+		},
+		createHref,
+		push,
+		replace,
+		go,
+		back: function back() {
+			go(-1);
+		},
+		forward: function forward() {
+			go(1);
+		},
+		listen: function listen(listener) {
+			return listeners.push(listener);
+		},
+		block: function block(blocker) {
+			var unblock = blockers.push(blocker);
+			if (blockers.length === 1) window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+			return function() {
+				unblock();
+				if (!blockers.length) window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+			};
+		}
+	};
+}
+/**
+* Memory history stores the current location in memory. It is designed for use
+* in stateful non-browser environments like tests and React Native.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory
+*/
+function createMemoryHistory(options) {
+	if (options === void 0) options = {};
+	var _options3 = options, _options3$initialEntr = _options3.initialEntries, initialEntries = _options3$initialEntr === void 0 ? ["/"] : _options3$initialEntr, initialIndex = _options3.initialIndex;
+	var entries = initialEntries.map(function(entry) {
+		var location = readOnly(_extends({
+			pathname: "/",
+			search: "",
+			hash: "",
+			state: null,
+			key: createKey()
+		}, typeof entry === "string" ? parsePath(entry) : entry));
+		process.env.NODE_ENV !== "production" && warning(location.pathname.charAt(0) === "/", "Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: " + JSON.stringify(entry) + ")");
+		return location;
+	});
+	var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);
+	var action = Action.Pop;
+	var location = entries[index];
+	var listeners = createEvents();
+	var blockers = createEvents();
+	function createHref(to) {
+		return typeof to === "string" ? to : createPath(to);
+	}
+	function getNextLocation(to, state) {
+		if (state === void 0) state = null;
+		return readOnly(_extends({
+			pathname: location.pathname,
+			search: "",
+			hash: ""
+		}, typeof to === "string" ? parsePath(to) : to, {
+			state,
+			key: createKey()
+		}));
+	}
+	function allowTx(action, location, retry) {
+		return !blockers.length || (blockers.call({
+			action,
+			location,
+			retry
+		}), false);
+	}
+	function applyTx(nextAction, nextLocation) {
+		action = nextAction;
+		location = nextLocation;
+		listeners.call({
+			action,
+			location
+		});
+	}
+	function push(to, state) {
+		var nextAction = Action.Push;
+		var nextLocation = getNextLocation(to, state);
+		function retry() {
+			push(to, state);
+		}
+		process.env.NODE_ENV !== "production" && warning(location.pathname.charAt(0) === "/", "Relative pathnames are not supported in memory history.push(" + JSON.stringify(to) + ")");
+		if (allowTx(nextAction, nextLocation, retry)) {
+			index += 1;
+			entries.splice(index, entries.length, nextLocation);
+			applyTx(nextAction, nextLocation);
+		}
+	}
+	function replace(to, state) {
+		var nextAction = Action.Replace;
+		var nextLocation = getNextLocation(to, state);
+		function retry() {
+			replace(to, state);
+		}
+		process.env.NODE_ENV !== "production" && warning(location.pathname.charAt(0) === "/", "Relative pathnames are not supported in memory history.replace(" + JSON.stringify(to) + ")");
+		if (allowTx(nextAction, nextLocation, retry)) {
+			entries[index] = nextLocation;
+			applyTx(nextAction, nextLocation);
+		}
+	}
+	function go(delta) {
+		var nextIndex = clamp(index + delta, 0, entries.length - 1);
+		var nextAction = Action.Pop;
+		var nextLocation = entries[nextIndex];
+		function retry() {
+			go(delta);
+		}
+		if (allowTx(nextAction, nextLocation, retry)) {
+			index = nextIndex;
+			applyTx(nextAction, nextLocation);
+		}
+	}
+	return {
+		get index() {
+			return index;
+		},
+		get action() {
+			return action;
+		},
+		get location() {
+			return location;
+		},
+		createHref,
+		push,
+		replace,
+		go,
+		back: function back() {
+			go(-1);
+		},
+		forward: function forward() {
+			go(1);
+		},
+		listen: function listen(listener) {
+			return listeners.push(listener);
+		},
+		block: function block(blocker) {
+			return blockers.push(blocker);
+		}
+	};
+}
+function clamp(n, lowerBound, upperBound) {
+	return Math.min(Math.max(n, lowerBound), upperBound);
+}
+function promptBeforeUnload(event) {
+	event.preventDefault();
+	event.returnValue = "";
+}
+function createEvents() {
+	var handlers = [];
+	return {
+		get length() {
+			return handlers.length;
+		},
+		push: function push(fn) {
+			handlers.push(fn);
+			return function() {
+				handlers = handlers.filter(function(handler) {
+					return handler !== fn;
+				});
+			};
+		},
+		call: function call(arg) {
+			handlers.forEach(function(fn) {
+				return fn && fn(arg);
+			});
+		}
+	};
+}
+function createKey() {
+	return Math.random().toString(36).substr(2, 8);
+}
+/**
+* Creates a string URL path from the given pathname, search, and hash components.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath
+*/
+function createPath(_ref) {
+	var _ref$pathname = _ref.pathname, pathname = _ref$pathname === void 0 ? "/" : _ref$pathname, _ref$search = _ref.search, search = _ref$search === void 0 ? "" : _ref$search, _ref$hash = _ref.hash, hash = _ref$hash === void 0 ? "" : _ref$hash;
+	if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
+	if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+	return pathname;
+}
+/**
+* Parses a string URL path into its separate pathname, search, and hash components.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath
+*/
+function parsePath(path) {
+	var parsedPath = {};
+	if (path) {
+		var hashIndex = path.indexOf("#");
+		if (hashIndex >= 0) {
+			parsedPath.hash = path.substr(hashIndex);
+			path = path.substr(0, hashIndex);
+		}
+		var searchIndex = path.indexOf("?");
+		if (searchIndex >= 0) {
+			parsedPath.search = path.substr(searchIndex);
+			path = path.substr(0, searchIndex);
+		}
+		if (path) parsedPath.pathname = path;
+	}
+	return parsedPath;
+}
+//#endregion
+//#region ../../node_modules/.bun/urlpattern-polyfill@10.1.0/node_modules/urlpattern-polyfill/dist/urlpattern.js
+var Pe = Object.defineProperty;
+var a = (e, t) => Pe(e, "name", {
+	value: t,
+	configurable: !0
+});
+var P = class {
+	type = 3;
+	name = "";
+	prefix = "";
+	value = "";
+	suffix = "";
+	modifier = 3;
+	constructor(t, r, n, c, l, f) {
+		this.type = t, this.name = r, this.prefix = n, this.value = c, this.suffix = l, this.modifier = f;
+	}
+	hasCustomName() {
+		return this.name !== "" && typeof this.name != "number";
+	}
+};
+a(P, "Part");
+var Re = /[$_\p{ID_Start}]/u;
+var Ee = /[$_\u200C\u200D\p{ID_Continue}]/u;
+var v = ".*";
+function Oe(e, t) {
+	return (t ? /^[\x00-\xFF]*$/ : /^[\x00-\x7F]*$/).test(e);
+}
+a(Oe, "isASCII");
+function D(e, t = !1) {
+	let r = [], n = 0;
+	for (; n < e.length;) {
+		let c = e[n], l = a(function(f) {
+			if (!t) throw new TypeError(f);
+			r.push({
+				type: "INVALID_CHAR",
+				index: n,
+				value: e[n++]
+			});
+		}, "ErrorOrInvalid");
+		if (c === "*") {
+			r.push({
+				type: "ASTERISK",
+				index: n,
+				value: e[n++]
+			});
+			continue;
+		}
+		if (c === "+" || c === "?") {
+			r.push({
+				type: "OTHER_MODIFIER",
+				index: n,
+				value: e[n++]
+			});
+			continue;
+		}
+		if (c === "\\") {
+			r.push({
+				type: "ESCAPED_CHAR",
+				index: n++,
+				value: e[n++]
+			});
+			continue;
+		}
+		if (c === "{") {
+			r.push({
+				type: "OPEN",
+				index: n,
+				value: e[n++]
+			});
+			continue;
+		}
+		if (c === "}") {
+			r.push({
+				type: "CLOSE",
+				index: n,
+				value: e[n++]
+			});
+			continue;
+		}
+		if (c === ":") {
+			let f = "", s = n + 1;
+			for (; s < e.length;) {
+				let i = e.substr(s, 1);
+				if (s === n + 1 && Re.test(i) || s !== n + 1 && Ee.test(i)) {
+					f += e[s++];
+					continue;
+				}
+				break;
+			}
+			if (!f) {
+				l(`Missing parameter name at ${n}`);
+				continue;
+			}
+			r.push({
+				type: "NAME",
+				index: n,
+				value: f
+			}), n = s;
+			continue;
+		}
+		if (c === "(") {
+			let f = 1, s = "", i = n + 1, o = !1;
+			if (e[i] === "?") {
+				l(`Pattern cannot start with "?" at ${i}`);
+				continue;
+			}
+			for (; i < e.length;) {
+				if (!Oe(e[i], !1)) {
+					l(`Invalid character '${e[i]}' at ${i}.`), o = !0;
+					break;
+				}
+				if (e[i] === "\\") {
+					s += e[i++] + e[i++];
+					continue;
+				}
+				if (e[i] === ")") {
+					if (f--, f === 0) {
+						i++;
+						break;
+					}
+				} else if (e[i] === "(" && (f++, e[i + 1] !== "?")) {
+					l(`Capturing groups are not allowed at ${i}`), o = !0;
+					break;
+				}
+				s += e[i++];
+			}
+			if (o) continue;
+			if (f) {
+				l(`Unbalanced pattern at ${n}`);
+				continue;
+			}
+			if (!s) {
+				l(`Missing pattern at ${n}`);
+				continue;
+			}
+			r.push({
+				type: "REGEX",
+				index: n,
+				value: s
+			}), n = i;
+			continue;
+		}
+		r.push({
+			type: "CHAR",
+			index: n,
+			value: e[n++]
+		});
+	}
+	return r.push({
+		type: "END",
+		index: n,
+		value: ""
+	}), r;
+}
+a(D, "lexer");
+function F(e, t = {}) {
+	let r = D(e);
+	t.delimiter ??= "/#?", t.prefixes ??= "./";
+	let n = `[^${x(t.delimiter)}]+?`, c = [], l = 0, f = 0, i = /* @__PURE__ */ new Set(), o = a((u) => {
+		if (f < r.length && r[f].type === u) return r[f++].value;
+	}, "tryConsume"), h = a(() => o("OTHER_MODIFIER") ?? o("ASTERISK"), "tryConsumeModifier"), p = a((u) => {
+		let d = o(u);
+		if (d !== void 0) return d;
+		let { type: g, index: y } = r[f];
+		throw new TypeError(`Unexpected ${g} at ${y}, expected ${u}`);
+	}, "mustConsume"), A = a(() => {
+		let u = "", d;
+		for (; d = o("CHAR") ?? o("ESCAPED_CHAR");) u += d;
+		return u;
+	}, "consumeText"), xe = a((u) => u, "DefaultEncodePart"), N = t.encodePart || xe, H = "", $ = a((u) => {
+		H += u;
+	}, "appendToPendingFixedValue"), M = a(() => {
+		H.length && (c.push(new P(3, "", "", N(H), "", 3)), H = "");
+	}, "maybeAddPartFromPendingFixedValue"), X = a((u, d, g, y, Z) => {
+		let m = 3;
+		switch (Z) {
+			case "?":
+				m = 1;
+				break;
+			case "*":
+				m = 0;
+				break;
+			case "+":
+				m = 2;
+				break;
+		}
+		if (!d && !g && m === 3) {
+			$(u);
+			return;
+		}
+		if (M(), !d && !g) {
+			if (!u) return;
+			c.push(new P(3, "", "", N(u), "", m));
+			return;
+		}
+		let S;
+		g ? g === "*" ? S = v : S = g : S = n;
+		let k = 2;
+		S === n ? (k = 1, S = "") : S === v && (k = 0, S = "");
+		let E;
+		if (d ? E = d : g && (E = l++), i.has(E)) throw new TypeError(`Duplicate name '${E}'.`);
+		i.add(E), c.push(new P(k, E, N(u), S, N(y), m));
+	}, "addPart");
+	for (; f < r.length;) {
+		let u = o("CHAR"), d = o("NAME"), g = o("REGEX");
+		if (!d && !g && (g = o("ASTERISK")), d || g) {
+			let m = u ?? "";
+			t.prefixes.indexOf(m) === -1 && ($(m), m = ""), M();
+			let S = h();
+			X(m, d, g, "", S);
+			continue;
+		}
+		let y = u ?? o("ESCAPED_CHAR");
+		if (y) {
+			$(y);
+			continue;
+		}
+		if (o("OPEN")) {
+			let m = A(), S = o("NAME"), k = o("REGEX");
+			!S && !k && (k = o("ASTERISK"));
+			let E = A();
+			p("CLOSE");
+			let be = h();
+			X(m, S, k, E, be);
+			continue;
+		}
+		M(), p("END");
+	}
+	return c;
+}
+a(F, "parse");
+function x(e) {
+	return e.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1");
+}
+a(x, "escapeString");
+function B(e) {
+	return e && e.ignoreCase ? "ui" : "u";
+}
+a(B, "flags");
+function q(e, t, r) {
+	return W(F(e, r), t, r);
+}
+a(q, "stringToRegexp");
+function T(e) {
+	switch (e) {
+		case 0: return "*";
+		case 1: return "?";
+		case 2: return "+";
+		case 3: return "";
+	}
+}
+a(T, "modifierToString");
+function W(e, t, r = {}) {
+	r.delimiter ??= "/#?", r.prefixes ??= "./", r.sensitive ??= !1, r.strict ??= !1, r.end ??= !0, r.start ??= !0, r.endsWith = "";
+	let n = r.start ? "^" : "";
+	for (let s of e) {
+		if (s.type === 3) {
+			s.modifier === 3 ? n += x(s.value) : n += `(?:${x(s.value)})${T(s.modifier)}`;
+			continue;
+		}
+		t && t.push(s.name);
+		let i = `[^${x(r.delimiter)}]+?`, o = s.value;
+		if (s.type === 1 ? o = i : s.type === 0 && (o = v), !s.prefix.length && !s.suffix.length) {
+			s.modifier === 3 || s.modifier === 1 ? n += `(${o})${T(s.modifier)}` : n += `((?:${o})${T(s.modifier)})`;
+			continue;
+		}
+		if (s.modifier === 3 || s.modifier === 1) {
+			n += `(?:${x(s.prefix)}(${o})${x(s.suffix)})`, n += T(s.modifier);
+			continue;
+		}
+		n += `(?:${x(s.prefix)}`, n += `((?:${o})(?:`, n += x(s.suffix), n += x(s.prefix), n += `(?:${o}))*)${x(s.suffix)})`, s.modifier === 0 && (n += "?");
+	}
+	let c = `[${x(r.endsWith)}]|$`, l = `[${x(r.delimiter)}]`;
+	if (r.end) return r.strict || (n += `${l}?`), r.endsWith.length ? n += `(?=${c})` : n += "$", new RegExp(n, B(r));
+	r.strict || (n += `(?:${l}(?=${c}))?`);
+	let f = !1;
+	if (e.length) {
+		let s = e[e.length - 1];
+		s.type === 3 && s.modifier === 3 && (f = r.delimiter.indexOf(s) > -1);
+	}
+	return f || (n += `(?=${l}|${c})`), new RegExp(n, B(r));
+}
+a(W, "partsToRegexp");
+var b = {
+	delimiter: "",
+	prefixes: "",
+	sensitive: !0,
+	strict: !0
+};
+var J = {
+	delimiter: ".",
+	prefixes: "",
+	sensitive: !0,
+	strict: !0
+};
+var Q = {
+	delimiter: "/",
+	prefixes: "/",
+	sensitive: !0,
+	strict: !0
+};
+function ee(e, t) {
+	return e.length ? e[0] === "/" ? !0 : !t || e.length < 2 ? !1 : (e[0] == "\\" || e[0] == "{") && e[1] == "/" : !1;
+}
+a(ee, "isAbsolutePathname");
+function te(e, t) {
+	return e.startsWith(t) ? e.substring(t.length, e.length) : e;
+}
+a(te, "maybeStripPrefix");
+function ke(e, t) {
+	return e.endsWith(t) ? e.substr(0, e.length - t.length) : e;
+}
+a(ke, "maybeStripSuffix");
+function _(e) {
+	return !e || e.length < 2 ? !1 : e[0] === "[" || (e[0] === "\\" || e[0] === "{") && e[1] === "[";
+}
+a(_, "treatAsIPv6Hostname");
+var re = [
+	"ftp",
+	"file",
+	"http",
+	"https",
+	"ws",
+	"wss"
+];
+function U(e) {
+	if (!e) return !0;
+	for (let t of re) if (e.test(t)) return !0;
+	return !1;
+}
+a(U, "isSpecialScheme");
+function ne(e, t) {
+	if (e = te(e, "#"), t || e === "") return e;
+	let r = new URL("https://example.com");
+	return r.hash = e, r.hash ? r.hash.substring(1, r.hash.length) : "";
+}
+a(ne, "canonicalizeHash");
+function se(e, t) {
+	if (e = te(e, "?"), t || e === "") return e;
+	let r = new URL("https://example.com");
+	return r.search = e, r.search ? r.search.substring(1, r.search.length) : "";
+}
+a(se, "canonicalizeSearch");
+function ie(e, t) {
+	return t || e === "" ? e : _(e) ? K(e) : j(e);
+}
+a(ie, "canonicalizeHostname");
+function ae(e, t) {
+	if (t || e === "") return e;
+	let r = new URL("https://example.com");
+	return r.password = e, r.password;
+}
+a(ae, "canonicalizePassword");
+function oe(e, t) {
+	if (t || e === "") return e;
+	let r = new URL("https://example.com");
+	return r.username = e, r.username;
+}
+a(oe, "canonicalizeUsername");
+function ce(e, t, r) {
+	if (r || e === "") return e;
+	if (t && !re.includes(t)) return new URL(`${t}:${e}`).pathname;
+	let n = e[0] == "/";
+	return e = new URL(n ? e : "/-" + e, "https://example.com").pathname, n || (e = e.substring(2, e.length)), e;
+}
+a(ce, "canonicalizePathname");
+function le(e, t, r) {
+	return z(t) === e && (e = ""), r || e === "" ? e : G(e);
+}
+a(le, "canonicalizePort");
+function fe(e, t) {
+	return e = ke(e, ":"), t || e === "" ? e : w(e);
+}
+a(fe, "canonicalizeProtocol");
+function z(e) {
+	switch (e) {
+		case "ws":
+		case "http": return "80";
+		case "wws":
+		case "https": return "443";
+		case "ftp": return "21";
+		default: return "";
+	}
+}
+a(z, "defaultPortForProtocol");
+function w(e) {
+	if (e === "") return e;
+	if (/^[-+.A-Za-z0-9]*$/.test(e)) return e.toLowerCase();
+	throw new TypeError(`Invalid protocol '${e}'.`);
+}
+a(w, "protocolEncodeCallback");
+function he(e) {
+	if (e === "") return e;
+	let t = new URL("https://example.com");
+	return t.username = e, t.username;
+}
+a(he, "usernameEncodeCallback");
+function ue(e) {
+	if (e === "") return e;
+	let t = new URL("https://example.com");
+	return t.password = e, t.password;
+}
+a(ue, "passwordEncodeCallback");
+function j(e) {
+	if (e === "") return e;
+	if (/[\t\n\r #%/:<>?@[\]^\\|]/g.test(e)) throw new TypeError(`Invalid hostname '${e}'`);
+	let t = new URL("https://example.com");
+	return t.hostname = e, t.hostname;
+}
+a(j, "hostnameEncodeCallback");
+function K(e) {
+	if (e === "") return e;
+	if (/[^0-9a-fA-F[\]:]/g.test(e)) throw new TypeError(`Invalid IPv6 hostname '${e}'`);
+	return e.toLowerCase();
+}
+a(K, "ipv6HostnameEncodeCallback");
+function G(e) {
+	if (e === "" || /^[0-9]*$/.test(e) && parseInt(e) <= 65535) return e;
+	throw new TypeError(`Invalid port '${e}'.`);
+}
+a(G, "portEncodeCallback");
+function de(e) {
+	if (e === "") return e;
+	let t = new URL("https://example.com");
+	return t.pathname = e[0] !== "/" ? "/-" + e : e, e[0] !== "/" ? t.pathname.substring(2, t.pathname.length) : t.pathname;
+}
+a(de, "standardURLPathnameEncodeCallback");
+function pe(e) {
+	return e === "" ? e : new URL(`data:${e}`).pathname;
+}
+a(pe, "pathURLPathnameEncodeCallback");
+function ge(e) {
+	if (e === "") return e;
+	let t = new URL("https://example.com");
+	return t.search = e, t.search.substring(1, t.search.length);
+}
+a(ge, "searchEncodeCallback");
+function me(e) {
+	if (e === "") return e;
+	let t = new URL("https://example.com");
+	return t.hash = e, t.hash.substring(1, t.hash.length);
+}
+a(me, "hashEncodeCallback");
+var C$1 = class {
+	#i;
+	#n = [];
+	#t = {};
+	#e = 0;
+	#s = 1;
+	#l = 0;
+	#o = 0;
+	#d = 0;
+	#p = 0;
+	#g = !1;
+	constructor(t) {
+		this.#i = t;
+	}
+	get result() {
+		return this.#t;
+	}
+	parse() {
+		for (this.#n = D(this.#i, !0); this.#e < this.#n.length; this.#e += this.#s) {
+			if (this.#s = 1, this.#n[this.#e].type === "END") {
+				if (this.#o === 0) {
+					this.#b(), this.#f() ? this.#r(9, 1) : this.#h() ? this.#r(8, 1) : this.#r(7, 0);
+					continue;
+				} else if (this.#o === 2) {
+					this.#u(5);
+					continue;
+				}
+				this.#r(10, 0);
+				break;
+			}
+			if (this.#d > 0) if (this.#A()) this.#d -= 1;
+			else continue;
+			if (this.#T()) {
+				this.#d += 1;
+				continue;
+			}
+			switch (this.#o) {
+				case 0:
+					this.#P() && this.#u(1);
+					break;
+				case 1:
+					if (this.#P()) {
+						this.#C();
+						let t = 7, r = 1;
+						this.#E() ? (t = 2, r = 3) : this.#g && (t = 2), this.#r(t, r);
+					}
+					break;
+				case 2:
+					this.#S() ? this.#u(3) : (this.#x() || this.#h() || this.#f()) && this.#u(5);
+					break;
+				case 3:
+					this.#O() ? this.#r(4, 1) : this.#S() && this.#r(5, 1);
+					break;
+				case 4:
+					this.#S() && this.#r(5, 1);
+					break;
+				case 5:
+					this.#y() ? this.#p += 1 : this.#w() && (this.#p -= 1), this.#k() && !this.#p ? this.#r(6, 1) : this.#x() ? this.#r(7, 0) : this.#h() ? this.#r(8, 1) : this.#f() && this.#r(9, 1);
+					break;
+				case 6:
+					this.#x() ? this.#r(7, 0) : this.#h() ? this.#r(8, 1) : this.#f() && this.#r(9, 1);
+					break;
+				case 7:
+					this.#h() ? this.#r(8, 1) : this.#f() && this.#r(9, 1);
+					break;
+				case 8:
+					this.#f() && this.#r(9, 1);
+					break;
+				case 9: break;
+				case 10: break;
+			}
+		}
+		this.#t.hostname !== void 0 && this.#t.port === void 0 && (this.#t.port = "");
+	}
+	#r(t, r) {
+		switch (this.#o) {
+			case 0: break;
+			case 1:
+				this.#t.protocol = this.#c();
+				break;
+			case 2: break;
+			case 3:
+				this.#t.username = this.#c();
+				break;
+			case 4:
+				this.#t.password = this.#c();
+				break;
+			case 5:
+				this.#t.hostname = this.#c();
+				break;
+			case 6:
+				this.#t.port = this.#c();
+				break;
+			case 7:
+				this.#t.pathname = this.#c();
+				break;
+			case 8:
+				this.#t.search = this.#c();
+				break;
+			case 9:
+				this.#t.hash = this.#c();
+				break;
+			case 10: break;
+		}
+		this.#o !== 0 && t !== 10 && ([
+			1,
+			2,
+			3,
+			4
+		].includes(this.#o) && [
+			6,
+			7,
+			8,
+			9
+		].includes(t) && (this.#t.hostname ??= ""), [
+			1,
+			2,
+			3,
+			4,
+			5,
+			6
+		].includes(this.#o) && [8, 9].includes(t) && (this.#t.pathname ??= this.#g ? "/" : ""), [
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7
+		].includes(this.#o) && t === 9 && (this.#t.search ??= "")), this.#R(t, r);
+	}
+	#R(t, r) {
+		this.#o = t, this.#l = this.#e + r, this.#e += r, this.#s = 0;
+	}
+	#b() {
+		this.#e = this.#l, this.#s = 0;
+	}
+	#u(t) {
+		this.#b(), this.#o = t;
+	}
+	#m(t) {
+		return t < 0 && (t = this.#n.length - t), t < this.#n.length ? this.#n[t] : this.#n[this.#n.length - 1];
+	}
+	#a(t, r) {
+		let n = this.#m(t);
+		return n.value === r && (n.type === "CHAR" || n.type === "ESCAPED_CHAR" || n.type === "INVALID_CHAR");
+	}
+	#P() {
+		return this.#a(this.#e, ":");
+	}
+	#E() {
+		return this.#a(this.#e + 1, "/") && this.#a(this.#e + 2, "/");
+	}
+	#S() {
+		return this.#a(this.#e, "@");
+	}
+	#O() {
+		return this.#a(this.#e, ":");
+	}
+	#k() {
+		return this.#a(this.#e, ":");
+	}
+	#x() {
+		return this.#a(this.#e, "/");
+	}
+	#h() {
+		if (this.#a(this.#e, "?")) return !0;
+		if (this.#n[this.#e].value !== "?") return !1;
+		let t = this.#m(this.#e - 1);
+		return t.type !== "NAME" && t.type !== "REGEX" && t.type !== "CLOSE" && t.type !== "ASTERISK";
+	}
+	#f() {
+		return this.#a(this.#e, "#");
+	}
+	#T() {
+		return this.#n[this.#e].type == "OPEN";
+	}
+	#A() {
+		return this.#n[this.#e].type == "CLOSE";
+	}
+	#y() {
+		return this.#a(this.#e, "[");
+	}
+	#w() {
+		return this.#a(this.#e, "]");
+	}
+	#c() {
+		let t = this.#n[this.#e], r = this.#m(this.#l).index;
+		return this.#i.substring(r, t.index);
+	}
+	#C() {
+		let t = {};
+		Object.assign(t, b), t.encodePart = w;
+		let r = q(this.#c(), void 0, t);
+		this.#g = U(r);
+	}
+};
+a(C$1, "Parser");
+var V = [
+	"protocol",
+	"username",
+	"password",
+	"hostname",
+	"port",
+	"pathname",
+	"search",
+	"hash"
+];
+var O = "*";
+function Se(e, t) {
+	if (typeof e != "string") throw new TypeError("parameter 1 is not of type 'string'.");
+	let r = new URL(e, t);
+	return {
+		protocol: r.protocol.substring(0, r.protocol.length - 1),
+		username: r.username,
+		password: r.password,
+		hostname: r.hostname,
+		port: r.port,
+		pathname: r.pathname,
+		search: r.search !== "" ? r.search.substring(1, r.search.length) : void 0,
+		hash: r.hash !== "" ? r.hash.substring(1, r.hash.length) : void 0
+	};
+}
+a(Se, "extractValues");
+function R(e, t) {
+	return t ? I(e) : e;
+}
+a(R, "processBaseURLString");
+function L(e, t, r) {
+	let n;
+	if (typeof t.baseURL == "string") try {
+		n = new URL(t.baseURL), t.protocol === void 0 && (e.protocol = R(n.protocol.substring(0, n.protocol.length - 1), r)), !r && t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.username === void 0 && (e.username = R(n.username, r)), !r && t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.username === void 0 && t.password === void 0 && (e.password = R(n.password, r)), t.protocol === void 0 && t.hostname === void 0 && (e.hostname = R(n.hostname, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && (e.port = R(n.port, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && (e.pathname = R(n.pathname, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && t.search === void 0 && (e.search = R(n.search.substring(1, n.search.length), r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && t.search === void 0 && t.hash === void 0 && (e.hash = R(n.hash.substring(1, n.hash.length), r));
+	} catch {
+		throw new TypeError(`invalid baseURL '${t.baseURL}'.`);
+	}
+	if (typeof t.protocol == "string" && (e.protocol = fe(t.protocol, r)), typeof t.username == "string" && (e.username = oe(t.username, r)), typeof t.password == "string" && (e.password = ae(t.password, r)), typeof t.hostname == "string" && (e.hostname = ie(t.hostname, r)), typeof t.port == "string" && (e.port = le(t.port, e.protocol, r)), typeof t.pathname == "string") {
+		if (e.pathname = t.pathname, n && !ee(e.pathname, r)) {
+			let c = n.pathname.lastIndexOf("/");
+			c >= 0 && (e.pathname = R(n.pathname.substring(0, c + 1), r) + e.pathname);
+		}
+		e.pathname = ce(e.pathname, e.protocol, r);
+	}
+	return typeof t.search == "string" && (e.search = se(t.search, r)), typeof t.hash == "string" && (e.hash = ne(t.hash, r)), e;
+}
+a(L, "applyInit");
+function I(e) {
+	return e.replace(/([+*?:{}()\\])/g, "\\$1");
+}
+a(I, "escapePatternString");
+function Te(e) {
+	return e.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1");
+}
+a(Te, "escapeRegexpString");
+function Ae(e, t) {
+	t.delimiter ??= "/#?", t.prefixes ??= "./", t.sensitive ??= !1, t.strict ??= !1, t.end ??= !0, t.start ??= !0, t.endsWith = "";
+	let r = ".*", n = `[^${Te(t.delimiter)}]+?`, c = /[$_\u200C\u200D\p{ID_Continue}]/u, l = "";
+	for (let f = 0; f < e.length; ++f) {
+		let s = e[f];
+		if (s.type === 3) {
+			if (s.modifier === 3) {
+				l += I(s.value);
+				continue;
+			}
+			l += `{${I(s.value)}}${T(s.modifier)}`;
+			continue;
+		}
+		let i = s.hasCustomName(), o = !!s.suffix.length || !!s.prefix.length && (s.prefix.length !== 1 || !t.prefixes.includes(s.prefix)), h = f > 0 ? e[f - 1] : null, p = f < e.length - 1 ? e[f + 1] : null;
+		if (!o && i && s.type === 1 && s.modifier === 3 && p && !p.prefix.length && !p.suffix.length) if (p.type === 3) {
+			let A = p.value.length > 0 ? p.value[0] : "";
+			o = c.test(A);
+		} else o = !p.hasCustomName();
+		if (!o && !s.prefix.length && h && h.type === 3) {
+			let A = h.value[h.value.length - 1];
+			o = t.prefixes.includes(A);
+		}
+		o && (l += "{"), l += I(s.prefix), i && (l += `:${s.name}`), s.type === 2 ? l += `(${s.value})` : s.type === 1 ? i || (l += `(${n})`) : s.type === 0 && (!i && (!h || h.type === 3 || h.modifier !== 3 || o || s.prefix !== "") ? l += "*" : l += `(${r})`), s.type === 1 && i && s.suffix.length && c.test(s.suffix[0]) && (l += "\\"), l += I(s.suffix), o && (l += "}"), s.modifier !== 3 && (l += T(s.modifier));
+	}
+	return l;
+}
+a(Ae, "partsToPattern");
+var Y = class {
+	#i;
+	#n = {};
+	#t = {};
+	#e = {};
+	#s = {};
+	#l = !1;
+	constructor(t = {}, r, n) {
+		try {
+			let c;
+			if (typeof r == "string" ? c = r : n = r, typeof t == "string") {
+				let i = new C$1(t);
+				if (i.parse(), t = i.result, c === void 0 && typeof t.protocol != "string") throw new TypeError("A base URL must be provided for a relative constructor string.");
+				t.baseURL = c;
+			} else {
+				if (!t || typeof t != "object") throw new TypeError("parameter 1 is not of type 'string' and cannot convert to dictionary.");
+				if (c) throw new TypeError("parameter 1 is not of type 'string'.");
+			}
+			typeof n > "u" && (n = { ignoreCase: !1 });
+			let l = { ignoreCase: n.ignoreCase === !0 }, f = {
+				pathname: O,
+				protocol: O,
+				username: O,
+				password: O,
+				hostname: O,
+				port: O,
+				search: O,
+				hash: O
+			};
+			this.#i = L(f, t, !0), z(this.#i.protocol) === this.#i.port && (this.#i.port = "");
+			let s;
+			for (s of V) {
+				if (!(s in this.#i)) continue;
+				let i = {}, o = this.#i[s];
+				switch (this.#t[s] = [], s) {
+					case "protocol":
+						Object.assign(i, b), i.encodePart = w;
+						break;
+					case "username":
+						Object.assign(i, b), i.encodePart = he;
+						break;
+					case "password":
+						Object.assign(i, b), i.encodePart = ue;
+						break;
+					case "hostname":
+						Object.assign(i, J), _(o) ? i.encodePart = K : i.encodePart = j;
+						break;
+					case "port":
+						Object.assign(i, b), i.encodePart = G;
+						break;
+					case "pathname":
+						U(this.#n.protocol) ? (Object.assign(i, Q, l), i.encodePart = de) : (Object.assign(i, b, l), i.encodePart = pe);
+						break;
+					case "search":
+						Object.assign(i, b, l), i.encodePart = ge;
+						break;
+					case "hash":
+						Object.assign(i, b, l), i.encodePart = me;
+						break;
+				}
+				try {
+					this.#s[s] = F(o, i), this.#n[s] = W(this.#s[s], this.#t[s], i), this.#e[s] = Ae(this.#s[s], i), this.#l = this.#l || this.#s[s].some((h) => h.type === 2);
+				} catch {
+					throw new TypeError(`invalid ${s} pattern '${this.#i[s]}'.`);
+				}
+			}
+		} catch (c) {
+			throw new TypeError(`Failed to construct 'URLPattern': ${c.message}`);
+		}
+	}
+	get [Symbol.toStringTag]() {
+		return "URLPattern";
+	}
+	test(t = {}, r) {
+		let n = {
+			pathname: "",
+			protocol: "",
+			username: "",
+			password: "",
+			hostname: "",
+			port: "",
+			search: "",
+			hash: ""
+		};
+		if (typeof t != "string" && r) throw new TypeError("parameter 1 is not of type 'string'.");
+		if (typeof t > "u") return !1;
+		try {
+			typeof t == "object" ? n = L(n, t, !1) : n = L(n, Se(t, r), !1);
+		} catch {
+			return !1;
+		}
+		let c;
+		for (c of V) if (!this.#n[c].exec(n[c])) return !1;
+		return !0;
+	}
+	exec(t = {}, r) {
+		let n = {
+			pathname: "",
+			protocol: "",
+			username: "",
+			password: "",
+			hostname: "",
+			port: "",
+			search: "",
+			hash: ""
+		};
+		if (typeof t != "string" && r) throw new TypeError("parameter 1 is not of type 'string'.");
+		if (typeof t > "u") return;
+		try {
+			typeof t == "object" ? n = L(n, t, !1) : n = L(n, Se(t, r), !1);
+		} catch {
+			return null;
+		}
+		let c = {};
+		r ? c.inputs = [t, r] : c.inputs = [t];
+		let l;
+		for (l of V) {
+			let f = this.#n[l].exec(n[l]);
+			if (!f) return null;
+			let s = {};
+			for (let [i, o] of this.#t[l].entries()) if (typeof o == "string" || typeof o == "number") s[o] = f[i + 1];
+			c[l] = {
+				input: n[l] ?? "",
+				groups: s
+			};
+		}
+		return c;
+	}
+	static compareComponent(t, r, n) {
+		let c = a((i, o) => {
+			for (let h of [
+				"type",
+				"modifier",
+				"prefix",
+				"value",
+				"suffix"
+			]) {
+				if (i[h] < o[h]) return -1;
+				if (i[h] === o[h]) continue;
+				return 1;
+			}
+			return 0;
+		}, "comparePart"), l = new P(3, "", "", "", "", 3), f = new P(0, "", "", "", "", 3), s = a((i, o) => {
+			let h = 0;
+			for (; h < Math.min(i.length, o.length); ++h) {
+				let p = c(i[h], o[h]);
+				if (p) return p;
+			}
+			return i.length === o.length ? 0 : c(i[h] ?? l, o[h] ?? l);
+		}, "comparePartList");
+		return !r.#e[t] && !n.#e[t] ? 0 : r.#e[t] && !n.#e[t] ? s(r.#s[t], [f]) : !r.#e[t] && n.#e[t] ? s([f], n.#s[t]) : s(r.#s[t], n.#s[t]);
+	}
+	get protocol() {
+		return this.#e.protocol;
+	}
+	get username() {
+		return this.#e.username;
+	}
+	get password() {
+		return this.#e.password;
+	}
+	get hostname() {
+		return this.#e.hostname;
+	}
+	get port() {
+		return this.#e.port;
+	}
+	get pathname() {
+		return this.#e.pathname;
+	}
+	get search() {
+		return this.#e.search;
+	}
+	get hash() {
+		return this.#e.hash;
+	}
+	get hasRegExpGroups() {
+		return this.#l;
+	}
+};
+a(Y, "URLPattern");
+//#endregion
+//#region ../../node_modules/.bun/urlpattern-polyfill@10.1.0/node_modules/urlpattern-polyfill/index.js
+if (!globalThis.URLPattern) globalThis.URLPattern = Y;
+//#endregion
+//#region utils/sleep.ts
+function sleep(time) {
+	return new Promise((resolve) => setTimeout(resolve, time));
+}
+//#endregion
+//#region client/ProgressManager.ts
+var ProgressManager = class {
+	state = new Subject(100);
+	unsubscribe;
+	timer;
+	tick = 0;
+	isTicking = false;
+	constructor(subject) {
+		this.unsubscribe = subject.subscribe((state) => {
+			if (state) this.start();
+			else this.end();
+		});
+	}
+	getNextIncrement() {
+		const current = this.state.getValue();
+		if (current === 100) return Math.ceil(Math.random() * 10);
+		if (current <= 20) {
+			if (Math.ceil(Math.random() * 100) > 80) return current;
+			return current + Math.ceil(Math.random() * 5) + 1;
+		}
+		if (current <= 50) {
+			if (Math.ceil(Math.random() * 100) > 50) return current;
+			return Math.min(current + Math.ceil(Math.random() * 10), 70);
+		}
+		if (current <= 70) {
+			if (Math.ceil(Math.random() * 100) > 60) return current;
+			return Math.min(current + Math.ceil(Math.random() * 3), 80);
+		}
+		if (current <= 80) return Math.min(current + Math.ceil(Math.random() * 1), 90);
+		if (current <= 90) {
+			const x = Math.ceil(Math.random() * 100) > 50 ? 0 : 1;
+			return Math.min(current + x, 94);
+		}
+		if (current <= 94) {
+			const x = Math.ceil(Math.random() * 100) > 20 ? 0 : 1;
+			return Math.min(current + x, 99);
+		}
+	}
+	getNextInterval() {
+		if (this.tick === 0) {
+			this.tick = 1;
+			return 200;
+		}
+		const current = this.state.getValue();
+		if (current >= 88) return 400;
+		if (current >= 94) return 1e3;
+		if (current >= 98) return 2e3;
+		return 100;
+	}
+	async nextTick() {
+		if (!this.isTicking) return;
+		await sleep(this.getNextInterval());
+		if (!this.isTicking) return;
+		const increment = this.getNextIncrement();
+		this.state.next(Math.min(increment, 96));
+		await this.nextTick();
+	}
+	start() {
+		this.isTicking = true;
+		this.nextTick();
+	}
+	end() {
+		this.state.next(99);
+		this.isTicking = false;
+		this.tick = 0;
+		setTimeout(() => {
+			this.state.next(100);
+		}, 200);
+	}
+	destroy() {
+		this.end();
+		this.unsubscribe();
+	}
+};
+//#endregion
+//#region client/useLocation.ts
+function useLocation() {
+	const ctx = useContext(RouteStateContext);
+	if (!ctx) throw new Error("Router context not found");
+	const { hash, pathname, search, state, locale } = ctx;
+	return {
+		hash,
+		key: pathname,
+		pathname,
+		search,
+		state,
+		locale
+	};
+}
+//#endregion
+//#region client/ServerDataProvider.tsx
+var ServerDataContext = createContext({});
+var ServerDataProvider = (props) => {
+	let _value = props.value;
+	if (props.value) _value = props.value;
+	else _value = window.__GEMI_DATA__;
+	return /* @__PURE__ */ jsx(ServerDataContext.Provider, {
+		value: _value,
+		children: props.children
+	});
+};
+//#endregion
+//#region client/I18nContext.tsx
+var I18nContext = createContext({});
+var I18nProvider = (props) => {
+	const { i18n } = useContext(ServerDataContext);
+	const [currentLocale, setCurrentLocale] = useState(i18n.currentLocale);
+	const dictionary = useRef((() => {
+		const dictionary = /* @__PURE__ */ new Map();
+		for (const [locale, value] of Object.entries(i18n?.dictionary ?? {})) {
+			const components = /* @__PURE__ */ new Map();
+			for (const [component, translations] of Object.entries(value)) components.set(component, translations);
+			dictionary.set(locale, components);
+		}
+		return dictionary;
+	})());
+	function updateDictionary(translations = {}, locale) {
+		for (const [locale, value] of Object.entries(translations)) {
+			if (!dictionary.current.has(locale)) dictionary.current.set(locale, /* @__PURE__ */ new Map());
+			const scopes = dictionary.current.get(locale);
+			for (const [scope, translations] of Object.entries(value)) {
+				if (!scopes.has(scope)) scopes.set(scope, {});
+				scopes.set(scope, translations);
+			}
+		}
+		changeLocale(locale);
+	}
+	const changeLocale = (locale) => {
+		if (dictionary.current.has(locale)) setCurrentLocale(locale);
+	};
+	const getTranslations = (locale) => {
+		return (component) => {
+			return dictionary.current.get(locale).get(component);
+		};
+	};
+	const fetchTranslations = async (pathname, locale, signal) => {
+		if (Object.keys(i18n).length === 0) return;
+		updateDictionary(await (await fetch(`/api/__gemi__/services/i18n/translations/${locale || currentLocale}${pathname === "/" ? "" : pathname}`, { signal })).json());
+	};
+	return /* @__PURE__ */ jsx(I18nContext.Provider, {
+		value: {
+			getComponentTranslations: getTranslations(currentLocale),
+			locale: currentLocale,
+			changeLocale,
+			updateDictionary,
+			fetchTranslations,
+			supportedLocales: i18n.supportedLocales,
+			defaultLocale: i18n.defaultLocale
+		},
+		children: props.children
+	});
+};
+//#endregion
+//#region client/useNavigate.ts
+function useNavigate() {
+	const { history, setNavigationAbortController } = useContext(ClientRouterContext);
+	const { defaultLocale } = useContext(I18nContext);
+	const location = useLocation();
+	function action(pushOrReplace) {
+		return async (path, ...args) => {
+			const navigationAbortController = new AbortController();
+			if (setNavigationAbortController) setNavigationAbortController(navigationAbortController);
+			const [options = {}] = args;
+			const { search = {}, params = {}, shallow, locale, hash } = {
+				params: {},
+				shallow: false,
+				locale: null,
+				hash: "",
+				...options
+			};
+			const urlSearchParams = new URLSearchParams(search);
+			let localeSegment = location.locale;
+			if (locale) localeSegment = locale;
+			if (localeSegment === defaultLocale) localeSegment = "";
+			const routePath = applyParams(path, params);
+			const finalPath = [[`${localeSegment ? `/${localeSegment}` : ""}${routePath === "/" ? "" : routePath}`, urlSearchParams.toString()].filter((s) => s.length > 0).join("?"), hash].filter(Boolean).join("");
+			if (shallow) {
+				history?.[pushOrReplace](finalPath, { shallow });
+				return;
+			}
+			history?.[pushOrReplace](finalPath === "" ? "/" : finalPath);
+		};
+	}
+	return {
+		push: action("push"),
+		replace: action("replace")
+	};
+}
+//#endregion
+//#region client/useSearchParams.ts
+var SearchParams = class {
+	searchParams;
+	callback;
+	constructor(searchParams, callback) {
+		this.searchParams = searchParams;
+		this.callback = callback;
+	}
+	get(key) {
+		return this.searchParams.get(key);
+	}
+	set(key, value) {
+		let entries = {};
+		if (typeof key === "string") {
+			let _value = value;
+			if (typeof value === "function") _value = value(this.get(key) ?? "");
+			entries[key] = _value;
+		} else entries = key ?? {};
+		for (const [key, value] of Object.entries(entries)) {
+			let _value = value;
+			if (typeof value === "function") _value = value(this.get(key) ?? "");
+			this.searchParams.set(key, _value);
+		}
+		return this;
+	}
+	append(key, value) {
+		this.searchParams.append(key, value);
+		return this;
+	}
+	sort() {
+		this.searchParams.sort();
+		return this;
+	}
+	clear() {
+		this.searchParams = new URLSearchParams();
+		return this;
+	}
+	delete(key) {
+		const keys = Array.isArray(key) ? key : [key];
+		for (const key of keys) this.searchParams.delete(key);
+		return this;
+	}
+	toJSON() {
+		const map = /* @__PURE__ */ new Map();
+		for (const [key, value] of this.searchParams) if (map.has(key)) {
+			const currentValue = map.get(key);
+			if (Array.isArray(currentValue)) {
+				currentValue.push(value);
+				map.set(key, currentValue);
+			} else map.set(key, [currentValue, value]);
+		} else map.set(key, value);
+		return Object.fromEntries(map.entries());
+	}
+	toString() {
+		return this.searchParams.toString();
+	}
+	push(mode = "soft") {
+		this.callback(this.toJSON(), mode === "soft");
+	}
+};
+function useSearchParams() {
+	const { push } = useNavigate();
+	const { search, pathname } = useContext(RouteStateContext);
+	const params = useParams();
+	const callback = (search, shallow) => {
+		push(pathname, {
+			params,
+			search,
+			shallow
+		});
+	};
+	return new SearchParams(new URLSearchParams(search), callback);
+}
+//#endregion
+//#region client/useRoute.ts
+function useRoute() {
+	const { pathname: _pathname } = useContext(RouteStateContext);
+	return {
+		pathname: _pathname,
+		startsWith: (pathname) => {
+			return _pathname.startsWith(pathname);
+		}
+	};
+}
+//#endregion
+//#region client/HttpReload.tsx
+var HttpReload = () => {
+	const { replace } = useNavigate();
+	useSearchParams();
+	const { pathname } = useRoute();
+	useParams();
+	const [reloading, setReloading] = useState(false);
+	const handleReload = () => {
+		if (typeof document !== "undefined") document.querySelectorAll("vite-error-overlay").forEach((el) => {
+			if (typeof el.close === "function") el.close();
+			else el.remove();
+		});
+		setReloading(true);
+	};
+	useEffect(() => {
+		if (import.meta.hot) import.meta.hot.on("http-reload", handleReload);
+		return () => {
+			if (import.meta.hot) import.meta.hot.off("http-reload", handleReload);
+		};
+	}, [handleReload]);
+	if (!reloading || typeof document === "undefined") return null;
+	return createPortal(/* @__PURE__ */ jsx("div", {
+		className: "fixed z-[1000] bottom-0 right-0 p-2",
+		children: /* @__PURE__ */ jsx("div", {
+			className: "p-2 bg-white text-black rounded-md shadow-md",
+			children: "..."
+		})
+	}), document.body);
+};
+//#endregion
+//#region client/PrefetchCache.ts
+/**
+* How long a prefetched payload stays usable. Long enough to cover the gap
+* between hovering a link and clicking it, short enough that a navigation is
+* not served a snapshot the visitor would notice as out of date.
+*
+* A payload cached here is committed wholesale on navigation — including into
+* the query cache via `hydrate` — so anything that invalidates page data has to
+* `clear()` this too. `useMutation` does exactly that on every successful
+* write; locale needs no such call, since the locale segment is part of the key.
+*/
+var PREFETCH_TTL = 1e4;
+/**
+* Payloads fetched ahead of a navigation, keyed by the `.json` URL that
+* navigation would request. Entries are handed over once — a navigation that
+* consumes one becomes the live route data, so keeping a copy around would only
+* let a later visit render from a stale snapshot.
+*/
+var PrefetchCache = class {
+	entries = /* @__PURE__ */ new Map();
+	isFresh(entry) {
+		return Date.now() - entry.createdAt < PREFETCH_TTL;
+	}
+	/** Drops what has expired, then the oldest of whatever is still over budget. */
+	evict() {
+		for (const [url, entry] of this.entries) if (!this.isFresh(entry)) this.entries.delete(url);
+		while (this.entries.size >= 12) {
+			const oldest = this.entries.keys().next().value;
+			if (oldest === void 0) return;
+			this.entries.delete(oldest);
+		}
+	}
+	/**
+	* Runs `load` unless the same URL is already in flight or freshly cached, so
+	* a link hovered repeatedly — or a screenful of eagerly prefetched links
+	* pointing at one route — costs a single request.
+	*/
+	prime(url, load) {
+		const existing = this.entries.get(url);
+		if (existing && this.isFresh(existing)) return existing.promise;
+		this.evict();
+		const entry = {
+			createdAt: Date.now(),
+			promise: null
+		};
+		entry.promise = load().catch(() => null).then((payload) => {
+			if (payload == null && this.entries.get(url) === entry) this.entries.delete(url);
+			return payload;
+		});
+		this.entries.set(url, entry);
+		return entry.promise;
+	}
+	/**
+	* Hands the payload for `url` to a navigation, if one was prefetched and is
+	* still fresh. Resolves to `null` when the prefetch failed, which callers
+	* must treat as a miss.
+	*/
+	take(url) {
+		const entry = this.entries.get(url);
+		if (!entry) return null;
+		this.entries.delete(url);
+		return this.isFresh(entry) ? entry.promise : null;
+	}
+	/**
+	* Drops everything, for when the data behind these payloads may have moved
+	* on. In-flight loads still settle; their entries are simply gone by then.
+	*/
+	clear() {
+		this.entries.clear();
+	}
+	/** Retained entries, fresh or not. Exposed for tests. */
+	get size() {
+		return this.entries.size;
+	}
+};
+//#endregion
+//#region client/helpers/routeDataUrl.ts
+/**
+* The `.json` URL a route's page data is served from.
+*
+* Prefetching and navigation have to agree on this string exactly — the
+* prefetch cache is keyed by it, and any disagreement silently turns every
+* prefetch into a wasted request plus a full fetch on click.
+*/
+function routeDataUrl(options) {
+	const { pathname, search = "", localeSegment = "" } = options;
+	return `${localeSegment}${localeSegment.length > 0 && pathname === "/" ? "" : pathname}.json${search}`;
+}
+//#endregion
+//#region client/helpers/readRoutePayload.ts
+/**
+* Reads a navigation payload response (#290).
+*
+* The body is NDJSON: the first line is the envelope (route data, meta,
+* partial info, already-resolved `prefetchedData`), later lines are
+* `[path, variantKey, data]` query results streamed as they settle
+* server-side. The returned promise resolves with the envelope as soon as
+* its line arrives — the caller commits the navigation immediately — while
+* the remaining lines keep draining in the background into `onQueryPayload`,
+* whose `hydrate()` settles any segment that suspended on that variant.
+*
+* Tolerates two other body shapes so every producer keeps working: a plain
+* single-JSON body with no trailing newline (error-path responses, buffering
+* proxies) parses as the envelope at end-of-stream, and a `Response` without
+* a readable `body` (test doubles) falls back to `.json()`.
+*/
+async function readRoutePayload(response, onQueryPayload) {
+	const reader = response.body?.getReader?.();
+	if (!reader) try {
+		return await response.json();
+	} catch {
+		return null;
+	}
+	const decoder = new TextDecoder();
+	let buffer = "";
+	return await new Promise((resolve) => {
+		let envelopeResolved = false;
+		const emitEnvelope = (value) => {
+			if (envelopeResolved) return;
+			envelopeResolved = true;
+			resolve(value);
+		};
+		const handleLine = (line) => {
+			if (line.trim().length === 0) return;
+			let value;
+			try {
+				value = JSON.parse(line);
+			} catch (error) {
+				console.error("[gemi] Unparseable route payload line", error);
+				emitEnvelope(null);
+				return;
+			}
+			if (!envelopeResolved) {
+				emitEnvelope(value);
+				return;
+			}
+			if (Array.isArray(value) && value.length === 3) onQueryPayload?.(value);
+		};
+		(async () => {
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					let newline = buffer.indexOf("\n");
+					while (newline !== -1) {
+						const line = buffer.slice(0, newline);
+						buffer = buffer.slice(newline + 1);
+						handleLine(line);
+						newline = buffer.indexOf("\n");
+					}
+				}
+				buffer += decoder.decode();
+				handleLine(buffer);
+				emitEnvelope(null);
+			} catch (error) {
+				console.error("[gemi] Route payload stream failed", error);
+				emitEnvelope(null);
+			}
+		})();
+	});
+}
+/**
+* Reads the response to the very end and returns the envelope with every
+* streamed query result merged into its `prefetchedData` — the settled
+* aggregate a `<Link prefetch>` warms ahead of a click, equivalent to what
+* the old blocking payload contained. Buffering is the point here: a hover
+* prefetch has time, and the cache stores one complete payload.
+*/
+async function readSettledRoutePayload(response) {
+	if (typeof response.text !== "function") try {
+		return await response.json();
+	} catch {
+		return null;
+	}
+	let text;
+	try {
+		text = await response.text();
+	} catch {
+		return null;
+	}
+	const lines = text.split("\n").filter((line) => line.trim().length > 0);
+	if (lines.length === 0) return null;
+	let envelope;
+	try {
+		envelope = JSON.parse(lines[0]);
+	} catch {
+		return null;
+	}
+	for (const line of lines.slice(1)) {
+		let value;
+		try {
+			value = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (Array.isArray(value) && value.length === 3) {
+			const [path, variantKey, data] = value;
+			envelope.prefetchedData ??= {};
+			envelope.prefetchedData[path] ??= {};
+			envelope.prefetchedData[path][variantKey] = data;
+		}
+	}
+	return envelope;
+}
+//#endregion
+//#region i18n/dictionaryRegistry.ts
+/**
+* Parked on `globalThis` rather than in module scope, because this module gets
+* bundled more than once and the copies have to agree.
+*
+* gemi ships `gemi/client` from one Vite lib build and `gemi/dictionary` from a
+* separate Bun build, an SSR view graph externalizes some gemi subpaths and
+* bundles others, and a dictionary imported by both a view and a controller is
+* evaluated on both sides. Every one of those splits would otherwise produce a
+* second registry: views would register into one Map while the view router
+* preloaded and snapshotted from another, and the hydration payload would come
+* out empty. Module identity is not something this can depend on; a global key
+* is.
+*/
+var GLOBAL_KEY = "__GEMI_DICTIONARY_REGISTRY__";
+var state = globalThis[GLOBAL_KEY] ??= {
+	registry: /* @__PURE__ */ new Map(),
+	resolved: /* @__PURE__ */ new Map(),
+	inFlight: /* @__PURE__ */ new Map(),
+	degraded: /* @__PURE__ */ new Map(),
+	order: [],
+	warmed: /* @__PURE__ */ new Map(),
+	activeLocale: null
+};
+var { registry, resolved, inFlight, degraded, order, warmed } = state;
+function cacheKey(id, locale) {
+	return `${id}\0${locale}`;
+}
+function registerDictionary(entry) {
+	if (registry.has(entry.id)) return;
+	registry.set(entry.id, entry);
+	order.push(entry.id);
+}
+/** A marker for "everything registered so far", for `preloadDictionaries`. */
+function dictionaryRegistrationMark() {
+	return order.length;
+}
+function getResolved(id, locale) {
+	return resolved.get(id)?.get(locale);
+}
+function putResolved(id, locale, strings) {
+	let byLocale = resolved.get(id);
+	if (!byLocale) {
+		byLocale = /* @__PURE__ */ new Map();
+		resolved.set(id, byLocale);
+	}
+	byLocale.set(locale, strings);
+}
+/**
+* Load one dictionary's locale, de-duplicating concurrent callers. Returns the
+* strings directly (not a promise) when they are already resolved, so the hook
+* can take a synchronous path without a microtask hop.
+*/
+function loadDictionary(id, locale) {
+	const already = getResolved(id, locale);
+	if (already) return already;
+	const key = cacheKey(id, locale);
+	const pending = inFlight.get(key);
+	if (pending) return pending;
+	const entry = registry.get(id);
+	if (!entry) throw new Error(`Unknown dictionary "${id}". A dictionary must be created with defineDictionary() and its module must have been evaluated before it is read.`);
+	const result = entry.load(locale);
+	if (!(result instanceof Promise)) {
+		putResolved(id, locale, result);
+		return result;
+	}
+	const promise = result.then((strings) => {
+		putResolved(id, locale, strings);
+		inFlight.delete(key);
+		return strings;
+	}, (err) => {
+		inFlight.delete(key);
+		throw err;
+	});
+	inFlight.set(key, promise);
+	return promise;
+}
+/**
+* The same load, but as something safe to hand React's `use()`.
+*
+* A rejecting promise passed to `use()` rethrows during render, which unmounts
+* the whole route into its error boundary — or, before the shell is ready,
+* fails the server render outright. A missing locale chunk is a routine event
+* (a browser holding stale HTML after a rolling deploy requests a hashed
+* filename that no longer exists), and the deprecated `useTranslator` degraded
+* every i18n failure to rendering the raw key. This keeps that behaviour: the
+* returned promise resolves to no strings, and the per-key lookup in
+* `useDictionary` then logs and falls back to the key.
+*
+* The degraded promise is cached because `use()` requires a stable reference —
+* a fresh `.then()` per render would suspend forever. It is only consulted
+* after `getResolved` misses, so a later successful load supersedes it without
+* needing to be evicted.
+*/
+function loadDictionaryForRender(id, locale) {
+	const already = getResolved(id, locale);
+	if (already) return already;
+	const key = cacheKey(id, locale);
+	const cached = degraded.get(key);
+	if (cached) return cached;
+	const result = loadDictionary(id, locale);
+	if (!(result instanceof Promise)) return result;
+	const safe = result.then((strings) => strings, (err) => {
+		console.error(`Failed to load dictionary ${id} for locale ${locale}; rendering keys instead.`, err);
+		return EMPTY_STRINGS;
+	});
+	degraded.set(key, safe);
+	return safe;
+}
+var EMPTY_STRINGS = {};
+/**
+* Warm dictionaries for `locale`, so a subsequent render reads them
+* synchronously instead of suspending.
+*
+* With a `mark` — the value taken *before* importing a view module — only that
+* view's newly announced dictionaries are loaded. That is the client's use: it
+* knows exactly which chunk just arrived.
+*
+* Without one, it resumes from where this locale last got to. The server calls
+* it per request and has no mark to give (view modules were imported long
+* before the request arrived), so a plain scan from zero would walk every
+* dictionary in the app on every request — re-deriving the per-request cost this
+* whole change exists to remove, just with a smaller constant.
+*
+* An empty `locale` means the app configured none, and each dictionary is warmed
+* under its own source language — the same key `useDictionary` will ask for, so
+* the warmed entry is the one the render actually reads.
+*
+* Failures are swallowed: a dictionary that cannot load should surface at the
+* component that actually reads it, where the error names the key, rather than
+* take down an unrelated navigation.
+*/
+async function preloadDictionaries(locale, mark) {
+	const from = mark ?? warmed.get(locale) ?? 0;
+	const ids = order.slice(from);
+	if (ids.length === 0) return;
+	const settled = await Promise.all(ids.map(async (id) => {
+		try {
+			await loadDictionary(id, localeFor(id, locale));
+			return true;
+		} catch {
+			return false;
+		}
+	}));
+	if (mark === void 0) {
+		const firstFailure = settled.indexOf(false);
+		const reached = firstFailure === -1 ? ids.length : firstFailure;
+		warmed.set(locale, Math.max(warmed.get(locale) ?? 0, from + reached));
+	}
+}
+/**
+* Which locale a given dictionary should be warmed under.
+*
+* `useDictionary` falls back to the dictionary's own source language when the
+* app has no locale configured, so the preload has to make the same choice or
+* it caches under a key no render ever reads — warming `""`, then suspending on
+* `"en-US"` a moment later.
+*/
+function localeFor(id, locale) {
+	if (locale) return locale;
+	return registry.get(id)?.locales[0] ?? locale;
+}
+function setActiveLocale(locale) {
+	if (locale) state.activeLocale = locale;
+}
+function getActiveLocale() {
+	return state.activeLocale;
+}
+if (typeof window !== "undefined") {
+	const w = window;
+	const adopt = ([id, locale, strings]) => {
+		putResolved(id, locale, strings);
+	};
+	const buffered = Array.isArray(w.__GEMI_DICT__) ? w.__GEMI_DICT__ : [];
+	w.__GEMI_DICT__ = { push: adopt };
+	for (const entry of buffered) adopt(entry);
+}
+//#endregion
+//#region client/helpers/flattenComponentTree.ts
+function flattenComponentTree(componentTree) {
+	let out = [];
+	for (const [root, branches] of componentTree) out.push(root, ...flattenComponentTree(branches).flat());
+	return Array.from(new Set(out));
+}
+//#endregion
+//#region client/ComponentContext.tsx
+/**
+* Resolved view modules, not just their default exports. A route segment's
+* `Suspense` fallback and error UI come from optional named exports
+* (`Loading`, `Error`), and those have to be readable synchronously
+* while rendering — so every path that loads a view chunk records the module
+* here. Browsers dedupe the underlying dynamic import, so calling
+* `loadViewModule` repeatedly is free.
+*/
+var viewModules = /* @__PURE__ */ new Map();
+var viewModuleListeners = /* @__PURE__ */ new Set();
+function loadViewModule(name) {
+	const loader = typeof window !== "undefined" ? window.loaders?.[name] : void 0;
+	if (!loader) return Promise.resolve(null);
+	const mark = dictionaryRegistrationMark();
+	return Promise.resolve(loader()).then(async (mod) => {
+		const isNew = !viewModules.has(name);
+		viewModules.set(name, mod);
+		if (isNew) for (const listener of viewModuleListeners) listener();
+		await preloadDictionaries(currentLocale(), mark);
+		return mod;
+	});
+}
+function currentLocale() {
+	return getActiveLocale() ?? (typeof window !== "undefined" ? window.__GEMI_DATA__?.i18n?.currentLocale ?? "" : "");
+}
+function subscribeViewModules(listener) {
+	viewModuleListeners.add(listener);
+	return () => {
+		viewModuleListeners.delete(listener);
+	};
+}
+function getViewModule(name) {
+	return viewModules.get(name);
+}
+var viewImportMap = null;
+if (typeof window !== "undefined" && process.env.NODE_ENV !== "test") {
+	viewImportMap = {};
+	const { componentTree = [] } = window.__GEMI_DATA__ ?? {};
+	for (const viewName of flattenComponentTree(componentTree)) viewImportMap[viewName] = lazy(() => loadViewModule(viewName));
+}
+var ComponentsContext = createContext({
+	viewImportMap,
+	getViewModule
+});
+var ComponentsProvider = (props) => {
+	const { modules } = props;
+	const value = useMemo(() => ({
+		viewImportMap: props.viewImportMap ?? viewImportMap,
+		getViewModule: modules ? (name) => modules[name] ?? getViewModule(name) : getViewModule
+	}), [props.viewImportMap, modules]);
+	return /* @__PURE__ */ jsx(ComponentsContext.Provider, {
+		value,
+		children: props.children
+	});
+};
+//#endregion
+//#region client/ClientRouterContext.tsx
+var ClientRouterContext = createContext({});
+var ClientRouterProvider = (props) => {
+	const { children, pathname, currentPath, is404, is500, routeManifest, cssManifest, modulePreloadManifest, pageData, params, searchParams, breadcrumbs, urlLocaleSegment } = props;
+	const navigationAbortControllerRef = useRef(new AbortController());
+	const [isNavigatingSubject] = useState(() => {
+		return new Subject(false);
+	});
+	const { supportedLocales = [], locale } = useContext(I18nContext);
+	const [progressManager] = useState(new ProgressManager(isNavigatingSubject));
+	const [prefetchCache] = useState(() => new PrefetchCache());
+	const pageDataRef = useRef(structuredClone(pageData));
+	const scrollHistoryRef = useRef(/* @__PURE__ */ new Map());
+	/** Hrefs already announced; `null` until seeded from the shell's own hints. */
+	const preloadedModulesRef = useRef(null);
+	const breadcrumbsCache = useRef(new Map(Object.entries(breadcrumbs)));
+	const initalViewEntries = is404 ? ["404"] : is500 ? ["500"] : routeManifest[pathname] ?? ["404"];
+	const viewEntriesSubject = useRef(new Subject(initalViewEntries));
+	const [routerSubject] = useState(() => {
+		return new Subject({
+			views: initalViewEntries,
+			params,
+			search: searchParams,
+			state: {},
+			pathname,
+			hash: "",
+			action: null,
+			routePath: currentPath,
+			locale
+		});
+	});
+	const [history] = useState(() => {
+		let history = null;
+		if (typeof window !== "undefined") history = createBrowserHistory();
+		return history;
+	});
+	const findMatchingRouteFromParams = useMemo(() => (pathname) => {
+		let routePath = pathname.replace("/en-US", "").replace("/tr-TR", "");
+		routePath = routePath === "" ? "/" : routePath;
+		const candidates = [];
+		for (const route of Object.keys(routeManifest)) if (new Y({ pathname: route }).test({ pathname: routePath })) candidates.push(route);
+		return (candidates.sort((a, b) => {
+			return a.split("/").length + a.split(":").length - (b.split("/").length + b.split(":").length);
+		}) ?? [])[0];
+	}, [routeManifest]);
+	const getViewPathsFromPathname = useMemo(() => (pathname) => {
+		const route = findMatchingRouteFromParams(pathname);
+		return routeManifest[route] ?? [];
+	}, [findMatchingRouteFromParams, routeManifest]);
+	const getRoutePathnameFromHref = useMemo(() => (href) => {
+		return findMatchingRouteFromParams(href);
+	}, [findMatchingRouteFromParams]);
+	const getParams = useMemo(() => (pathname) => {
+		return new Y({ pathname: findMatchingRouteFromParams(pathname) }).exec({ pathname })?.pathname.groups ?? {};
+	}, [findMatchingRouteFromParams]);
+	useEffect(() => {
+		history?.listen(({ location, action }) => {
+			if (!window.scrollHistory) window.scrollHistory = /* @__PURE__ */ new Map();
+			const { hash, pathname, search } = routerSubject.getValue();
+			const key = [
+				pathname,
+				search,
+				hash
+			].join("");
+			window.scrollHistory.set(key, window.scrollY);
+			let _pathname = location.pathname;
+			let _locale = null;
+			for (const locale of supportedLocales) if (_pathname.startsWith(`/${locale}`)) {
+				_locale = locale;
+				_pathname = _pathname.replace(`/${locale}`, "");
+				break;
+			}
+			_pathname = _pathname === "" ? "/" : _pathname;
+			const routePath = getRoutePathnameFromHref(_pathname);
+			routerSubject.next({
+				views: getViewPathsFromPathname(_pathname),
+				params: getParams(_pathname),
+				search: location.search,
+				state: location.state,
+				pathname: _pathname,
+				action,
+				routePath,
+				hash: location.hash,
+				locale: _locale
+			});
+		});
+	}, [
+		supportedLocales,
+		history,
+		routerSubject,
+		getParams,
+		getRoutePathnameFromHref,
+		getViewPathsFromPathname
+	]);
+	const updatePageData = (newPageData, breadcrumbs) => {
+		const [key, value] = Object.entries(newPageData)[0];
+		if (!pageDataRef.current?.[key]) pageDataRef.current[key] = {};
+		for (const b in breadcrumbs) breadcrumbsCache.current.set(b, breadcrumbs[b]);
+		pageDataRef.current[key] = value;
+	};
+	const getPageData = (key, pathname) => {
+		return pageDataRef.current[pathname]?.[key];
+	};
+	const setNavigationAbortController = (controller) => {
+		navigationAbortControllerRef.current.abort();
+		navigationAbortControllerRef.current = controller;
+	};
+	const fetchRouteCSS = async (routePath) => {
+		const views = routeManifest[routePath];
+		if (!views) return;
+		const cssFiles = views.flatMap((view) => {
+			return cssManifest?.[view];
+		}).filter(Boolean).filter((file) => !document.getElementById(file));
+		if (cssFiles.length === 0) return;
+		async function fetchCSS(path) {
+			return {
+				content: (await fetch(`/${path}`)).text(),
+				id: path
+			};
+		}
+		const result = await Promise.all(cssFiles?.map((file) => fetchCSS(file)));
+		for (const { content, id } of result) {
+			const style = document.createElement("style");
+			style.id = id;
+			style.textContent = await content;
+			document.head.appendChild(style);
+		}
+	};
+	/**
+	* Announces every chunk a navigation to `routePath` will import.
+	*
+	* `loadViewModule` starts each view's own chunk, but a chunk's static
+	* imports are discoverable only once it has arrived and parsed — so a
+	* `layout -> view -> components` route still costs a round trip per level on
+	* every navigation, holding the transition open for exactly the interval the
+	* shell's head hints remove from the first load (#352). These are the same
+	* per-view lists the shell renders, shipped in the document payload.
+	*
+	* `modulepreload` rather than `import()`: it fills the HTTP cache without
+	* evaluating anything, so warming a link that is never clicked costs a
+	* download and no side effects.
+	*/
+	const preloadRouteModules = (routePath) => {
+		if (typeof document === "undefined") return;
+		if (!preloadedModulesRef.current) preloadedModulesRef.current = new Set(Array.from(document.querySelectorAll("link[rel=\"modulepreload\"]"), (link) => link.getAttribute("href") ?? ""));
+		const preloaded = preloadedModulesRef.current;
+		for (const view of routeManifest[routePath] ?? []) for (const href of modulePreloadManifest?.[view] ?? []) {
+			if (preloaded.has(href)) continue;
+			preloaded.add(href);
+			const link = document.createElement("link");
+			link.rel = "modulepreload";
+			link.href = href;
+			document.head.appendChild(link);
+		}
+	};
+	/**
+	* Warms everything a navigation to `target` would need: the route's page
+	* data, its stylesheets and its component chunks.
+	*
+	* The payload is requested *without* the partial-render header, because the
+	* route on screen when the link is prefetched is not necessarily the one it
+	* will be clicked from — a partial response computed against the wrong base
+	* has nothing sound to merge onto. A full payload is always safe to commit.
+	*
+	* It carries `Purpose: prefetch` so applications can tell speculative traffic
+	* from a real visit — a route's handlers run either way, and a `viewport`
+	* page multiplies that by the number of links on it.
+	*/
+	const prefetchRoute = async (target) => {
+		if (typeof window === "undefined") return;
+		const { pathname, search = "", localeSegment = "" } = target;
+		const routePath = getRoutePathnameFromHref(pathname);
+		if (!routePath) return;
+		const url = routeDataUrl({
+			pathname,
+			search,
+			localeSegment
+		});
+		fetchRouteCSS(routePath).catch(() => {});
+		preloadRouteModules(routePath);
+		for (const view of routeManifest[routePath] ?? []) loadViewModule(view);
+		await prefetchCache.prime(url, async () => {
+			const response = await fetch(url, { headers: { Purpose: "prefetch" } });
+			if (!response.ok) return null;
+			return await readSettledRoutePayload(response);
+		});
+	};
+	return /* @__PURE__ */ jsxs(ClientRouterContext.Provider, {
+		value: {
+			isNavigatingSubject,
+			prefetchRoute,
+			takePrefetched: (url) => prefetchCache.take(url),
+			clearPrefetchCache: () => prefetchCache.clear(),
+			getViewPathsFromPathname,
+			history,
+			getScrollPosition: (path) => {
+				return scrollHistoryRef.current.get(path) || 0;
+			},
+			viewEntriesSubject: viewEntriesSubject.current,
+			updatePageData,
+			getPageData,
+			getRoutePathnameFromHref,
+			setNavigationAbortController,
+			progressManager,
+			fetchRouteCSS,
+			preloadRouteModules,
+			breadcrumbsCache: breadcrumbsCache.current,
+			routerSubject,
+			urlLocaleSegment
+		},
+		children: [children, import.meta.hot && /* @__PURE__ */ jsx(HttpReload, {})]
+	});
+};
+//#endregion
+//#region client/RouteTransitionProvider.tsx
+var RouteTransitionContext = createContext({
+	isTransitioning: false,
+	targetPath: "",
+	currentPath: ""
+});
+var RouteTransitionProvider = (props) => {
+	const { isPending, isFetching, transitionPath } = props;
+	return /* @__PURE__ */ jsx(RouteTransitionContext.Provider, {
+		value: {
+			isTransitioning: isPending || isFetching,
+			targetPath: transitionPath[1],
+			currentPath: transitionPath[0] || ""
+		},
+		children: props.children
+	});
+};
+function useRouteTransition() {
+	const context = useContext(RouteTransitionContext);
+	if (!context) throw new Error("useRouteTransition must be used within a RouteTransitionProvider");
+	return context;
+}
+//#endregion
+//#region ../../node_modules/.bun/react-error-boundary@6.1.1+83d5fd7b249dbeef/node_modules/react-error-boundary/dist/react-error-boundary.js
+var h = createContext(null);
+var c = {
+	didCatch: !1,
+	error: null
+};
+var m = class extends Component {
+	constructor(e) {
+		super(e), this.resetErrorBoundary = this.resetErrorBoundary.bind(this), this.state = c;
+	}
+	static getDerivedStateFromError(e) {
+		return {
+			didCatch: !0,
+			error: e
+		};
+	}
+	resetErrorBoundary(...e) {
+		const { error: t } = this.state;
+		t !== null && (this.props.onReset?.({
+			args: e,
+			reason: "imperative-api"
+		}), this.setState(c));
+	}
+	componentDidCatch(e, t) {
+		this.props.onError?.(e, t);
+	}
+	componentDidUpdate(e, t) {
+		const { didCatch: o } = this.state, { resetKeys: s } = this.props;
+		o && t.error !== null && C(e.resetKeys, s) && (this.props.onReset?.({
+			next: s,
+			prev: e.resetKeys,
+			reason: "keys"
+		}), this.setState(c));
+	}
+	render() {
+		const { children: e, fallbackRender: t, FallbackComponent: o, fallback: s } = this.props, { didCatch: n, error: a } = this.state;
+		let i = e;
+		if (n) {
+			const u = {
+				error: a,
+				resetErrorBoundary: this.resetErrorBoundary
+			};
+			if (typeof t == "function") i = t(u);
+			else if (o) i = createElement(o, u);
+			else if (s !== void 0) i = s;
+			else throw a;
+		}
+		return createElement(h.Provider, { value: {
+			didCatch: n,
+			error: a,
+			resetErrorBoundary: this.resetErrorBoundary
+		} }, i);
+	}
+};
+function C(r = [], e = []) {
+	return r.length !== e.length || r.some((t, o) => !Object.is(t, e[o]));
+}
+//#endregion
+//#region client/WebsocketContext.tsx
+var WebSocketContext = createContext({});
+var WebSocketContextProvider = (props) => {
+	const wsRef = useRef(null);
+	function getWS() {
+		return new Promise((resolve) => {
+			if (wsRef.current) resolve(wsRef.current);
+			else {
+				const ws = new WebSocket("ws://localhost:5173/");
+				ws.onopen = () => {
+					wsRef.current = ws;
+					console.log("ws opened");
+					ws.addEventListener("close", () => {
+						console.log("ws closed");
+						wsRef.current = null;
+					});
+					resolve(ws);
+				};
+			}
+		});
+	}
+	const subscribe = async (topic, handler) => {
+		const ws = await getWS();
+		ws.send(JSON.stringify({
+			type: "subscribe",
+			topic
+		}));
+		ws.addEventListener("message", handler);
+	};
+	const unsubscribe = async (topic, handler) => {
+		const ws = await getWS();
+		ws.send(JSON.stringify({
+			type: "unsubscribe",
+			topic
+		}));
+		ws.removeEventListener("message", handler);
+	};
+	const broadcast = async (topic, payload = {}) => {
+		(await getWS()).send(JSON.stringify({
+			type: "broadcast",
+			topic,
+			payload
+		}));
+	};
+	useEffect(() => {
+		return () => {
+			if (wsRef.current) {
+				wsRef.current.close();
+				wsRef.current = null;
+			}
+		};
+	}, []);
+	return /* @__PURE__ */ jsx(WebSocketContext.Provider, {
+		value: {
+			subscribe,
+			unsubscribe,
+			broadcast
+		},
+		children: props.children
+	});
+};
+//#endregion
+//#region client/ThemeProvider.tsx
+var ThemeContext = createContext({
+	theme: "light",
+	setTheme: (theme) => {}
+});
+function storeTheme(theme) {
+	try {
+		localStorage.setItem("theme", theme);
+	} catch (error) {
+		console.error("Failed to store theme in localStorage:", error);
+	}
+}
+var ThemeProvider = (props) => {
+	const [theme, setTheme] = useState(() => {
+		if (props.theme) return props.theme;
+		if (typeof window === "undefined") return "light";
+		return localStorage.getItem("theme") || "light";
+	});
+	useEffect(() => {
+		if (theme === "system") window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", ({ matches }) => {
+			document.documentElement.classList.remove("light", "dark");
+			document.documentElement.classList.add(matches ? "dark" : "light");
+		});
+	}, [theme]);
+	return /* @__PURE__ */ jsx(ThemeContext.Provider, {
+		value: {
+			theme,
+			setTheme: (newTheme) => {
+				setTheme(newTheme);
+				storeTheme(newTheme);
+				let documentTheme = newTheme;
+				if (newTheme === "system") documentTheme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+				document.documentElement.classList.remove("light", "dark");
+				document.documentElement.classList.add(documentTheme);
+			}
+		},
+		children: props.children
+	});
+};
+function useTheme() {
+	const context = useContext(ThemeContext);
+	if (!context) throw new Error("useTheme must be used within a ThemeProvider");
+	return context;
+}
+//#endregion
+export { createMemoryHistory as A, QueryError as B, I18nContext as C, useLocation as D, ServerDataProvider as E, applyParams as F, QueryConfigContext as I, QueryManagerContext as L, RouteStateContext as M, RouteStateProvider as N, ProgressManager as O, toVariantKey as P, QueryManagerProvider as R, useNavigate as S, ServerDataContext as T, Subject as V, setActiveLocale as _, m as a, useRoute as b, ClientRouterContext as c, ComponentsProvider as d, loadViewModule as f, registerDictionary as g, loadDictionaryForRender as h, WebSocketContextProvider as i, useParams as j, Action as k, ClientRouterProvider as l, loadDictionary as m, useTheme as n, RouteTransitionProvider as o, subscribeViewModules as p, WebSocketContext as r, useRouteTransition as s, ThemeProvider as t, ComponentsContext as u, readRoutePayload as v, I18nProvider as w, useSearchParams as x, routeDataUrl as y, DEFAULT_STALE_TIME as z };
+
+//# sourceMappingURL=ThemeProvider-Bk1eZymb.js.map