@journ/lift 0.1.1 → 0.2.1

package/dist/use-local-storage.js

@@ -0,0 +1,76 @@
+import { n as tryCatchSync } from "./try-catch-D4d3N9_W.js";
+import { t as logger } from "./logger-Dse1660l.js";
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+//#region src/use-local-storage.ts
+const serializeJSON = (value, hookName) => {
+	const result = tryCatchSync(() => JSON.stringify(value));
+	if (!result.success) throw new Error(`${hookName}: Failed to serialize the value`);
+	return result.data;
+};
+const deserializeJSON = (value) => {
+	const result = tryCatchSync(() => JSON.parse(value));
+	return result.success ? result.data : value;
+};
+const createStorageHandler = (type, hookName) => {
+	const attempt = (fn, failure, fallback) => {
+		const result = tryCatchSync(fn);
+		if (result.success) return result.data;
+		logger.warn(`${hookName}: ${failure}`);
+		return fallback;
+	};
+	const getItem = (key) => attempt(() => window[type].getItem(key), "Failed to get value from storage", null);
+	const setItem = (key, value) => attempt(() => window[type].setItem(key, value), "Failed to set value to storage", void 0);
+	const removeItem = (key) => attempt(() => window[type].removeItem(key), "Failed to remove value from storage", void 0);
+	return {
+		getItem,
+		setItem,
+		removeItem
+	};
+};
+const getServerSnapshot = () => null;
+const createUseStorage = (type, hookName) => {
+	const eventName = type === "localStorage" ? "local-storage" : "session-storage";
+	const { getItem, setItem, removeItem } = createStorageHandler(type, hookName);
+	const subscribe = (callback) => {
+		window.addEventListener("storage", callback);
+		window.addEventListener(eventName, callback);
+		return () => {
+			window.removeEventListener("storage", callback);
+			window.removeEventListener(eventName, callback);
+		};
+	};
+	const defaultSerialize = (value) => serializeJSON(value, hookName);
+	const notify = () => window.dispatchEvent(new Event(eventName));
+	return ({ key, defaultValue, deserialize = deserializeJSON, serialize = defaultSerialize }) => {
+		const getSnapshot = useCallback(() => getItem(key), [key]);
+		const raw = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+		const stored = useMemo(() => raw === null ? void 0 : deserialize(raw), [raw, deserialize]);
+		const setStorageValue = useCallback((val) => {
+			let next;
+			if (val instanceof Function) {
+				const current = getItem(key);
+				next = val(current === null ? defaultValue : deserialize(current));
+			} else next = val;
+			setItem(key, serialize(next));
+			notify();
+		}, [
+			key,
+			defaultValue,
+			deserialize,
+			serialize
+		]);
+		const removeStorageValue = useCallback(() => {
+			removeItem(key);
+			notify();
+		}, [key]);
+		return [
+			raw === null ? defaultValue : stored,
+			setStorageValue,
+			removeStorageValue
+		];
+	};
+};
+const useLocalStorage = createUseStorage("localStorage", "use-local-storage");
+const useSessionStorage = createUseStorage("sessionStorage", "use-session-storage");
+//#endregion
+export { useLocalStorage, useSessionStorage };

package/dist/use-logger.d.ts

@@ -0,0 +1,4 @@
+//#region src/use-logger.d.ts
+declare const useLogger: (componentName: string, props: unknown[]) => void;
+//#endregion
+export { useLogger };

package/dist/use-logger.js

@@ -0,0 +1,17 @@
+import { useDidUpdate } from "./use-did-update.js";
+import { t as logger } from "./logger-Dse1660l.js";
+import { useEffect, useEffectEvent } from "react";
+//#region src/use-logger.ts
+const useLogger = (componentName, props) => {
+	const logMount = useEffectEvent(() => logger.log(`${componentName} mounted`, ...props));
+	const logUnmount = useEffectEvent(() => logger.log(`${componentName} unmounted`));
+	useEffect(() => {
+		logMount();
+		return () => logUnmount();
+	}, []);
+	useDidUpdate(() => {
+		logger.log(`${componentName} updated`, ...props);
+	}, props);
+};
+//#endregion
+export { useLogger };

package/dist/use-long-press.d.ts

