@alivault/pico 0.1.0

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

@@ -0,0 +1,152 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { X as require_react } from "./@base-ui/react+[...].mjs";
+import { c as detectPlatform, s as normalizeRegisterableHotkey, t as getHotkeyManager } from "./@tanstack/hotkeys+[...].mjs";
+//#region node_modules/.pnpm/@tanstack+react-hotkeys@0.10.0_react-dom@19.2.5_react@19.2.5__react@19.2.5/node_modules/@tanstack/react-hotkeys/dist/HotkeysProvider.js
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var HotkeysContext = (0, import_react.createContext)(null);
+var DEFAULT_OPTIONS = {};
+function HotkeysProvider({ children, defaultOptions = DEFAULT_OPTIONS }) {
+	const contextValue = (0, import_react.useMemo)(() => ({ defaultOptions }), [defaultOptions]);
+	return /* @__PURE__ */ import_react.createElement(HotkeysContext.Provider, { value: contextValue }, children);
+}
+function useDefaultHotkeysOptions() {
+	return (0, import_react.useContext)(HotkeysContext)?.defaultOptions ?? {};
+}
+//#endregion
+//#region node_modules/.pnpm/@tanstack+react-hotkeys@0.10.0_react-dom@19.2.5_react@19.2.5__react@19.2.5/node_modules/@tanstack/react-hotkeys/dist/utils.js
+/**
+* Type guard to check if a value is a React ref-like object.
+*/
+function isRef(value) {
+	return value !== null && typeof value === "object" && "current" in value;
+}
+//#endregion
+//#region node_modules/.pnpm/@tanstack+react-hotkeys@0.10.0_react-dom@19.2.5_react@19.2.5__react@19.2.5/node_modules/@tanstack/react-hotkeys/dist/useHotkeys.js
+/**
+* React hook for registering multiple keyboard hotkeys at once.
+*
+* Uses the singleton HotkeyManager for efficient event handling.
+* Accepts a dynamic array of hotkey definitions, making it safe to use
+* with variable-length lists without violating the rules of hooks.
+*
+* Options are merged in this order:
+* HotkeysProvider defaults < commonOptions < per-definition options
+*
+* Callbacks and options are synced on every render to avoid stale closures.
+*
+* @param hotkeys - Array of hotkey definitions to register
+* @param commonOptions - Shared options applied to all hotkeys (overridden by per-definition options).
+*   Per-row `enabled: false` still registers that hotkey: `HotkeyManager` suppresses execution only (the row
+*   stays in the store and appears in TanStack Hotkeys devtools). Toggling `enabled` updates the existing handle
+*   via `setOptions` (no unregister/re-register churn).
+*
+* @example
+* ```tsx
+* function Editor() {
+*   useHotkeys([
+*     { hotkey: 'Mod+S', callback: () => save() },
+*     { hotkey: 'Mod+Z', callback: () => undo() },
+*     { hotkey: 'Escape', callback: () => close() },
+*   ])
+* }
+* ```
+*
+* @example
+* ```tsx
+* function MenuShortcuts({ items }) {
+*   // Dynamic hotkeys from data -- safe because it's a single hook call
+*   useHotkeys(
+*     items.map((item) => ({
+*       hotkey: item.shortcut,
+*       callback: item.action,
+*       options: { enabled: item.enabled },
+*     })),
+*     { preventDefault: true },
+*   )
+* }
+* ```
+*/
+function useHotkeys(hotkeys, commonOptions = {}) {
+	const defaultOptions = useDefaultHotkeysOptions().hotkey;
+	const manager = getHotkeyManager();
+	const platform = commonOptions.platform ?? defaultOptions?.platform ?? detectPlatform();
+	const registrationsRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+	const hotkeysRef = (0, import_react.useRef)(hotkeys);
+	const hotkeyStringsRef = (0, import_react.useRef)([]);
+	const commonOptionsRef = (0, import_react.useRef)(commonOptions);
+	const defaultOptionsRef = (0, import_react.useRef)(defaultOptions);
+	const managerRef = (0, import_react.useRef)(manager);
+	const hotkeyStrings = hotkeys.map((def) => normalizeRegisterableHotkey(def.hotkey, platform));
+	hotkeysRef.current = hotkeys;
+	hotkeyStringsRef.current = hotkeyStrings;
+	commonOptionsRef.current = commonOptions;
+	defaultOptionsRef.current = defaultOptions;
+	managerRef.current = manager;
+	(0, import_react.useEffect)(() => {
+		const prevRegistrations = registrationsRef.current;
+		const nextRegistrations = /* @__PURE__ */ new Map();
+		const rows = [];
+		for (let i = 0; i < hotkeysRef.current.length; i++) {
+			const def = hotkeysRef.current[i];
+			const hotkeyStr = hotkeyStringsRef.current[i];
+			const mergedOptions = {
+				...defaultOptionsRef.current,
+				...commonOptionsRef.current,
+				...def.options
+			};
+			const resolvedTarget = isRef(mergedOptions.target) ? mergedOptions.target.current : mergedOptions.target ?? (typeof document !== "undefined" ? document : null);
+			if (!resolvedTarget) continue;
+			const registrationKey = `${i}:${hotkeyStr}`;
+			rows.push({
+				registrationKey,
+				def,
+				hotkeyStr,
+				mergedOptions,
+				resolvedTarget
+			});
+		}
+		const nextKeys = new Set(rows.map((r) => r.registrationKey));
+		for (const [key, record] of prevRegistrations) if (!nextKeys.has(key) && record.handle.isActive) record.handle.unregister();
+		for (const row of rows) {
+			const { registrationKey, def, hotkeyStr, mergedOptions, resolvedTarget } = row;
+			const existing = prevRegistrations.get(registrationKey);
+			if (existing?.handle.isActive && existing.target === resolvedTarget) {
+				nextRegistrations.set(registrationKey, existing);
+				continue;
+			}
+			if (existing?.handle.isActive) existing.handle.unregister();
+			const handle = managerRef.current.register(hotkeyStr, def.callback, {
+				...mergedOptions,
+				target: resolvedTarget
+			});
+			nextRegistrations.set(registrationKey, {
+				handle,
+				target: resolvedTarget
+			});
+		}
+		registrationsRef.current = nextRegistrations;
+	});
+	(0, import_react.useEffect)(() => {
+		return () => {
+			for (const { handle } of registrationsRef.current.values()) if (handle.isActive) handle.unregister();
+			registrationsRef.current = /* @__PURE__ */ new Map();
+		};
+	}, []);
+	for (let i = 0; i < hotkeys.length; i++) {
+		const def = hotkeys[i];
+		const hotkeyStr = hotkeyStrings[i];
+		const registrationKey = `${i}:${hotkeyStr}`;
+		const handle = registrationsRef.current.get(registrationKey)?.handle;
+		if (handle?.isActive) {
+			handle.callback = def.callback;
+			const { target: _target, ...optionsWithoutTarget } = {
+				...defaultOptions,
+				...commonOptions,
+				...def.options
+			};
+			handle.setOptions(optionsWithoutTarget);
+		}
+	}
+}
+//#endregion
+export { HotkeysProvider as n, useHotkeys as t };

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

