gitxp 0.0.1

package/.output/server/_libs/tanstack__react-db.mjs

@@ -0,0 +1,242 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { u as require_react } from "./@floating-ui/react-dom+[...].mjs";
+import { l as require_jsx_runtime } from "./@radix-ui/react-arrow+[...].mjs";
+import { a as createLiveQueryObserver, c as BaseQueryBuilder, i as getStableValueHash, n as prepareLiveQueryValue, o as isCollection, r as UnhashableQueryIRError, s as createLiveQueryCollection, t as getPreparedLiveQueryIdentity, u as deepEquals } from "./@tanstack/db+[...].mjs";
+require_jsx_runtime();
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var DbContext = (0, import_react.createContext)(void 0);
+function useOptionalDbClient() {
+	return (0, import_react.useContext)(DbContext);
+}
+//#endregion
+//#region node_modules/@tanstack/react-db/dist/esm/live-query-internals.js
+var liveQueryResultInfo = /* @__PURE__ */ Symbol(`liveQueryResultInfo`);
+function setLiveQueryResultInfo(result, info) {
+	Object.defineProperty(result, liveQueryResultInfo, {
+		configurable: true,
+		value: info
+	});
+}
+//#endregion
+//#region node_modules/@tanstack/react-db/dist/esm/useLiveQuery.js
+var DEFAULT_GC_TIME_MS = 1;
+var DERIVED_IDENTITY_SINGLE_RENDER_WARN_MS = 16;
+var DERIVED_IDENTITY_RENDER_COUNT_WARN_THRESHOLD = 10;
+var DERIVED_IDENTITY_TOTAL_WARN_MS = 50;
+var warnedDepsCallsites = /* @__PURE__ */ new Set();
+var warnedDerivedIdentityCallsites = /* @__PURE__ */ new Set();
+var warnedUnhashableIdentityCallsites = /* @__PURE__ */ new Set();
+var unpreparedQueryValue = /* @__PURE__ */ Symbol(`unpreparedQueryValue`);
+function warnDeprecatedDepsArray(hookName = `useLiveQuery`) {
+	if (!shouldWarnInDevelopment(`TANSTACK_DB_DISABLE_DEPRECATION_WARNINGS`)) return;
+	const callsite = getWarningCallsite(4);
+	if (warnedDepsCallsites.has(callsite)) return;
+	warnedDepsCallsites.add(callsite);
+	console.warn(`[${hookName}] The dependency-array form is deprecated and will be removed in 1.0. Use ${hookName === `useLiveQuery` ? `useLiveQuery({ query })` : `useLiveInfiniteQuery(query, { queryKey })`} instead. Provide queryKey only for functional/opaque queries or to avoid deriving identity from structured query IR on render.`);
+}
+function shouldWarnInDevelopment(disableEnvVar) {
+	if (typeof process === `undefined`) return false;
+	return false;
+}
+function getCurrentTime() {
+	return typeof performance !== `undefined` && typeof performance.now === `function` ? performance.now() : Date.now();
+}
+function getWarningCallsite(stackIndex) {
+	const stack = (/* @__PURE__ */ new Error()).stack ?? `unknown`;
+	return stack.split(`
+`)[stackIndex]?.trim() ?? stack;
+}
+function warnDerivedIdentityHotPath(profiler, durationMs) {
+	if (profiler.warned || !shouldWarnInDevelopment(`TANSTACK_DB_DISABLE_QUERY_IDENTITY_WARNINGS`)) return;
+	const isSlowSingleRender = durationMs >= DERIVED_IDENTITY_SINGLE_RENDER_WARN_MS;
+	const isHotRenderPath = profiler.renderCount >= DERIVED_IDENTITY_RENDER_COUNT_WARN_THRESHOLD && profiler.totalMs >= DERIVED_IDENTITY_TOTAL_WARN_MS;
+	if (!isSlowSingleRender && !isHotRenderPath) return;
+	const callsite = getWarningCallsite(5);
+	if (warnedDerivedIdentityCallsites.has(callsite)) {
+		profiler.warned = true;
+		return;
+	}
+	warnedDerivedIdentityCallsites.add(callsite);
+	profiler.warned = true;
+	const reason = isSlowSingleRender ? `one render took ${durationMs.toFixed(1)}ms` : `${profiler.renderCount} renders took ${profiler.totalMs.toFixed(1)}ms`;
+	console.warn(`[useLiveQuery] Deriving live query identity from structured query IR is running on a hot render path (${reason}, max ${profiler.maxMs.toFixed(1)}ms). Provide an explicit queryKey to skip rebuilding and hashing the IR on every render: useLiveQuery({ queryKey: [...], query }).`);
+}
+function getExplicitQueryKey(value) {
+	return value && typeof value === `object` && Array.isArray(value.queryKey) ? value.queryKey : void 0;
+}
+function getExplicitDbClient(value) {
+	return value && typeof value === `object` && `client` in value && value.client !== void 0 ? value.client : void 0;
+}
+function prepareQueryValue(value, dbClient, deferredCollections) {
+	return prepareLiveQueryValue(value, dbClient, deferredCollections);
+}
+function prepareDerivedQuery(value, dbClient, profiler, deferredCollections) {
+	const shouldProfile = shouldWarnInDevelopment(`TANSTACK_DB_DISABLE_QUERY_IDENTITY_WARNINGS`);
+	const start = shouldProfile ? getCurrentTime() : 0;
+	const preparedValue = prepareQueryValue(value, dbClient, deferredCollections);
+	try {
+		return {
+			status: `hashable`,
+			value: preparedValue,
+			identityDeps: [`derived`, getPreparedLiveQueryIdentity(preparedValue)]
+		};
+	} catch (error) {
+		if (error instanceof UnhashableQueryIRError) return {
+			status: `unhashable`,
+			value: preparedValue,
+			error
+		};
+		throw error;
+	} finally {
+		if (shouldProfile) {
+			const durationMs = getCurrentTime() - start;
+			profiler.renderCount += 1;
+			profiler.totalMs += durationMs;
+			profiler.maxMs = Math.max(profiler.maxMs, durationMs);
+			warnDerivedIdentityHotPath(profiler, durationMs);
+		}
+	}
+}
+function warnUnhashableDerivedIdentity(error) {
+	if (!shouldWarnInDevelopment(`TANSTACK_DB_DISABLE_QUERY_IDENTITY_WARNINGS`)) return;
+	const callsite = getWarningCallsite(4);
+	if (warnedUnhashableIdentityCallsites.has(callsite)) return;
+	warnedUnhashableIdentityCallsites.add(callsite);
+	console.warn(`[useLiveQuery] This query cannot derive a stable identity because ${error.reason} at ${error.path}. It will keep the legacy mount-stable behavior for now. Add queryKey: [...] to make captured values reactive. Unhashable queries without queryKey will throw in 1.0.`);
+}
+function createCollectionFromPreparedQuery(value) {
+	if (value === void 0 || value === null) return null;
+	if (isCollection(value)) {
+		value.startSyncImmediate();
+		return value;
+	}
+	if (value instanceof BaseQueryBuilder) return createLiveQueryCollection({
+		query: value,
+		startSync: true,
+		gcTime: DEFAULT_GC_TIME_MS
+	});
+	if (typeof value === `object`) return createLiveQueryCollection({
+		startSync: true,
+		gcTime: DEFAULT_GC_TIME_MS,
+		...value
+	});
+	throw new Error(`useLiveQuery callback must return a QueryBuilder, LiveQueryCollectionConfig, Collection, undefined, or null. Got: ${typeof value}`);
+}
+function useLiveQuery(configOrQueryOrCollection, deps) {
+	const contextDbClient = useOptionalDbClient();
+	const inputIsCollection = isCollection(configOrQueryOrCollection);
+	const dbClient = inputIsCollection ? contextDbClient : getExplicitDbClient(configOrQueryOrCollection) ?? contextDbClient;
+	const resolvedDeps = deps ?? [];
+	const collectionRef = (0, import_react.useRef)(null);
+	const depsRef = (0, import_react.useRef)(null);
+	const configRef = (0, import_react.useRef)(null);
+	const clientRef = (0, import_react.useRef)(dbClient);
+	const legacyUnhashableIdentityRef = (0, import_react.useRef)([`legacy-unhashable`]);
+	const derivedIdentityProfilerRef = (0, import_react.useRef)({
+		renderCount: 0,
+		totalMs: 0,
+		maxMs: 0,
+		warned: false
+	});
+	const deferredCollectionsRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+	const observerRef = (0, import_react.useRef)(null);
+	const queryHashRef = (0, import_react.useRef)(void 0);
+	const identityErrorRef = (0, import_react.useRef)(void 0);
+	const queryKey = !inputIsCollection ? getExplicitQueryKey(configOrQueryOrCollection) : void 0;
+	let preparedQueryValue = unpreparedQueryValue;
+	let identityDeps;
+	let streamIdentity = void 0;
+	let identityError;
+	if (queryKey) {
+		identityDeps = queryKey;
+		streamIdentity = [`queryKey`, queryKey];
+	} else if (deps !== void 0) {
+		identityDeps = resolvedDeps;
+		try {
+			preparedQueryValue = prepareQueryValue(configOrQueryOrCollection, dbClient, deferredCollectionsRef.current);
+			streamIdentity = [
+				`deps`,
+				resolvedDeps,
+				getPreparedLiveQueryIdentity(preparedQueryValue)
+			];
+		} catch (error) {
+			if (!(error instanceof UnhashableQueryIRError)) throw error;
+			warnUnhashableDerivedIdentity(error);
+			identityError = error;
+		}
+	} else if (inputIsCollection) {
+		identityDeps = [];
+		streamIdentity = [`collection`, configOrQueryOrCollection.id];
+	} else {
+		const preparation = prepareDerivedQuery(configOrQueryOrCollection, dbClient, derivedIdentityProfilerRef.current, deferredCollectionsRef.current);
+		preparedQueryValue = preparation.value;
+		if (preparation.status === `hashable`) {
+			identityDeps = preparation.identityDeps;
+			streamIdentity = preparation.identityDeps;
+		} else {
+			warnUnhashableDerivedIdentity(preparation.error);
+			identityDeps = legacyUnhashableIdentityRef.current;
+			identityError = preparation.error;
+		}
+	}
+	let queryHash;
+	if (streamIdentity !== void 0) try {
+		queryHash = getStableValueHash(streamIdentity, `queryKey`);
+	} catch (error) {
+		if (error instanceof UnhashableQueryIRError) {
+			if (queryKey !== void 0) throw error;
+			identityError = error;
+		} else throw error;
+	}
+	if (deps !== void 0) warnDeprecatedDepsArray();
+	const identityChanged = depsRef.current === null || (deps !== void 0 ? depsRef.current.length !== identityDeps.length || depsRef.current.some((dep, index) => dep !== identityDeps[index]) : !deepEquals(depsRef.current, identityDeps));
+	const needsNewCollection = !collectionRef.current || inputIsCollection && configRef.current !== configOrQueryOrCollection || !inputIsCollection && (clientRef.current !== dbClient || identityChanged);
+	const resumeDeferredCollections = () => {
+		for (const collection of deferredCollectionsRef.current) collection._resumeSyncStart();
+		deferredCollectionsRef.current.clear();
+	};
+	if (needsNewCollection) {
+		if (inputIsCollection) {
+			if (configOrQueryOrCollection.config?.syncMode === `on-demand` && shouldWarnInDevelopment(`TANSTACK_DB_DISABLE_QUERY_IDENTITY_WARNINGS`)) console.warn(`[useLiveQuery] Warning: Passing a collection with syncMode "on-demand" directly to useLiveQuery will not load any data. In on-demand mode, data is only loaded when queries with predicates request it.
+
+Instead, use a query builder function:
+  const { data } = useLiveQuery({ query: (q) => q.from({ c: myCollection }).select(({ c }) => c) })
+
+Or switch to syncMode "eager" if you want all data to sync automatically.`);
+			configOrQueryOrCollection.startSyncImmediate();
+			collectionRef.current = configOrQueryOrCollection;
+			configRef.current = configOrQueryOrCollection;
+		} else {
+			if (preparedQueryValue === unpreparedQueryValue) preparedQueryValue = prepareQueryValue(configOrQueryOrCollection, dbClient, deferredCollectionsRef.current);
+			collectionRef.current = createCollectionFromPreparedQuery(preparedQueryValue);
+			configRef.current = configOrQueryOrCollection;
+			depsRef.current = [...identityDeps];
+		}
+		clientRef.current = dbClient;
+		queryHashRef.current = queryHash;
+		identityErrorRef.current = identityError;
+	}
+	if (needsNewCollection) observerRef.current = createLiveQueryObserver(collectionRef.current, {
+		mode: `wholesale`,
+		client: dbClient,
+		queryHash: queryHashRef.current,
+		onPreload: resumeDeferredCollections
+	});
+	const observer = observerRef.current;
+	const subscribeRef = (0, import_react.useRef)(null);
+	if (!subscribeRef.current || needsNewCollection) subscribeRef.current = (onStoreChange) => {
+		const unsubscribe = observer.subscribe(() => onStoreChange());
+		resumeDeferredCollections();
+		return unsubscribe;
+	};
+	const returned = (0, import_react.useSyncExternalStore)(subscribeRef.current, () => observer.getSnapshot(), () => observer.getServerSnapshot());
+	setLiveQueryResultInfo(returned, {
+		client: dbClient,
+		queryHash: queryHashRef.current,
+		identityError: identityErrorRef.current,
+		observer
+	});
+	return returned;
+}
+//#endregion
+export { useLiveQuery as t };

