react-kanca 1.6.0 → 1.6.1

package/dist/index.modern.js

@@ -1,844 +0,0 @@
-import React, { useState, useEffect, useRef, cloneElement, useCallback, useLayoutEffect, useReducer, Component } from 'react';
-import Cookies from 'js-cookie';
-
-const usePageVisible = () => {
-  const [isVisible, setIsVisible] = useState(true);
-  const handleVisibilityChange = () => {
-    setIsVisible(document.visibilityState === 'visible');
-  };
-  useEffect(() => {
-    document.addEventListener('visibilitychange', handleVisibilityChange);
-    return () => {
-      document.removeEventListener('visibilitychange', handleVisibilityChange);
-    };
-  }, []);
-  return isVisible;
-};
-
-const useWindowSize = () => {
-  const [size, setSize] = useState({
-    width: '',
-    height: ''
-  });
-  useEffect(() => {
-    const handleResize = () => {
-      setSize({
-        width: window.innerWidth,
-        height: window.innerHeight
-      });
-    };
-    window.addEventListener('resize', handleResize);
-    handleResize();
-    return () => {
-      window.removeEventListener('resize', handleResize);
-    };
-  }, []);
-  return size;
-};
-
-const useDebounce = () => {
-  const [debouncedValue, setDebouncedValue] = useState(null);
-  const debounce = (value, delay) => {
-    const handler = setTimeout(() => {
-      if (typeof value === 'function') {
-        value();
-      } else {
-        setDebouncedValue(value);
-      }
-    }, delay);
-    return () => {
-      clearTimeout(handler);
-    };
-  };
-  return [debouncedValue, debounce];
-};
-
-const usePrevious = value => {
-  const ref = useRef();
-  useEffect(() => {
-    ref.current = value;
-  });
-  return ref.current;
-};
-
-const noop = () => {};
-function on(obj, ...args) {
-  if (obj && obj.addEventListener) {
-    obj.addEventListener(...args);
-  }
-}
-function off(obj, ...args) {
-  if (obj && obj.removeEventListener) {
-    obj.removeEventListener(...args);
-  }
-}
-const isBrowser = typeof window !== 'undefined';
-
-const useHover = element => {
-  const [state, setState] = useState(false);
-  const onMouseEnter = originalOnMouseEnter => event => {
-    setState(true);
-  };
-  const onMouseLeave = originalOnMouseLeave => event => {
-    setState(false);
-  };
-  if (typeof element === 'function') {
-    element = element(state);
-  }
-  const el = cloneElement(element, {
-    onMouseEnter: onMouseEnter(),
-    onMouseLeave: onMouseLeave()
-  });
-  return [el, state];
-};
-
-const useScrolling = ref => {
-  const [scrolling, setScrolling] = useState(false);
-  useEffect(() => {
-    if (ref.current) {
-      let scrollingTimeout;
-      const handleScrollEnd = () => {
-        setScrolling(false);
-      };
-      const handleScroll = () => {
-        setScrolling(true);
-        clearTimeout(scrollingTimeout);
-        scrollingTimeout = setTimeout(() => handleScrollEnd(), 150);
-      };
-      on(ref.current, 'scroll', handleScroll, false);
-      return () => {
-        if (ref.current) {
-          off(ref.current, 'scroll', handleScroll, false);
-        }
-      };
-    }
-    return () => {};
-  }, [ref]);
-  return scrolling;
-};
-
-const useBeforeUnload = (enabled = true, message) => {
-  const handler = useCallback(event => {
-    const finalEnabled = typeof enabled === 'function' ? enabled() : true;
-    if (!finalEnabled) {
-      return;
-    }
-    event.preventDefault();
-    if (message) {
-      event.returnValue = message;
-    }
-    return message;
-  }, [enabled, message]);
-  useEffect(() => {
-    if (!enabled) {
-      return;
-    }
-    on(window, 'beforeunload', handler);
-    return () => off(window, 'beforeunload', handler);
-  }, [enabled, handler]);
-};
-
-const useEffectOnce = effect => {
-  useEffect(effect, []);
-};
-const useUnmount = fn => {
-  const fnRef = useRef(fn);
-  fnRef.current = fn;
-  useEffectOnce(() => () => fnRef.current());
-};
-const useThrottle = (value, ms = 200) => {
-  const [state, setState] = useState(value);
-  const timeout = useRef();
-  const nextValue = useRef(null);
-  const hasNextValue = useRef(0);
-  useEffect(() => {
-    if (!timeout.current) {
-      setState(value);
-      const timeoutCallback = () => {
-        if (hasNextValue.current) {
-          hasNextValue.current = false;
-          setState(nextValue.current);
-          timeout.current = setTimeout(timeoutCallback, ms);
-        } else {
-          timeout.current = undefined;
-        }
-      };
-      timeout.current = setTimeout(timeoutCallback, ms);
-    } else {
-      nextValue.current = value;
-      hasNextValue.current = true;
-    }
-  }, [value]);
-  useUnmount(() => {
-    timeout.current && clearTimeout(timeout.current);
-  });
-  return state;
-};
-
-const useLocalStorage = (key, initialValue, options) => {
-  if (!isBrowser) {
-    return [initialValue, noop, noop];
-  }
-  if (!key) {
-    throw new Error('useLocalStorage key may not be falsy');
-  }
-  const deserializer = options ? options.raw ? value => value : options.deserializer : JSON.parse;
-  const initializer = useRef(key => {
-    try {
-      const serializer = options ? options.raw ? String : options.serializer : JSON.stringify;
-      const localStorageValue = localStorage.getItem(key);
-      if (localStorageValue !== null) {
-        return deserializer(localStorageValue);
-      } else {
-        initialValue && localStorage.setItem(key, serializer(initialValue));
-        return initialValue;
-      }
-    } catch {
-      return initialValue;
-    }
-  });
-  const [state, setState] = useState(() => initializer.current(key));
-  useLayoutEffect(() => setState(initializer.current(key)), [key]);
-  const set = useCallback(valOrFunc => {
-    try {
-      const newState = typeof valOrFunc === 'function' ? valOrFunc(state) : valOrFunc;
-      if (typeof newState === 'undefined') return;
-      let value;
-      if (options) {
-        if (options.raw) {
-          if (typeof newState === 'string') value = newState;else value = JSON.stringify(newState);
-        } else if (options.serializer) value = options.serializer(newState);else value = JSON.stringify(newState);
-      } else value = JSON.stringify(newState);
-      localStorage.setItem(key, value);
-      setState(deserializer(value));
-    } catch {}
-  }, [key, setState]);
-  const remove = useCallback(() => {
-    try {
-      localStorage.removeItem(key);
-      setState(undefined);
-    } catch {}
-  }, [key, setState]);
-  return [state, set, remove];
-};
-
-const useEqualObject = (obj1, obj2) => {
-  if (obj1 === obj2) return true;
-  if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) return false;
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-  if (keys1.length !== keys2.length) return false;
-  for (let key of keys1) {
-    if (!keys2.includes(key) || !useEqualObject(obj1[key], obj2[key])) return false;
-  }
-  return true;
-};
-
-const useCookie = cookieName => {
-  const [value, setValue] = useState(() => Cookies.get(cookieName) || null);
-  const updateCookie = useCallback((newValue, options) => {
-    Cookies.set(cookieName, newValue, options);
-    setValue(newValue);
-  }, [cookieName]);
-  const deleteCookie = useCallback(() => {
-    Cookies.remove(cookieName);
-    setValue(null);
-  }, [cookieName]);
-  return [value, updateCookie, deleteCookie];
-};
-
-const useGeolocation = options => {
-  const [state, setState] = useState({
-    loading: true,
-    accuracy: null,
-    altitude: null,
-    altitudeAccuracy: null,
-    heading: null,
-    latitude: null,
-    longitude: null,
-    speed: null,
-    timestamp: Date.now()
-  });
-  let mounted = true;
-  let watchId;
-  const onEvent = event => {
-    if (mounted) {
-      setState({
-        loading: false,
-        accuracy: event.coords.accuracy,
-        altitude: event.coords.altitude,
-        altitudeAccuracy: event.coords.altitudeAccuracy,
-        heading: event.coords.heading,
-        latitude: event.coords.latitude,
-        longitude: event.coords.longitude,
-        speed: event.coords.speed,
-        timestamp: event.timestamp
-      });
-    }
-  };
-  const onEventError = error => mounted && setState(oldState => ({
-    ...oldState,
-    loading: false,
-    error
-  }));
-  useEffect(() => {
-    navigator.geolocation.getCurrentPosition(onEvent, onEventError, options);
-    watchId = navigator.geolocation.watchPosition(onEvent, onEventError, options);
-    return () => {
-      mounted = false;
-      navigator.geolocation.clearWatch(watchId);
-    };
-  }, []);
-  return state;
-};
-
-const useIsFirstRender = () => {
-  const isFirstRender = useRef(true);
-  useEffect(() => {
-    isFirstRender.current = false;
-  }, []);
-  return isFirstRender.current;
-};
-
-const useConnection = () => {
-  const [status, setStatus] = useState(true);
-  useEffect(() => {
-    const events = ['online', 'offline'];
-    const eventHandle = () => setStatus(navigator.online);
-    events.forEach(event => window.addEventListener(event, eventHandle));
-    return () => {
-      events.forEach(event => window.removeEventListener(event, eventHandle));
-    };
-  }, []);
-  return {
-    status
-  };
-};
-
-const useBatteryInfo = () => {
-  const [batteryLevel, setBatteryLevel] = useState(null);
-  const [isCharging, setIsCharging] = useState(null);
-  const [dischargingTime, setDischargingTime] = useState(null);
-  useEffect(() => {
-    const getBatteryInfo = async () => {
-      try {
-        const battery = await navigator.getBattery();
-        const updateBatteryInfo = () => {
-          setBatteryLevel(Math.round(battery.level * 100));
-          setIsCharging(battery.charging);
-          setDischargingTime(battery.dischargingTime);
-        };
-        updateBatteryInfo();
-        battery.addEventListener('chargingchange', updateBatteryInfo);
-        battery.addEventListener('levelchange', updateBatteryInfo);
-        battery.addEventListener('chargingtimechange', updateBatteryInfo);
-        battery.addEventListener('dischargingtimechange', updateBatteryInfo);
-        return () => {
-          battery.removeEventListener('chargingchange', updateBatteryInfo);
-          battery.removeEventListener('levelchange', updateBatteryInfo);
-          battery.removeEventListener('chargingtimechange', updateBatteryInfo);
-          battery.removeEventListener('dischargingtimechange', updateBatteryInfo);
-        };
-      } catch (error) {
-        console.error('Batarya bilgisi alınamadı: ' + error.message);
-      }
-    };
-    getBatteryInfo();
-    return () => {};
-  }, []);
-  return {
-    batteryLevel,
-    isCharging,
-    dischargingTime
-  };
-};
-
-const useCopyToClipboard = () => {
-  const [copied, setCopied] = useState(false);
-  const [error, setError] = useState(false);
-  const copyToClipboard = text => {
-    navigator.clipboard.writeText(text).then(() => {
-      setCopied(true);
-    }).catch(err => {
-      setError(err);
-    });
-  };
-  return {
-    copied,
-    error,
-    copyToClipboard
-  };
-};
-
-const useMedia = (width = 1024) => {
-  const [screenStatus, setScreenStatus] = useState(window.matchMedia(`(max-width: ${width}px)`).matches);
-  useEffect(() => {
-    const matchMedia = window.matchMedia(`(max-width: ${width}px)`);
-    const onChangeHandle = e => {
-      console.log(e.matches);
-      setScreenStatus(e.matches);
-    };
-    matchMedia.addEventListener('change', onChangeHandle);
-  });
-  return screenStatus;
-};
-
-const useClickOutside = (ref, callback) => {
-  const handleClick = e => {
-    if (ref.current && !ref.current.contains(e.target)) {
-      callback();
-    }
-  };
-  useEffect(() => {
-    document.addEventListener('click', handleClick);
-    return () => {
-      document.removeEventListener('click', handleClick);
-    };
-  });
-};
-
-const useColorScheme = () => {
-  const [colorScheme, setColorScheme] = useState(getInitialColorScheme());
-  useEffect(() => {
-    const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
-    const listener = e => {
-      setColorScheme(e.matches ? 'dark' : 'light');
-    };
-    mediaQuery.addEventListener('change', listener);
-    return () => {
-      mediaQuery.removeEventListener('change', listener);
-    };
-  }, []);
-  function getInitialColorScheme() {
-    const isDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches;
-    return isDarkMode ? 'dark' : 'light';
-  }
-  return colorScheme;
-};
-
-const useFullScreen = () => {
-  const [isFullScreen, setIsFullScreen] = useState(false);
-  const enterFullScreen = () => {
-    if (document.documentElement.requestFullscreen) {
-      document.documentElement.requestFullscreen();
-    } else if (document.documentElement.mozRequestFullScreen) {
-      document.documentElement.mozRequestFullScreen();
-    } else if (document.documentElement.webkitRequestFullscreen) {
-      document.documentElement.webkitRequestFullscreen();
-    } else if (document.documentElement.msRequestFullscreen) {
-      document.documentElement.msRequestFullscreen();
-    }
-    setIsFullScreen(true);
-  };
-  const exitFullScreen = () => {
-    if (document.exitFullscreen) {
-      document.exitFullscreen();
-    } else if (document.mozCancelFullScreen) {
-      document.mozCancelFullScreen();
-    } else if (document.webkitExitFullscreen) {
-      document.webkitExitFullscreen();
-    } else if (document.msExitFullscreen) {
-      document.msExitFullscreen();
-    }
-    setIsFullScreen(false);
-  };
-  return {
-    isFullScreen,
-    enterFullScreen,
-    exitFullScreen
-  };
-};
-
-const useSessionStorage = (key, initialValue) => {
-  const [storedValue, setStoredValue] = useState(() => {
-    try {
-      const item = window.sessionStorage.getItem(key);
-      return item ? JSON.parse(item) : initialValue;
-    } catch (error) {
-      console.error(error);
-      return initialValue;
-    }
-  });
-  const setValue = value => {
-    try {
-      setStoredValue(value);
-      window.sessionStorage.setItem(key, JSON.stringify(value));
-    } catch (error) {
-      console.error(error);
-    }
-  };
-  return [storedValue, setValue];
-};
-
-const useScrollLock = lock => {
-  useEffect(() => {
-    if (lock) {
-      document.body.style.overflow = 'hidden';
-    } else {
-      document.body.style.overflow = 'unset';
-    }
-    return () => {
-      document.body.style.overflow = 'unset';
-    };
-  }, [lock]);
-};
-
-const usePreferredLanguage = () => {
-  const [preferredLanguage, setPreferredLanguage] = useState('');
-  useEffect(() => {
-    const language = navigator.language || navigator.userLanguage;
-    setPreferredLanguage(language);
-  }, []);
-  return preferredLanguage;
-};
-
-function useMousePageLeave(onPageLeave) {
-  useEffect(() => {
-    document.documentElement.addEventListener('mouseleave', onPageLeave);
-    return () => document.documentElement.removeEventListener('mouseleave', onPageLeave);
-  }, []);
-}
-
-const usePageLeave = onLeave => {
-  useEffect(() => {
-    const handleBeforeUnload = event => {
-      const returnValue = onLeave();
-      if (returnValue) {
-        event.preventDefault();
-        event.returnValue = returnValue;
-        return returnValue;
-      }
-    };
-    window.addEventListener('beforeunload', handleBeforeUnload);
-    return () => {
-      window.removeEventListener('beforeunload', handleBeforeUnload);
-    };
-  }, [onLeave]);
-};
-
-const useForceUpdate = () => {
-  const [, setTick] = useState(0);
-  const update = useCallback(() => {
-    setTick(tick => tick + 1);
-  }, []);
-  return update;
-};
-
-const useInterval = (callback, delay) => {
-  const savedCallback = useRef(() => {});
-  useEffect(() => {
-    savedCallback.current = callback;
-  });
-  useEffect(() => {
-    if (delay !== null) {
-      const interval = setInterval(() => savedCallback.current(), delay || 0);
-      return () => clearInterval(interval);
-    }
-    return undefined;
-  }, [delay]);
-};
-
-const useIntersectionObserver = (targetRef, options) => {
-  const [isIntersecting, setIsIntersecting] = useState(false);
-  useEffect(() => {
-    const observer = new IntersectionObserver(([entry]) => {
-      setIsIntersecting(entry.isIntersecting);
-    }, options);
-    if (targetRef.current) {
-      observer.observe(targetRef.current);
-    }
-    return () => {
-      if (targetRef.current) {
-        observer.unobserve(targetRef.current);
-      }
-    };
-  }, [targetRef, options]);
-  return isIntersecting;
-};
-
-const useMobileLandscape = () => {
-  const [isLandscape, setIsLandscape] = useState(false);
-  const [isMobile, setIsMobile] = useState(false);
-  const [isMobileLandscape, setIsMobileLandscape] = useState(false);
-  const handleResize = () => {
-    const landscape = window.innerWidth > window.innerHeight;
-    const mobile = window.innerWidth <= 996;
-    setIsLandscape(landscape);
-    setIsMobile(mobile);
-    setIsMobileLandscape(landscape && mobile);
-  };
-  useEffect(() => {
-    handleResize();
-    window.addEventListener('resize', handleResize);
-    return () => {
-      window.removeEventListener('resize', handleResize);
-    };
-  }, []);
-  return {
-    isMobileLandscape,
-    isLandscape,
-    isMobile
-  };
-};
-
-const useOnlineStatus = () => {
-  const [isOnline, setIsOnline] = useState(navigator.onLine);
-  useEffect(() => {
-    const handleOnline = () => setIsOnline(true);
-    const handleOffline = () => setIsOnline(false);
-    window.addEventListener('online', handleOnline);
-    window.addEventListener('offline', handleOffline);
-    return () => {
-      window.removeEventListener('online', handleOnline);
-      window.removeEventListener('offline', handleOffline);
-    };
-  }, []);
-  return isOnline;
-};
-
-const useScrollToElement = () => {
-  const scrollToElement = useCallback((selectorOrRef, options = {}) => {
-    let element;
-    if (typeof selectorOrRef === 'string') {
-      element = document.querySelector(selectorOrRef);
-    } else if (selectorOrRef.current) {
-      element = selectorOrRef.current;
-    }
-    if (element) {
-      element.scrollIntoView({
-        behavior: 'smooth',
-        ...options
-      });
-    }
-  }, []);
-  return scrollToElement;
-};
-
-const useStateValidator = (state, validator, initialState = [undefined]) => {
-  const validatorInner = useRef(validator);
-  const stateInner = useRef(state);
-  validatorInner.current = validator;
-  stateInner.current = state;
-  const [validity, setValidity] = useState(initialState);
-  const validate = useCallback(() => {
-    if (validatorInner.current.length >= 2) {
-      validatorInner.current(stateInner.current, setValidity);
-    } else {
-      setValidity(validatorInner.current(stateInner.current));
-    }
-  }, [setValidity]);
-  useEffect(() => {
-    validate();
-  }, [state]);
-  return [validity, validate];
-};
-
-const useMultiStateValidator = (states, validator, initialValidity = [undefined]) => {
-  if (typeof states !== 'object') {
-    throw new Error("state'in bir nesne ya da dizi olması beklenirken -> " + typeof states);
-  }
-  const validatorInner = useRef(validator);
-  const statesInner = useRef(states);
-  validatorInner.current = validator;
-  statesInner.current = states;
-  const [validity, setValidity] = useState(initialValidity);
-  const validate = useCallback(() => {
-    if (validatorInner.current.length >= 2) {
-      validatorInner.current(statesInner.current, setValidity);
-    } else {
-      setValidity(validatorInner.current(statesInner.current));
-    }
-  }, [setValidity]);
-  useEffect(() => {
-    validate();
-  }, Object.values(states));
-  return [validity, validate];
-};
-
-const useWindowScroll = () => {
-  const [state, setState] = useState(() => ({
-    x: isBrowser ? window.pageXOffset : 0,
-    y: isBrowser ? window.pageYOffset : 0
-  }));
-  useEffect(() => {
-    const handler = () => {
-      setState(state => {
-        const {
-          pageXOffset,
-          pageYOffset
-        } = window;
-        return state.x !== pageXOffset || state.y !== pageYOffset ? {
-          x: pageXOffset,
-          y: pageYOffset
-        } : state;
-      });
-    };
-    handler();
-    on(window, 'scroll', handler, {
-      capture: false,
-      passive: true
-    });
-    return () => {
-      off(window, 'scroll', handler);
-    };
-  }, []);
-  return state;
-};
-
-const useSelection = () => {
-  const elementRef = useRef(null);
-  const getSelectedText = () => {
-    if (elementRef.current) {
-      const selection = window.getSelection();
-      const range = selection.getRangeAt(0);
-      return range.toString();
-    }
-    return '';
-  };
-  return {
-    elementRef,
-    getSelectedText
-  };
-};
-
-const useUpdateEffect = (effect, dependencies) => {
-  const isFirstRender = useIsFirstRender();
-  useEffect(() => {
-    if (!isFirstRender) {
-      return effect();
-    }
-  }, dependencies);
-};
-
-const initialState = {
-  data: null,
-  loading: true,
-  error: null
-};
-const fetchReducer = (state, action) => {
-  switch (action.type) {
-    case 'FETCH_INIT':
-      return {
-        ...state,
-        loading: true,
-        error: null
-      };
-    case 'FETCH_SUCCESS':
-      return {
-        ...state,
-        loading: false,
-        data: action.payload
-      };
-    case 'FETCH_FAILURE':
-      return {
-        ...state,
-        loading: false,
-        error: action.payload
-      };
-    default:
-      throw new Error();
-  }
-};
-const useFetch = (url, options) => {
-  const [state, dispatch] = useReducer(fetchReducer, initialState);
-  useEffect(() => {
-    if (!url) return;
-    const fetchData = async () => {
-      dispatch({
-        type: 'FETCH_INIT'
-      });
-      try {
-        const response = await fetch(url, options);
-        if (!response.ok) {
-          throw new Error(`HTTP error! Status: ${response.status}`);
-        }
-        const result = await response.json();
-        dispatch({
-          type: 'FETCH_SUCCESS',
-          payload: result
-        });
-      } catch (error) {
-        dispatch({
-          type: 'FETCH_FAILURE',
-          payload: error.message
-        });
-      }
-    };
-    fetchData();
-  }, [url, options]);
-  return state;
-};
-
-class ErrorBoundaryKanca extends Component {
-  constructor(props) {
-    super(props);
-    this.state = {
-      hasError: false
-    };
-  }
-  static getDerivedStateFromError(error) {
-    return {
-      hasError: true
-    };
-  }
-  componentDidCatch(error, info) {
-    console.error('Hata:', error, info);
-  }
-  render() {
-    if (this.state.hasError) {
-      const fallback = this.props.fallback;
-      if (typeof fallback === 'function') {
-        return fallback();
-      }
-      return /*#__PURE__*/React.createElement("h1", null, fallback || 'Bir hata meydana geldi. Lütfen daha sonra tekrar deneyin.');
-    }
-    return this.props.children;
-  }
-}
-
-const useURLSearchParams = () => {
-  const [searchParams, setSearchParams] = useState(new URLSearchParams(window.location.search));
-  useEffect(() => {
-    const handlePopState = () => {
-      setSearchParams(new URLSearchParams(window.location.search));
-    };
-    window.addEventListener('popstate', handlePopState);
-    return () => {
-      window.removeEventListener('popstate', handlePopState);
-    };
-  }, []);
-  const updateSearchParams = newParams => {
-    const params = new URLSearchParams(searchParams);
-    Object.keys(newParams).forEach(key => {
-      if (newParams[key] === null) {
-        params.delete(key);
-      } else {
-        params.set(key, newParams[key]);
-      }
-    });
-    const newUrl = `${window.location.pathname}?${params.toString()}`;
-    window.history.pushState({}, '', newUrl);
-    setSearchParams(params);
-  };
-  return [searchParams, updateSearchParams];
-};
-
-const useToggle = (initialValue = false) => {
-  const [value, setValue] = useState(initialValue);
-  const toggle = () => {
-    setValue(prevValue => !prevValue);
-  };
-  return [value, toggle];
-};
-
-const useDocumentTitle = title => {
-  useEffect(() => {
-    document.title = title;
-    return () => {
-      document.title = 'react-kanca';
-    };
-  }, [title]);
-};
-
-export { ErrorBoundaryKanca, useBatteryInfo, useBeforeUnload, useClickOutside, useColorScheme, useConnection, useCookie, useCopyToClipboard, useDebounce, useDocumentTitle, useEqualObject, useFetch, useForceUpdate, useFullScreen, useGeolocation, useHover, useIntersectionObserver, useInterval, useIsFirstRender, useLocalStorage, useMedia, useMobileLandscape, useMousePageLeave, useMultiStateValidator, useOnlineStatus, usePageLeave, usePageVisible, usePreferredLanguage, usePrevious, useScrollLock, useScrollToElement, useScrolling, useSelection, useSessionStorage, useStateValidator, useThrottle, useToggle, useURLSearchParams, useUpdateEffect, useWindowScroll, useWindowSize };
-//# sourceMappingURL=index.modern.js.map