@@ -0,0 +1,180 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { X as require_react, Y as require_jsx_runtime } from "./@base-ui/react+[...].mjs";
+import { c as noop, i as notifyManager, l as replaceEqualDeep, n as MutationObserver, r as QueryObserver, s as environmentManager, u as shouldThrowError } from "./tanstack__query-core.mjs";
+//#region node_modules/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/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/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/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/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/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/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/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 || options.experimental_prefetchInRender || 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/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/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 willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
+var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+	errorResetBoundary.clearReset();
+});
+//#endregion
+//#region node_modules/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/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);
+	client.getDefaultOptions().queries?._experimental_beforeQuery?.(defaultedOptions);
+	const query = client.getQueryCache().get(defaultedOptions.queryHash);
+	defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
+	ensureSuspenseTimers(defaultedOptions);
+	ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
+	useClearResetErrorBoundary(errorResetBoundary);
+	const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+	const [observer] = import_react.useState(() => new Observer(client, defaultedOptions));
+	const result = observer.getOptimisticResult(defaultedOptions);
+	const shouldSubscribe = !isRestoring && options.subscribed !== false;
+	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;
+	client.getDefaultOptions().queries?._experimental_afterQuery?.(defaultedOptions, result);
+	if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) (isNewCacheEntry ? fetchOptimistic(defaultedOptions, observer, errorResetBoundary) : query?.promise)?.catch(noop).finally(() => {
+		observer.updateResult();
+	});
+	return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+//#endregion
+//#region node_modules/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/node_modules/@tanstack/react-query/build/modern/useQuery.js
+function useQuery(options, queryClient) {
+	return useBaseQuery(options, QueryObserver, queryClient);
+}
+//#endregion
+//#region node_modules/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/node_modules/@tanstack/react-query/build/modern/useIsFetching.js
+function useIsFetching(filters, queryClient) {
+	const client = useQueryClient(queryClient);
+	const queryCache = client.getQueryCache();
+	return import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)), [queryCache]), () => client.isFetching(filters), () => client.isFetching(filters));
+}
+//#endregion
+//#region node_modules/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/node_modules/@tanstack/react-query/build/modern/useMutationState.js
+function useIsMutating(filters, queryClient) {
+	const client = useQueryClient(queryClient);
+	return useMutationState({ filters: {
+		...filters,
+		status: "pending"
+	} }, client).length;
+}
+function getResult(mutationCache, options) {
+	return mutationCache.findAll(options.filters).map((mutation) => options.select ? options.select(mutation) : mutation.state);
+}
+function useMutationState(options = {}, queryClient) {
+	const mutationCache = useQueryClient(queryClient).getMutationCache();
+	const optionsRef = import_react.useRef(options);
+	const result = import_react.useRef(null);
+	if (result.current === null) result.current = getResult(mutationCache, options);
+	import_react.useEffect(() => {
+		optionsRef.current = options;
+	});
+	return import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => mutationCache.subscribe(() => {
+		const nextResult = replaceEqualDeep(result.current, getResult(mutationCache, optionsRef.current));
+		if (result.current !== nextResult) {
+			result.current = nextResult;
+			notifyManager.schedule(onStoreChange);
+		}
+	}), [mutationCache]), () => result.current, () => result.current);
+}
+//#endregion
+//#region node_modules/.pnpm/@tanstack+react-query@5.99.0_react@19.2.5/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((variables, mutateOptions) => {
+		observer.mutate(variables, mutateOptions).catch(noop);
+	}, [observer]);
+	if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
+	return {
+		...result,
+		mutate,
+		mutateAsync: result.mutate
+	};
+}
+//#endregion
+export { QueryClientProvider as a, useQuery as i, useIsMutating as n, useQueryClient as o, useIsFetching as r, useMutation as t };

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