@@ -0,0 +1,12 @@
+import { PointerEvent, SyntheticEvent } from "react";
+//#region src/use-long-press.d.ts
+type LongPressHandlers = {
+  readonly onPointerDown: (event: PointerEvent) => void;
+  readonly onPointerMove: (event: PointerEvent) => void;
+  readonly onPointerUp: () => void;
+  readonly onPointerCancel: () => void;
+  readonly onContextMenu: (event: SyntheticEvent) => void;
+};
+declare const useLongPress: (onLongPress: () => void, disabled?: boolean) => LongPressHandlers;
+//#endregion
+export { useLongPress };

package/dist/use-long-press.js

@@ -0,0 +1,43 @@
+import { useCallback, useEffect, useRef } from "react";
+//#region src/use-long-press.ts
+const HOLD_MS = 500;
+const SLOP_PX = 10;
+const useLongPress = (onLongPress, disabled = false) => {
+	const timer = useRef(null);
+	const origin = useRef(null);
+	const cancel = useCallback(() => {
+		if (timer.current !== null) {
+			clearTimeout(timer.current);
+			timer.current = null;
+		}
+		origin.current = null;
+	}, []);
+	useEffect(() => cancel, [cancel]);
+	return {
+		onPointerDown: useCallback((event) => {
+			if (disabled) return;
+			cancel();
+			origin.current = {
+				x: event.clientX,
+				y: event.clientY
+			};
+			timer.current = setTimeout(() => {
+				timer.current = null;
+				onLongPress();
+			}, HOLD_MS);
+		}, [
+			disabled,
+			onLongPress,
+			cancel
+		]),
+		onPointerMove: useCallback((event) => {
+			if (!origin.current) return;
+			if (Math.abs(event.clientX - origin.current.x) > SLOP_PX || Math.abs(event.clientY - origin.current.y) > SLOP_PX) cancel();
+		}, [cancel]),
+		onPointerUp: cancel,
+		onPointerCancel: cancel,
+		onContextMenu: useCallback((event) => event.preventDefault(), [])
+	};
+};
+//#endregion
+export { useLongPress };

package/dist/use-map.d.ts

@@ -0,0 +1,4 @@
+//#region src/use-map.d.ts
+declare const useMap: <K, V>(initialState?: [K, V][]) => Map<K, V>;
+//#endregion
+export { useMap };

package/dist/use-map.js

@@ -0,0 +1,30 @@
+import { useMemo, useRef, useState } from "react";
+//#region src/use-map.ts
+const useMap = (initialState) => {
+	const [map, setMap] = useState(() => new Map(initialState));
+	const latest = useRef(map);
+	return useMemo(() => {
+		const view = new Map(map);
+		const commit = (next) => {
+			latest.current = next;
+			setMap(next);
+		};
+		view.set = (key, value) => {
+			commit(new Map(latest.current).set(key, value));
+			return view;
+		};
+		view.delete = (key) => {
+			const existed = latest.current.has(key);
+			if (existed) {
+				const next = new Map(latest.current);
+				next.delete(key);
+				commit(next);
+			}
+			return existed;
+		};
+		view.clear = () => commit(/* @__PURE__ */ new Map());
+		return view;
+	}, [map]);
+};
+//#endregion
+export { useMap };

package/dist/use-measure.d.ts

@@ -0,0 +1,8 @@
+//#region src/use-measure.d.ts
+type Dimensions = {
+  width: number | null;
+  height: number | null;
+};
+declare const useMeasure: () => [(node: Element | null) => void, Dimensions];
+//#endregion
+export { useMeasure };

package/dist/use-measure.js

@@ -0,0 +1,27 @@
+import { useCallback, useRef, useState } from "react";
+//#region src/use-measure.ts
+const EMPTY = {
+	width: null,
+	height: null
+};
+const useMeasure = () => {
+	const [dimensions, setDimensions] = useState(EMPTY);
+	const observerRef = useRef(null);
+	return [useCallback((node) => {
+		observerRef.current?.disconnect();
+		observerRef.current = null;
+		if (node?.nodeType !== Node.ELEMENT_NODE) return;
+		const observer = new ResizeObserver(([entry]) => {
+			if (!entry?.borderBoxSize) return;
+			const box = entry.borderBoxSize[0];
+			setDimensions(box ? {
+				width: box.inlineSize,
+				height: box.blockSize
+			} : EMPTY);
+		});
+		observer.observe(node);
+		observerRef.current = observer;
+	}, []), dimensions];
+};
+//#endregion
+export { useMeasure };