package/.output/server/_libs/tanstack__react-query.mjs

@@ -0,0 +1,140 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { u as require_react } from "./@floating-ui/react-dom+[...].mjs";
+import { l as require_jsx_runtime } from "./@radix-ui/react-arrow+[...].mjs";
+import { c as shouldThrowError, i as notifyManager, n as MutationObserver, r as QueryObserver, s as noop } from "./tanstack__query-core.mjs";
+//#region node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var import_jsx_runtime = require_jsx_runtime();
+var QueryClientContext = import_react.createContext(void 0);
+var useQueryClient = (queryClient) => {
+	const client = import_react.useContext(QueryClientContext);
+	if (queryClient) return queryClient;
+	if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
+	return client;
+};
+var QueryClientProvider = ({ client, children }) => {
+	import_react.useEffect(() => {
+		client.mount();
+		return () => {
+			client.unmount();
+		};
+	}, [client]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, {
+		value: client,
+		children
+	});
+};
+//#endregion
+//#region node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
+var IsRestoringContext = import_react.createContext(false);
+var useIsRestoring = () => import_react.useContext(IsRestoringContext);
+IsRestoringContext.Provider;
+//#endregion
+//#region node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
+function createValue() {
+	let isReset = false;
+	return {
+		clearReset: () => {
+			isReset = false;
+		},
+		reset: () => {
+			isReset = true;
+		},
+		isReset: () => {
+			return isReset;
+		}
+	};
+}
+var QueryErrorResetBoundaryContext = import_react.createContext(createValue());
+var useQueryErrorResetBoundary = () => import_react.useContext(QueryErrorResetBoundaryContext);
+//#endregion
+//#region node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
+	const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
+	if (options.suspense || throwOnError) {
+		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
+	}
+};
+var useClearResetErrorBoundary = (errorResetBoundary) => {
+	import_react.useEffect(() => {
+		errorResetBoundary.clearReset();
+	}, [errorResetBoundary]);
+};
+var getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }) => {
+	return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
+};
+//#endregion
+//#region node_modules/@tanstack/react-query/build/modern/suspense.js
+var ensureSuspenseTimers = (defaultedOptions) => {
+	if (defaultedOptions.suspense) {
+		const MIN_SUSPENSE_TIME_MS = 1e3;
+		const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
+		const originalStaleTime = defaultedOptions.staleTime;
+		defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
+		if (typeof defaultedOptions.gcTime === "number") defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, MIN_SUSPENSE_TIME_MS);
+	}
+};
+var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
+var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+	errorResetBoundary.clearReset();
+});
+//#endregion
+//#region node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
+function useBaseQuery(options, Observer, queryClient) {
+	const isRestoring = useIsRestoring();
+	const errorResetBoundary = useQueryErrorResetBoundary();
+	const client = useQueryClient(queryClient);
+	const defaultedOptions = client.defaultQueryOptions(options);
+	const query = client.getQueryCache().get(defaultedOptions.queryHash);
+	const subscribed = options.subscribed !== false;
+	defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
+	ensureSuspenseTimers(defaultedOptions);
+	ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
+	useClearResetErrorBoundary(errorResetBoundary);
+	const [observer] = import_react.useState(() => new Observer(client, defaultedOptions));
+	const result = observer.getOptimisticResult(defaultedOptions);
+	const shouldSubscribe = !isRestoring && subscribed;
+	import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => {
+		const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
+		observer.updateResult();
+		return unsubscribe;
+	}, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+	import_react.useEffect(() => {
+		observer.setOptions(defaultedOptions);
+	}, [defaultedOptions, observer]);
+	if (shouldSuspend(defaultedOptions, result)) throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+	if (getHasError({
+		result,
+		errorResetBoundary,
+		throwOnError: defaultedOptions.throwOnError,
+		query,
+		suspense: defaultedOptions.suspense
+	})) throw result.error;
+	return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+//#endregion
+//#region node_modules/@tanstack/react-query/build/modern/useQuery.js
+function useQuery(options, queryClient) {
+	return useBaseQuery(options, QueryObserver, queryClient);
+}
+//#endregion
+//#region node_modules/@tanstack/react-query/build/modern/useMutation.js
+function useMutation(options, queryClient) {
+	const client = useQueryClient(queryClient);
+	const [observer] = import_react.useState(() => new MutationObserver(client, options));
+	import_react.useEffect(() => {
+		observer.setOptions(options);
+	}, [observer, options]);
+	const result = import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+	const mutate = import_react.useCallback((...args) => {
+		observer.mutate(args[0], args[1]).catch(noop);
+	}, [observer]);
+	if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
+	return {
+		...result,
+		mutate,
+		mutateAsync: result.mutate
+	};
+}
+//#endregion
+export { useQueryClient as i, useQuery as n, QueryClientProvider as r, useMutation as t };

package/.output/server/_libs/ufo.mjs

@@ -0,0 +1,64 @@
+String.fromCharCode;
+var ENC_SLASH_RE = /%2f/gi;
+function decode(text = "") {
+	try {
+		return decodeURIComponent("" + text);
+	} catch {
+		return "" + text;
+	}
+}
+function decodePath(text) {
+	return decode(text.replace(ENC_SLASH_RE, "%252F"));
+}
+var TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+var JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+	if (!hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+	}
+	const [s0, ...s] = path.split("?");
+	return ((s0.endsWith("/") ? s0.slice(0, -1) : s0) || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
+	if (hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+		if (!path) return fragment;
+	}
+	const [s0, ...s] = path.split("?");
+	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function hasLeadingSlash(input = "") {
+	return input.startsWith("/");
+}
+function withLeadingSlash(input = "") {
+	return hasLeadingSlash(input) ? input : "/" + input;
+}
+function isNonEmptyURL(url) {
+	return url && url !== "/";
+}
+function joinURL(base, ...input) {
+	let url = base || "";
+	for (const segment of input.filter((url2) => isNonEmptyURL(url2))) if (url) {
+		const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+		url = withTrailingSlash(url) + _segment;
+	} else url = segment;
+	return url;
+}
+//#endregion
+export { withoutTrailingSlash as i, joinURL as n, withLeadingSlash as r, decodePath as t };

package/.output/server/_runtime.mjs

@@ -0,0 +1,35 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/.output/server/_ssr/empty-plugin-adapters-D9UWiqvJ.mjs

@@ -0,0 +1,5 @@
+//#region node_modules/.nitro/vite/services/ssr/assets/empty-plugin-adapters-D9UWiqvJ.js
+var pluginSerializationAdapters = [];
+var hasPluginAdapters = false;
+//#endregion
+export { hasPluginAdapters, pluginSerializationAdapters };

package/.output/server/_ssr/events-BNrmOvgU.mjs

@@ -0,0 +1,13 @@
+//#region node_modules/.nitro/vite/services/ssr/assets/events-BNrmOvgU.js
+var listeners = /* @__PURE__ */ new Set();
+function onChange(listener) {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+function emitChange(resource) {
+	for (const listener of listeners) listener(resource);
+}
+//#endregion
+export { onChange as n, emitChange as t };