@@ -0,0 +1,39 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { J as require_with_selector, X as require_react } from "./@base-ui/react+[...].mjs";
+//#region node_modules/.pnpm/@tanstack+react-store@0.11.0_react-dom@19.2.5_react@19.2.5__react@19.2.5/node_modules/@tanstack/react-store/dist/useSelector.js
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var import_with_selector = require_with_selector();
+function defaultCompare(a, b) {
+	return a === b;
+}
+/**
+* Selects a slice of state from an atom or store and subscribes the component
+* to that selection.
+*
+* This is the primary React read hook for TanStack Store. It works with any
+* source that exposes `get()` and `subscribe()`, including atoms, readonly
+* atoms, stores, and readonly stores.
+*
+* Omit the selector to subscribe to the whole value.
+*
+* @example
+* ```tsx
+* const count = useSelector(counterStore, (state) => state.count)
+* ```
+*
+* @example
+* ```tsx
+* const value = useSelector(countAtom)
+* ```
+*/
+function useSelector(source, selector = (s) => s, options) {
+	const compare = options?.compare ?? defaultCompare;
+	const subscribe = (0, import_react.useCallback)((handleStoreChange) => {
+		const { unsubscribe } = source.subscribe(handleStoreChange);
+		return unsubscribe;
+	}, [source]);
+	const getSnapshot = (0, import_react.useCallback)(() => source.get(), [source]);
+	return (0, import_with_selector.useSyncExternalStoreWithSelector)(subscribe, getSnapshot, getSnapshot, selector, compare);
+}
+//#endregion
+export { useSelector as t };

package/.output/server/_libs/tanstack__router-core.mjs

@@ -0,0 +1,6 @@
+//#region node_modules/.pnpm/@tanstack+router-core@1.168.15/node_modules/@tanstack/router-core/dist/esm/ssr/handlerCallback.js
+function defineHandlerCallback(handler) {
+	return handler;
+}
+//#endregion
+export { defineHandlerCallback as t };

package/.output/server/_libs/tanstack__store.mjs