package/dist/use-media-query.d.ts

@@ -0,0 +1,14 @@
+//#region src/use-media-query.d.ts
+declare const breakpoints: {
+  readonly sm: "(min-width: 40rem)";
+  readonly md: "(min-width: 48rem)";
+  readonly "max-md": "(width < 48rem)";
+  readonly lg: "(min-width: 64rem)";
+  readonly "max-lg": "(width < 64rem)";
+};
+type Breakpoint = keyof typeof breakpoints;
+type BreakpointValue = (typeof breakpoints)[Breakpoint];
+declare const useMediaQuery: (query: BreakpointValue | string) => boolean;
+declare const useBreakpoint: (breakpoint: Breakpoint) => boolean;
+//#endregion
+export { type Breakpoint, breakpoints, useBreakpoint, useMediaQuery };

package/dist/use-media-query.js

@@ -0,0 +1,24 @@
+import { useCallback, useSyncExternalStore } from "react";
+//#region src/use-media-query.ts
+const breakpoints = {
+	sm: "(min-width: 40rem)",
+	md: "(min-width: 48rem)",
+	"max-md": "(width < 48rem)",
+	lg: "(min-width: 64rem)",
+	"max-lg": "(width < 64rem)"
+};
+const getServerSnapshot = () => {
+	throw new Error("useMediaQuery is a client-only hook");
+};
+const useMediaQuery = (query) => {
+	const subscribe = useCallback((callback) => {
+		const mediaQueryList = window.matchMedia(query);
+		mediaQueryList.addEventListener("change", callback);
+		return () => mediaQueryList.removeEventListener("change", callback);
+	}, [query]);
+	const getSnapshot = useCallback(() => window.matchMedia(query).matches, [query]);
+	return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+};
+const useBreakpoint = (breakpoint) => useMediaQuery(breakpoints[breakpoint]);
+//#endregion
+export { breakpoints, useBreakpoint, useMediaQuery };

package/dist/use-mouse.d.ts

@@ -0,0 +1,18 @@
+import { RefCallback } from "react";
+//#region src/use-mouse.d.ts
+type UseMouseOptions = {
+  resetOnExit?: boolean;
+};
+type UseMouseReturnValue<T extends HTMLElement = HTMLElement> = {
+  ref: RefCallback<T>;
+  x: number;
+  y: number;
+};
+type UseMousePositionReturnValue = {
+  x: number;
+  y: number;
+};
+declare const useMouse: <T extends HTMLElement = HTMLElement>({ resetOnExit }?: UseMouseOptions) => UseMouseReturnValue<T>;
+declare const useMousePosition: () => UseMousePositionReturnValue;
+//#endregion
+export { type UseMouseOptions, type UseMousePositionReturnValue, type UseMouseReturnValue, useMouse, useMousePosition };

package/dist/use-mouse.js

@@ -0,0 +1,40 @@
+import { useWindowEvent } from "./use-window-event.js";
+import { useCallback, useState } from "react";
+//#region src/use-mouse.ts
+const ORIGIN = {
+	x: 0,
+	y: 0
+};
+const useMouse = ({ resetOnExit = false } = {}) => {
+	const [position, setPosition] = useState(ORIGIN);
+	return {
+		ref: useCallback((node) => {
+			if (!node) return;
+			const trackPosition = (event) => {
+				const rect = node.getBoundingClientRect();
+				setPosition({
+					x: Math.max(0, Math.round(event.clientX - rect.left)),
+					y: Math.max(0, Math.round(event.clientY - rect.top))
+				});
+			};
+			const resetPosition = () => setPosition(ORIGIN);
+			node.addEventListener("mousemove", trackPosition);
+			if (resetOnExit) node.addEventListener("mouseleave", resetPosition);
+			return () => {
+				node.removeEventListener("mousemove", trackPosition);
+				node.removeEventListener("mouseleave", resetPosition);
+			};
+		}, [resetOnExit]),
+		...position
+	};
+};
+const useMousePosition = () => {
+	const [position, setPosition] = useState(ORIGIN);
+	useWindowEvent("mousemove", (event) => setPosition({
+		x: event.clientX,
+		y: event.clientY
+	}));
+	return position;
+};
+//#endregion
+export { useMouse, useMousePosition };

package/dist/use-network.d.ts

@@ -0,0 +1,17 @@
+//#region src/use-network.d.ts
+type EffectiveType = "slow-2g" | "2g" | "3g" | "4g";
+type ConnectionType = "bluetooth" | "cellular" | "ethernet" | "wifi" | "wimax" | "none" | "other" | "unknown";
+type NetworkStatus = {
+  downlink?: number;
+  downlinkMax?: number;
+  effectiveType?: EffectiveType;
+  rtt?: number;
+  saveData?: boolean;
+  type?: ConnectionType;
+};
+type NetworkState = NetworkStatus & {
+  online: boolean;
+};
+declare const useNetwork: () => NetworkState;
+//#endregion
+export { useNetwork };

package/dist/use-network.js

@@ -0,0 +1,38 @@
+import { useMemo, useSyncExternalStore } from "react";
+//#region src/use-network.ts
+const getConnection = () => {
+	if (typeof navigator === "undefined") return;
+	const nav = navigator;
+	return nav.connection ?? nav.mozConnection ?? nav.webkitConnection;
+};
+const readNetworkState = () => {
+	const connection = getConnection();
+	return {
+		online: typeof navigator !== "undefined" ? navigator.onLine : true,
+		downlink: connection?.downlink,
+		downlinkMax: connection?.downlinkMax,
+		effectiveType: connection?.effectiveType,
+		rtt: connection?.rtt,
+		saveData: connection?.saveData,
+		type: connection?.type
+	};
+};
+const subscribe = (callback) => {
+	const connection = getConnection();
+	window.addEventListener("online", callback);
+	window.addEventListener("offline", callback);
+	connection?.addEventListener("change", callback);
+	return () => {
+		window.removeEventListener("online", callback);
+		window.removeEventListener("offline", callback);
+		connection?.removeEventListener("change", callback);
+	};
+};
+const getSnapshot = () => JSON.stringify(readNetworkState());
+const getServerSnapshot = () => JSON.stringify({ online: true });
+const useNetwork = () => {
+	const snapshot = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+	return useMemo(() => JSON.parse(snapshot), [snapshot]);
+};
+//#endregion
+export { useNetwork };

package/dist/use-page-leave.d.ts

@@ -0,0 +1,4 @@
+//#region src/use-page-leave.d.ts
+declare const usePageLeave: (onPageLeave: () => void) => void;
+//#endregion
+export { usePageLeave };

package/dist/use-page-leave.js

@@ -0,0 +1,11 @@
+import { useEffect, useEffectEvent } from "react";
+//#region src/use-page-leave.ts
+const usePageLeave = (onPageLeave) => {
+	const onPageLeaveEvent = useEffectEvent(onPageLeave);
+	useEffect(() => {
+		document.documentElement.addEventListener("mouseleave", onPageLeaveEvent);
+		return () => document.documentElement.removeEventListener("mouseleave", onPageLeaveEvent);
+	}, []);
+};
+//#endregion
+export { usePageLeave };

package/dist/use-pagination.d.ts

@@ -0,0 +1,19 @@
+//#region src/use-pagination.d.ts
+declare const DOTS: "...";
+type PaginationItem = number | typeof DOTS;
+type UsePaginationOptions = {
+  initialPage?: number;
+  page?: number;
+  total: number;
+  siblings?: number;
+  boundaries?: number;
+  onChange?: (page: number) => void;
+};
+type UsePaginationReturnValue = {
+  range: PaginationItem[];
+  active: number;
+  setPage: (page: number) => void;
+};
+declare const usePagination: ({ total, siblings, boundaries, page, initialPage, onChange }: UsePaginationOptions) => UsePaginationReturnValue;
+//#endregion
+export { DOTS, usePagination };

package/dist/use-pagination.js