@@ -0,0 +1,28 @@
+//#region node_modules/.pnpm/@tanstack+store@0.11.0/node_modules/@tanstack/store/dist/shallow.js
+function shallow(objA, objB) {
+	if (Object.is(objA, objB)) return true;
+	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return false;
+	if (objA instanceof Map && objB instanceof Map) {
+		if (objA.size !== objB.size) return false;
+		for (const [k, v] of objA) if (!objB.has(k) || !Object.is(v, objB.get(k))) return false;
+		return true;
+	}
+	if (objA instanceof Set && objB instanceof Set) {
+		if (objA.size !== objB.size) return false;
+		for (const v of objA) if (!objB.has(v)) return false;
+		return true;
+	}
+	if (objA instanceof Date && objB instanceof Date) {
+		if (objA.getTime() !== objB.getTime()) return false;
+		return true;
+	}
+	const keysA = getOwnKeys(objA);
+	if (keysA.length !== getOwnKeys(objB).length) return false;
+	for (let i = 0; i < keysA.length; i++) if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) return false;
+	return true;
+}
+function getOwnKeys(obj) {
+	return Object.keys(obj).concat(Object.getOwnPropertySymbols(obj));
+}
+//#endregion
+export { shallow 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/_libs/unctx.mjs

@@ -0,0 +1,82 @@
+//#region node_modules/.pnpm/nitro@3.0.260415-beta_dotenv@17.4.2_jiti@2.7.0_lru-cache@11.3.5_rollup@4.60.1_vite@8.0._aab64657a678a0edb1746e2c859bb8b1/node_modules/nitro/dist/node_modules/unctx/dist/index.mjs
+function createContext(opts = {}) {
+	let currentInstance;
+	let isSingleton = false;
+	const checkConflict = (instance) => {
+		if (currentInstance && currentInstance !== instance) throw new Error("Context conflict");
+	};
+	let als;
+	if (opts.asyncContext) {
+		const _AsyncLocalStorage = opts.AsyncLocalStorage || globalThis.AsyncLocalStorage;
+		if (_AsyncLocalStorage) als = new _AsyncLocalStorage();
+		else console.warn("[unctx] `AsyncLocalStorage` is not provided.");
+	}
+	const _getCurrentInstance = () => {
+		if (als) {
+			const instance = als.getStore();
+			if (instance !== void 0) return instance;
+		}
+		return currentInstance;
+	};
+	return {
+		use: () => {
+			const _instance = _getCurrentInstance();
+			if (_instance === void 0) throw new Error("Context is not available");
+			return _instance;
+		},
+		tryUse: () => {
+			return _getCurrentInstance();
+		},
+		set: (instance, replace) => {
+			if (!replace) checkConflict(instance);
+			currentInstance = instance;
+			isSingleton = true;
+		},
+		unset: () => {
+			currentInstance = void 0;
+			isSingleton = false;
+		},
+		call: (instance, callback) => {
+			checkConflict(instance);
+			currentInstance = instance;
+			try {
+				return als ? als.run(instance, callback) : callback();
+			} finally {
+				if (!isSingleton) currentInstance = void 0;
+			}
+		},
+		async callAsync(instance, callback) {
+			currentInstance = instance;
+			const onRestore = () => {
+				currentInstance = instance;
+			};
+			const onLeave = () => currentInstance === instance ? onRestore : void 0;
+			asyncHandlers.add(onLeave);
+			try {
+				const r = als ? als.run(instance, callback) : callback();
+				if (!isSingleton) currentInstance = void 0;
+				return await r;
+			} finally {
+				asyncHandlers.delete(onLeave);
+			}
+		}
+	};
+}
+function createNamespace(defaultOpts = {}) {
+	const contexts = {};
+	return { get(key, opts = {}) {
+		if (!contexts[key]) contexts[key] = createContext({
+			...defaultOpts,
+			...opts
+		});
+		return contexts[key];
+	} };
+}
+var _globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : {};
+var globalKey = "__unctx__";
+var defaultNamespace = _globalThis[globalKey] || (_globalThis[globalKey] = createNamespace());
+var getContext = (key, opts = {}) => defaultNamespace.get(key, opts);
+var asyncHandlersKey = "__unctx_async_handlers__";
+var asyncHandlers = _globalThis[asyncHandlersKey] || (_globalThis[asyncHandlersKey] = /* @__PURE__ */ new Set());
+//#endregion
+export { getContext as t };