@@ -0,0 +1,55 @@
+import { useUncontrolled } from "./use-uncontrolled.js";
+import { useMemo } from "react";
+//#region src/use-pagination.ts
+const DOTS = "...";
+const range = (start, end) => Array.from({ length: end - start + 1 }, (_, index) => index + start);
+const usePagination = ({ total, siblings = 1, boundaries = 1, page, initialPage = 1, onChange }) => {
+	const totalPages = Math.max(Math.trunc(total), 0);
+	const [activePage, setPage] = useUncontrolled({
+		value: page,
+		defaultValue: initialPage,
+		finalValue: initialPage,
+		onChange
+	});
+	return {
+		range: useMemo(() => {
+			if (siblings * 2 + 3 + boundaries * 2 >= totalPages) return range(1, totalPages);
+			const leftSiblingIndex = Math.max(activePage - siblings, boundaries);
+			const rightSiblingIndex = Math.min(activePage + siblings, totalPages - boundaries);
+			const shouldShowLeftDots = leftSiblingIndex > boundaries + 2;
+			const shouldShowRightDots = rightSiblingIndex < totalPages - (boundaries + 1);
+			if (!shouldShowLeftDots && shouldShowRightDots) {
+				const leftItemCount = siblings * 2 + boundaries + 2;
+				return [
+					...range(1, leftItemCount),
+					"...",
+					...range(totalPages - (boundaries - 1), totalPages)
+				];
+			}
+			if (shouldShowLeftDots && !shouldShowRightDots) {
+				const rightItemCount = boundaries + 1 + 2 * siblings;
+				return [
+					...range(1, boundaries),
+					"...",
+					...range(totalPages - rightItemCount, totalPages)
+				];
+			}
+			return [
+				...range(1, boundaries),
+				"...",
+				...range(leftSiblingIndex, rightSiblingIndex),
+				"...",
+				...range(totalPages - boundaries + 1, totalPages)
+			];
+		}, [
+			totalPages,
+			siblings,
+			activePage,
+			boundaries
+		]),
+		active: activePage,
+		setPage
+	};
+};
+//#endregion
+export { DOTS, usePagination };

package/dist/use-reduced-motion.d.ts

@@ -0,0 +1,4 @@
+//#region src/use-reduced-motion.d.ts
+declare const useReducedMotion: () => boolean;
+//#endregion
+export { useReducedMotion };

package/dist/use-reduced-motion.js

@@ -0,0 +1,5 @@
+import { useMediaQuery } from "./use-media-query.js";
+//#region src/use-reduced-motion.ts
+const useReducedMotion = () => useMediaQuery("(prefers-reduced-motion: reduce)");
+//#endregion
+export { useReducedMotion };

package/dist/use-scroll-direction.d.ts

@@ -0,0 +1,5 @@
+//#region src/use-scroll-direction.d.ts
+type ScrollDirection = "up" | "down" | "unknown";
+declare const useScrollDirection: () => ScrollDirection;
+//#endregion
+export { useScrollDirection };

package/dist/use-scroll-direction.js

@@ -0,0 +1,33 @@
+import { useEffect, useEffectEvent, useRef, useState } from "react";
+//#region src/use-scroll-direction.ts
+const useScrollDirection = () => {
+	const lastScrollTopRef = useRef(0);
+	const [scrollDirection, setScrollDirection] = useState("unknown");
+	const isResizingRef = useRef(false);
+	const resizeTimerRef = useRef(void 0);
+	const handleScroll = useEffectEvent(() => {
+		if (isResizingRef.current) return;
+		const currentScrollTop = window.scrollY || document.documentElement.scrollTop;
+		setScrollDirection(currentScrollTop < lastScrollTopRef.current ? "up" : "down");
+		lastScrollTopRef.current = currentScrollTop;
+	});
+	useEffect(() => {
+		const handleResize = () => {
+			isResizingRef.current = true;
+			window.clearTimeout(resizeTimerRef.current);
+			resizeTimerRef.current = window.setTimeout(() => {
+				isResizingRef.current = false;
+			}, 300);
+		};
+		window.addEventListener("scroll", handleScroll);
+		window.addEventListener("resize", handleResize);
+		return () => {
+			window.removeEventListener("scroll", handleScroll);
+			window.removeEventListener("resize", handleResize);
+			clearTimeout(resizeTimerRef.current);
+		};
+	}, []);
+	return scrollDirection;
+};
+//#endregion
+export { useScrollDirection };

package/dist/use-uncontrolled.d.ts

@@ -0,0 +1,11 @@
+//#region src/use-uncontrolled.d.ts
+type UseUncontrolledOptions<T> = {
+  value?: T;
+  defaultValue?: T;
+  finalValue?: T;
+  onChange?: (value: T, ...payload: unknown[]) => void;
+};
+type UseUncontrolledReturnValue<T> = [T, (value: T, ...payload: unknown[]) => void, boolean];
+declare const useUncontrolled: <T>({ value, defaultValue, finalValue, onChange }: UseUncontrolledOptions<T>) => UseUncontrolledReturnValue<T>;
+//#endregion
+export { type UseUncontrolledOptions, type UseUncontrolledReturnValue, useUncontrolled };

package/dist/use-uncontrolled.js

@@ -0,0 +1,21 @@
+import { useState } from "react";
+//#region src/use-uncontrolled.ts
+const useUncontrolled = ({ value, defaultValue, finalValue, onChange = () => {} }) => {
+	const [uncontrolledValue, setUncontrolledValue] = useState(defaultValue !== void 0 ? defaultValue : finalValue);
+	const handleUncontrolledChange = (val, ...payload) => {
+		setUncontrolledValue(val);
+		onChange(val, ...payload);
+	};
+	if (value !== void 0) return [
+		value,
+		onChange,
+		true
+	];
+	return [
+		uncontrolledValue,
+		handleUncontrolledChange,
+		false
+	];
+};
+//#endregion
+export { useUncontrolled };

package/dist/use-validated-state.d.ts

@@ -0,0 +1,10 @@
+//#region src/use-validated-state.d.ts
+type UseValidatedStateValue<T> = {
+  value: T;
+  lastValidValue: T | undefined;
+  valid: boolean;
+};
+type UseValidatedStateReturnValue<T> = [UseValidatedStateValue<T>, (value: T) => void];
+declare const useValidatedState: <T>(initialValue: T, validate: (value: T) => boolean, initialValidationState?: boolean) => UseValidatedStateReturnValue<T>;
+//#endregion
+export { type UseValidatedStateReturnValue, type UseValidatedStateValue, useValidatedState };

package/dist/use-validated-state.js

@@ -0,0 +1,22 @@
+import { useCallback, useState } from "react";
+//#region src/use-validated-state.ts
+const useValidatedState = (initialValue, validate, initialValidationState) => {
+	const [state, setState] = useState(() => {
+		const valid = validate(initialValue);
+		return {
+			value: initialValue,
+			lastValidValue: valid ? initialValue : void 0,
+			valid: initialValidationState ?? valid
+		};
+	});
+	return [state, useCallback((value) => {
+		const valid = validate(value);
+		setState((previous) => ({
+			value,
+			lastValidValue: valid ? value : previous.lastValidValue,
+			valid
+		}));
+	}, [validate])];
+};
+//#endregion
+export { useValidatedState };

package/dist/use-window-event.d.ts

@@ -0,0 +1,5 @@
+//#region src/use-window-event.d.ts
+type WindowEventListener<K extends string> = K extends keyof WindowEventMap ? (event: WindowEventMap[K]) => void : (event: CustomEvent) => void;
+declare const useWindowEvent: <K extends string>(type: K, listener: WindowEventListener<K>, options?: boolean | AddEventListenerOptions) => void;
+//#endregion
+export { useWindowEvent };

package/dist/use-window-event.js

@@ -0,0 +1,11 @@
+import { useEffect, useEffectEvent } from "react";
+//#region src/use-window-event.ts
+const useWindowEvent = (type, listener, options) => {
+	const onEvent = useEffectEvent((event) => listener(event));
+	useEffect(() => {
+		window.addEventListener(type, onEvent, options);
+		return () => window.removeEventListener(type, onEvent, options);
+	}, [type, options]);
+};
+//#endregion
+export { useWindowEvent };

package/dist/use-window-scroll.d.ts

@@ -0,0 +1,10 @@
+//#region src/use-window-scroll.d.ts
+type UseWindowScrollPosition = {
+  x: number;
+  y: number;
+};
+type UseWindowScrollTo = (position: Partial<UseWindowScrollPosition>) => void;
+type UseWindowScrollReturnValue = [UseWindowScrollPosition, UseWindowScrollTo];
+declare const useWindowScroll: () => UseWindowScrollReturnValue;
+//#endregion
+export { type UseWindowScrollPosition, type UseWindowScrollReturnValue, type UseWindowScrollTo, useWindowScroll };