☰

@mantine᜵hooks-umd

UMD of @mantine/hooks

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.gf.qytechs.cn/scripts/499180/1510107/%40mantine%E1%9C%B5hooks-umd.js 

  1. (function (global, factory) {
  2.   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
  3.   typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
  4.   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MantineHooks = {}, global.React));
  5. })(this, (function (exports, React) { 'use strict';
  6.   function clamp(value, min, max) {
  7.     if (min === void 0 && max === void 0) {
  8.       return value;
  9.     }
  10.     if (min !== void 0 && max === void 0) {
  11.       return Math.max(value, min);
  12.     }
  13.     if (min === void 0 && max !== void 0) {
  14.       return Math.min(value, max);
  15.     }
  16.     return Math.min(Math.max(value, min), max);
  17.   }
  18.   function lowerFirst(value) {
  19.     return typeof value !== "string" ? "" : value.charAt(0).toLowerCase() + value.slice(1);
  20.   }
  21.   function randomId(prefix = "mantine-") {
  22.     return `${prefix}${Math.random().toString(36).slice(2, 11)}`;
  23.   }
  24.   function range(start, end) {
  25.     const length = Math.abs(end - start) + 1;
  26.     const reversed = start > end;
  27.     if (!reversed) {
  28.       return Array.from({ length }, (_, index) => index + start);
  29.     }
  30.     return Array.from({ length }, (_, index) => start - index);
  31.   }
  32.   function shallowEqual(a, b) {
  33.     if (a === b) {
  34.       return true;
  35.     }
  36.     if (!(a instanceof Object) || !(b instanceof Object)) {
  37.       return false;
  38.     }
  39.     const keys = Object.keys(a);
  40.     const { length } = keys;
  41.     if (length !== Object.keys(b).length) {
  42.       return false;
  43.     }
  44.     for (let i = 0; i < length; i += 1) {
  45.       const key = keys[i];
  46.       if (!(key in b)) {
  47.         return false;
  48.       }
  49.       if (a[key] !== b[key]) {
  50.         return false;
  51.       }
  52.     }
  53.     return true;
  54.   }
  55.   function upperFirst(value) {
  56.     return typeof value !== "string" ? "" : value.charAt(0).toUpperCase() + value.slice(1);
  57.   }
  58.   function useCallbackRef(callback) {
  59.     const callbackRef = React.useRef(callback);
  60.     React.useEffect(() => {
  61.       callbackRef.current = callback;
  62.     });
  63.     return React.useMemo(() => (...args) => callbackRef.current?.(...args), []);
  64.   }
  65.   function useDebouncedCallback(callback, delay) {
  66.     const handleCallback = useCallbackRef(callback);
  67.     const debounceTimerRef = React.useRef(0);
  68.     React.useEffect(() => () => window.clearTimeout(debounceTimerRef.current), []);
  69.     return React.useCallback(
  70.       (...args) => {
  71.         window.clearTimeout(debounceTimerRef.current);
  72.         debounceTimerRef.current = window.setTimeout(() => handleCallback(...args), delay);
  73.       },
  74.       [handleCallback, delay]
  75.     );
  76.   }
  77.   var DEFAULT_EVENTS = ["mousedown", "touchstart"];
  78.   function useClickOutside(handler, events, nodes) {
  79.     const ref = React.useRef(null);
  80.     React.useEffect(() => {
  81.       const listener = (event) => {
  82.         const { target } = event ?? {};
  83.         if (Array.isArray(nodes)) {
  84.           const shouldIgnore = target?.hasAttribute("data-ignore-outside-clicks") || !document.body.contains(target) && target.tagName !== "HTML";
  85.           const shouldTrigger = nodes.every((node) => !!node && !event.composedPath().includes(node));
  86.           shouldTrigger && !shouldIgnore && handler();
  87.         } else if (ref.current && !ref.current.contains(target)) {
  88.           handler();
  89.         }
  90.       };
  91.       (events || DEFAULT_EVENTS).forEach((fn) => document.addEventListener(fn, listener));
  92.       return () => {
  93.         (events || DEFAULT_EVENTS).forEach((fn) => document.removeEventListener(fn, listener));
  94.       };
  95.     }, [ref, handler, nodes]);
  96.     return ref;
  97.   }
  98.   function useClipboard({ timeout = 2e3 } = {}) {
  99.     const [error, setError] = React.useState(null);
  100.     const [copied, setCopied] = React.useState(false);
  101.     const [copyTimeout, setCopyTimeout] = React.useState(null);
  102.     const handleCopyResult = (value) => {
  103.       window.clearTimeout(copyTimeout);
  104.       setCopyTimeout(window.setTimeout(() => setCopied(false), timeout));
  105.       setCopied(value);
  106.     };
  107.     const copy = (valueToCopy) => {
  108.       if ("clipboard" in navigator) {
  109.         navigator.clipboard.writeText(valueToCopy).then(() => handleCopyResult(true)).catch((err) => setError(err));
  110.       } else {
  111.         setError(new Error("useClipboard: navigator.clipboard is not supported"));
  112.       }
  113.     };
  114.     const reset = () => {
  115.       setCopied(false);
  116.       setError(null);
  117.       window.clearTimeout(copyTimeout);
  118.     };
  119.     return { copy, reset, error, copied };
  120.   }
  121.   function attachMediaListener(query, callback) {
  122.     try {
  123.       query.addEventListener("change", callback);
  124.       return () => query.removeEventListener("change", callback);
  125.     } catch (e) {
  126.       query.addListener(callback);
  127.       return () => query.removeListener(callback);
  128.     }
  129.   }
  130.   function getInitialValue(query, initialValue) {
  131.     if (typeof window !== "undefined" && "matchMedia" in window) {
  132.       return window.matchMedia(query).matches;
  133.     }
  134.     return false;
  135.   }
  136.   function useMediaQuery(query, initialValue, { getInitialValueInEffect } = {
  137.     getInitialValueInEffect: true
  138.   }) {
  139.     const [matches, setMatches] = React.useState(
  140.       getInitialValueInEffect ? initialValue : getInitialValue(query)
  141.     );
  142.     const queryRef = React.useRef(null);
  143.     React.useEffect(() => {
  144.       if ("matchMedia" in window) {
  145.         queryRef.current = window.matchMedia(query);
  146.         setMatches(queryRef.current.matches);
  147.         return attachMediaListener(queryRef.current, (event) => setMatches(event.matches));
  148.       }
  149.       return void 0;
  150.     }, [query]);
  151.     return matches;
  152.   }
  153.   function useColorScheme(initialValue, options) {
  154.     return useMediaQuery("(prefers-color-scheme: dark)", initialValue === "dark", options) ? "dark" : "light";
  155.   }
  156.   var DEFAULT_OPTIONS = {
  157.     min: -Infinity,
  158.     max: Infinity
  159.   };
  160.   function useCounter(initialValue = 0, options) {
  161.     const { min, max } = { ...DEFAULT_OPTIONS, ...options };
  162.     const [count, setCount] = React.useState(clamp(initialValue, min, max));
  163.     const increment = () => setCount((current) => clamp(current + 1, min, max));
  164.     const decrement = () => setCount((current) => clamp(current - 1, min, max));
  165.     const set = (value) => setCount(clamp(value, min, max));
  166.     const reset = () => setCount(clamp(initialValue, min, max));
  167.     return [count, { increment, decrement, set, reset }];
  168.   }
  169.   function useDebouncedState(defaultValue, wait, options = { leading: false }) {
  170.     const [value, setValue] = React.useState(defaultValue);
  171.     const timeoutRef = React.useRef(null);
  172.     const leadingRef = React.useRef(true);
  173.     const clearTimeout2 = () => window.clearTimeout(timeoutRef.current);
  174.     React.useEffect(() => clearTimeout2, []);
  175.     const debouncedSetValue = React.useCallback(
  176.       (newValue) => {
  177.         clearTimeout2();
  178.         if (leadingRef.current && options.leading) {
  179.           setValue(newValue);
  180.         } else {
  181.           timeoutRef.current = window.setTimeout(() => {
  182.             leadingRef.current = true;
  183.             setValue(newValue);
  184.           }, wait);
  185.         }
  186.         leadingRef.current = false;
  187.       },
  188.       [options.leading]
  189.     );
  190.     return [value, debouncedSetValue];
  191.   }
  192.   function useDebouncedValue(value, wait, options = { leading: false }) {
  193.     const [_value, setValue] = React.useState(value);
  194.     const mountedRef = React.useRef(false);
  195.     const timeoutRef = React.useRef(null);
  196.     const cooldownRef = React.useRef(false);
  197.     const cancel = () => window.clearTimeout(timeoutRef.current);
  198.     React.useEffect(() => {
  199.       if (mountedRef.current) {
  200.         if (!cooldownRef.current && options.leading) {
  201.           cooldownRef.current = true;
  202.           setValue(value);
  203.         } else {
  204.           cancel();
  205.           timeoutRef.current = window.setTimeout(() => {
  206.             cooldownRef.current = false;
  207.             setValue(value);
  208.           }, wait);
  209.         }
  210.       }
  211.     }, [value, options.leading, wait]);
  212.     React.useEffect(() => {
  213.       mountedRef.current = true;
  214.       return cancel;
  215.     }, []);
  216.     return [_value, cancel];
  217.   }
  218.   var useIsomorphicEffect = typeof document !== "undefined" ? React.useLayoutEffect : React.useEffect;
  219.   function useDocumentTitle(title) {
  220.     useIsomorphicEffect(() => {
  221.       if (typeof title === "string" && title.trim().length > 0) {
  222.         document.title = title.trim();
  223.       }
  224.     }, [title]);
  225.   }
  226.   function useDocumentVisibility() {
  227.     const [documentVisibility, setDocumentVisibility] = React.useState("visible");
  228.     React.useEffect(() => {
  229.       const listener = () => setDocumentVisibility(document.visibilityState);
  230.       document.addEventListener("visibilitychange", listener);
  231.       return () => document.removeEventListener("visibilitychange", listener);
  232.     }, []);
  233.     return documentVisibility;
  234.   }
  235.   function useDidUpdate(fn, dependencies) {
  236.     const mounted = React.useRef(false);
  237.     React.useEffect(
  238.       () => () => {
  239.         mounted.current = false;
  240.       },
  241.       []
  242.     );
  243.     React.useEffect(() => {
  244.       if (mounted.current) {
  245.         return fn();
  246.       }
  247.       mounted.current = true;
  248.       return void 0;
  249.     }, dependencies);
  250.   }
  251.   function useFocusReturn({ opened, shouldReturnFocus = true }) {
  252.     const lastActiveElement = React.useRef(null);
  253.     const returnFocus = () => {
  254.       if (lastActiveElement.current && "focus" in lastActiveElement.current && typeof lastActiveElement.current.focus === "function") {
  255.         lastActiveElement.current?.focus({ preventScroll: true });
  256.       }
  257.     };
  258.     useDidUpdate(() => {
  259.       let timeout = -1;
  260.       const clearFocusTimeout = (event) => {
  261.         if (event.key === "Tab") {
  262.           window.clearTimeout(timeout);
  263.         }
  264.       };
  265.       document.addEventListener("keydown", clearFocusTimeout);
  266.       if (opened) {
  267.         lastActiveElement.current = document.activeElement;
  268.       } else if (shouldReturnFocus) {
  269.         timeout = window.setTimeout(returnFocus, 10);
  270.       }
  271.       return () => {
  272.         window.clearTimeout(timeout);
  273.         document.removeEventListener("keydown", clearFocusTimeout);
  274.       };
  275.     }, [opened, shouldReturnFocus]);
  276.     return returnFocus;
  277.   }
  278.   var TABBABLE_NODES = /input|select|textarea|button|object/;
  279.   var FOCUS_SELECTOR = "a, input, select, textarea, button, object, [tabindex]";
  280.   function hidden(element) {
  281.     return element.style.display === "none";
  282.   }
  283.   function visible(element) {
  284.     const isHidden = element.getAttribute("aria-hidden") || element.getAttribute("hidden") || element.getAttribute("type") === "hidden";
  285.     if (isHidden) {
  286.       return false;
  287.     }
  288.     let parentElement = element;
  289.     while (parentElement) {
  290.       if (parentElement === document.body || parentElement.nodeType === 11) {
  291.         break;
  292.       }
  293.       if (hidden(parentElement)) {
  294.         return false;
  295.       }
  296.       parentElement = parentElement.parentNode;
  297.     }
  298.     return true;
  299.   }
  300.   function getElementTabIndex(element) {
  301.     let tabIndex = element.getAttribute("tabindex");
  302.     if (tabIndex === null) {
  303.       tabIndex = void 0;
  304.     }
  305.     return parseInt(tabIndex, 10);
  306.   }
  307.   function focusable(element) {
  308.     const nodeName = element.nodeName.toLowerCase();
  309.     const isTabIndexNotNaN = !Number.isNaN(getElementTabIndex(element));
  310.     const res = (
  311.       
  312.       TABBABLE_NODES.test(nodeName) && !element.disabled || (element instanceof HTMLAnchorElement ? element.href || isTabIndexNotNaN : isTabIndexNotNaN)
  313.     );
  314.     return res && visible(element);
  315.   }
  316.   function tabbable(element) {
  317.     const tabIndex = getElementTabIndex(element);
  318.     const isTabIndexNaN = Number.isNaN(tabIndex);
  319.     return (isTabIndexNaN || tabIndex >= 0) && focusable(element);
  320.   }
  321.   function findTabbableDescendants(element) {
  322.     return Array.from(element.querySelectorAll(FOCUS_SELECTOR)).filter(tabbable);
  323.   }
  324.   function scopeTab(node, event) {
  325.     const tabbable2 = findTabbableDescendants(node);
  326.     if (!tabbable2.length) {
  327.       event.preventDefault();
  328.       return;
  329.     }
  330.     const finalTabbable = tabbable2[event.shiftKey ? 0 : tabbable2.length - 1];
  331.     const root = node.getRootNode();
  332.     let leavingFinalTabbable = finalTabbable === root.activeElement || node === root.activeElement;
  333.     const activeElement = root.activeElement;
  334.     const activeElementIsRadio = activeElement.tagName === "INPUT" && activeElement.getAttribute("type") === "radio";
  335.     if (activeElementIsRadio) {
  336.       const activeRadioGroup = tabbable2.filter(
  337.         (element) => element.getAttribute("type") === "radio" && element.getAttribute("name") === activeElement.getAttribute("name")
  338.       );
  339.       leavingFinalTabbable = activeRadioGroup.includes(finalTabbable);
  340.     }
  341.     if (!leavingFinalTabbable) {
  342.       return;
  343.     }
  344.     event.preventDefault();
  345.     const target = tabbable2[event.shiftKey ? tabbable2.length - 1 : 0];
  346.     if (target) {
  347.       target.focus();
  348.     }
  349.   }
  350.   function useFocusTrap(active = true) {
  351.     const ref = React.useRef(null);
  352.     const focusNode = (node) => {
  353.       let focusElement = node.querySelector("[data-autofocus]");
  354.       if (!focusElement) {
  355.         const children = Array.from(node.querySelectorAll(FOCUS_SELECTOR));
  356.         focusElement = children.find(tabbable) || children.find(focusable) || null;
  357.         if (!focusElement && focusable(node)) {
  358.           focusElement = node;
  359.         }
  360.       }
  361.       if (focusElement) {
  362.         focusElement.focus({ preventScroll: true });
  363.       } else {
  364.         console.warn(
  365.           "[@mantine/hooks/use-focus-trap] Failed to find focusable element within provided node",
  366.           node
  367.         );
  368.       }
  369.     };
  370.     const setRef = React.useCallback(
  371.       (node) => {
  372.         if (!active) {
  373.           return;
  374.         }
  375.         if (node === null) {
  376.           return;
  377.         }
  378.         if (ref.current === node) {
  379.           return;
  380.         }
  381.         if (node) {
  382.           setTimeout(() => {
  383.             if (node.getRootNode()) {
  384.               focusNode(node);
  385.             } else {
  386.               console.warn("[@mantine/hooks/use-focus-trap] Ref node is not part of the dom", node);
  387.             }
  388.           });
  389.           ref.current = node;
  390.         } else {
  391.           ref.current = null;
  392.         }
  393.       },
  394.       [active]
  395.     );
  396.     React.useEffect(() => {
  397.       if (!active) {
  398.         return void 0;
  399.       }
  400.       ref.current && setTimeout(() => focusNode(ref.current));
  401.       const handleKeyDown = (event) => {
  402.         if (event.key === "Tab" && ref.current) {
  403.           scopeTab(ref.current, event);
  404.         }
  405.       };
  406.       document.addEventListener("keydown", handleKeyDown);
  407.       return () => document.removeEventListener("keydown", handleKeyDown);
  408.     }, [active]);
  409.     return setRef;
  410.   }
  411.   var reducer = (value) => (value + 1) % 1e6;
  412.   function useForceUpdate() {
  413.     const [, update] = React.useReducer(reducer, 0);
  414.     return update;
  415.   }
  416.   var __useId = React["useId".toString()] || (() => void 0);
  417.   function useReactId() {
  418.     const id = __useId();
  419.     return id ? `mantine-${id.replace(/:/g, "")}` : "";
  420.   }
  421.   function useId(staticId) {
  422.     const reactId = useReactId();
  423.     const [uuid, setUuid] = React.useState(reactId);
  424.     useIsomorphicEffect(() => {
  425.       setUuid(randomId());
  426.     }, []);
  427.     if (typeof staticId === "string") {
  428.       return staticId;
  429.     }
  430.     if (typeof window === "undefined") {
  431.       return reactId;
  432.     }
  433.     return uuid;
  434.   }
  435.   var DEFAULT_EVENTS2 = [
  436.     "keypress",
  437.     "mousemove",
  438.     "touchmove",
  439.     "click",
  440.     "scroll"
  441.   ];
  442.   var DEFAULT_OPTIONS2 = {
  443.     events: DEFAULT_EVENTS2,
  444.     initialState: true
  445.   };
  446.   function useIdle(timeout, options) {
  447.     const { events, initialState } = { ...DEFAULT_OPTIONS2, ...options };
  448.     const [idle, setIdle] = React.useState(initialState);
  449.     const timer = React.useRef(-1);
  450.     React.useEffect(() => {
  451.       const handleEvents = () => {
  452.         setIdle(false);
  453.         if (timer.current) {
  454.           window.clearTimeout(timer.current);
  455.         }
  456.         timer.current = window.setTimeout(() => {
  457.           setIdle(true);
  458.         }, timeout);
  459.       };
  460.       events.forEach((event) => document.addEventListener(event, handleEvents));
  461.       timer.current = window.setTimeout(() => {
  462.         setIdle(true);
  463.       }, timeout);
  464.       return () => {
  465.         events.forEach((event) => document.removeEventListener(event, handleEvents));
  466.       };
  467.     }, [timeout]);
  468.     return idle;
  469.   }
  470.   function useInterval(fn, interval, { autoInvoke = false } = {}) {
  471.     const [active, setActive] = React.useState(false);
  472.     const intervalRef = React.useRef(null);
  473.     const fnRef = React.useRef(null);
  474.     const start = () => {
  475.       setActive((old) => {
  476.         if (!old && (!intervalRef.current || intervalRef.current === -1)) {
  477.           intervalRef.current = window.setInterval(fnRef.current, interval);
  478.         }
  479.         return true;
  480.       });
  481.     };
  482.     const stop = () => {
  483.       setActive(false);
  484.       window.clearInterval(intervalRef.current || -1);
  485.       intervalRef.current = -1;
  486.     };
  487.     const toggle = () => {
  488.       if (active) {
  489.         stop();
  490.       } else {
  491.         start();
  492.       }
  493.     };
  494.     React.useEffect(() => {
  495.       fnRef.current = fn;
  496.       active && start();
  497.       return stop;
  498.     }, [fn, active, interval]);
  499.     React.useEffect(() => {
  500.       if (autoInvoke) {
  501.         start();
  502.       }
  503.     }, []);
  504.     return { start, stop, toggle, active };
  505.   }
  506.   function useListState(initialValue = []) {
  507.     const [state, setState] = React.useState(initialValue);
  508.     const append = (...items) => setState((current) => [...current, ...items]);
  509.     const prepend = (...items) => setState((current) => [...items, ...current]);
  510.     const insert = (index, ...items) => setState((current) => [...current.slice(0, index), ...items, ...current.slice(index)]);
  511.     const apply = (fn) => setState((current) => current.map((item, index) => fn(item, index)));
  512.     const remove = (...indices) => setState((current) => current.filter((_, index) => !indices.includes(index)));
  513.     const pop = () => setState((current) => {
  514.       const cloned = [...current];
  515.       cloned.pop();
  516.       return cloned;
  517.     });
  518.     const shift = () => setState((current) => {
  519.       const cloned = [...current];
  520.       cloned.shift();
  521.       return cloned;
  522.     });
  523.     const reorder = ({ from, to }) => setState((current) => {
  524.       const cloned = [...current];
  525.       const item = current[from];
  526.       cloned.splice(from, 1);
  527.       cloned.splice(to, 0, item);
  528.       return cloned;
  529.     });
  530.     const swap = ({ from, to }) => setState((current) => {
  531.       const cloned = [...current];
  532.       const fromItem = cloned[from];
  533.       const toItem = cloned[to];
  534.       cloned.splice(to, 1, fromItem);
  535.       cloned.splice(from, 1, toItem);
  536.       return cloned;
  537.     });
  538.     const setItem = (index, item) => setState((current) => {
  539.       const cloned = [...current];
  540.       cloned[index] = item;
  541.       return cloned;
  542.     });
  543.     const setItemProp = (index, prop, value) => setState((current) => {
  544.       const cloned = [...current];
  545.       cloned[index] = { ...cloned[index], [prop]: value };
  546.       return cloned;
  547.     });
  548.     const applyWhere = (condition, fn) => setState(
  549.       (current) => current.map((item, index) => condition(item, index) ? fn(item, index) : item)
  550.     );
  551.     const filter = (fn) => {
  552.       setState((current) => current.filter(fn));
  553.     };
  554.     return [
  555.       state,
  556.       {
  557.         setState,
  558.         append,
  559.         prepend,
  560.         insert,
  561.         pop,
  562.         shift,
  563.         apply,
  564.         applyWhere,
  565.         remove,
  566.         reorder,
  567.         swap,
  568.         setItem,
  569.         setItemProp,
  570.         filter
  571.       }
  572.     ];
  573.   }
  574.   function useWindowEvent(type, listener, options) {
  575.     React.useEffect(() => {
  576.       window.addEventListener(type, listener, options);
  577.       return () => window.removeEventListener(type, listener, options);
  578.     }, [type, listener]);
  579.   }
  580.   function serializeJSON(value, hookName = "use-local-storage") {
  581.     try {
  582.       return JSON.stringify(value);
  583.     } catch (error) {
  584.       throw new Error(`@mantine/hooks ${hookName}: Failed to serialize the value`);
  585.     }
  586.   }
  587.   function deserializeJSON(value) {
  588.     try {
  589.       return value && JSON.parse(value);
  590.     } catch {
  591.       return value;
  592.     }
  593.   }
  594.   function createStorageHandler(type) {
  595.     const getItem = (key) => {
  596.       try {
  597.         return window[type].getItem(key);
  598.       } catch (error) {
  599.         console.warn("use-local-storage: Failed to get value from storage, localStorage is blocked");
  600.         return null;
  601.       }
  602.     };
  603.     const setItem = (key, value) => {
  604.       try {
  605.         window[type].setItem(key, value);
  606.       } catch (error) {
  607.         console.warn("use-local-storage: Failed to set value to storage, localStorage is blocked");
  608.       }
  609.     };
  610.     const removeItem = (key) => {
  611.       try {
  612.         window[type].removeItem(key);
  613.       } catch (error) {
  614.         console.warn(
  615.           "use-local-storage: Failed to remove value from storage, localStorage is blocked"
  616.         );
  617.       }
  618.     };
  619.     return { getItem, setItem, removeItem };
  620.   }
  621.   function createStorage(type, hookName) {
  622.     const eventName = type === "localStorage" ? "mantine-local-storage" : "mantine-session-storage";
  623.     const { getItem, setItem, removeItem } = createStorageHandler(type);
  624.     return function useStorage({
  625.       key,
  626.       defaultValue,
  627.       getInitialValueInEffect = true,
  628.       deserialize = deserializeJSON,
  629.       serialize = (value) => serializeJSON(value, hookName)
  630.     }) {
  631.       const readStorageValue = React.useCallback(
  632.         (skipStorage) => {
  633.           let storageBlockedOrSkipped;
  634.           try {
  635.             storageBlockedOrSkipped = typeof window === "undefined" || !(type in window) || window[type] === null || !!skipStorage;
  636.           } catch (_e) {
  637.             storageBlockedOrSkipped = true;
  638.           }
  639.           if (storageBlockedOrSkipped) {
  640.             return defaultValue;
  641.           }
  642.           const storageValue = getItem(key);
  643.           return storageValue !== null ? deserialize(storageValue) : defaultValue;
  644.         },
  645.         [key, defaultValue]
  646.       );
  647.       const [value, setValue] = React.useState(readStorageValue(getInitialValueInEffect));
  648.       const setStorageValue = React.useCallback(
  649.         (val) => {
  650.           if (val instanceof Function) {
  651.             setValue((current) => {
  652.               const result = val(current);
  653.               setItem(key, serialize(result));
  654.               window.dispatchEvent(
  655.                 new CustomEvent(eventName, { detail: { key, value: val(current) } })
  656.               );
  657.               return result;
  658.             });
  659.           } else {
  660.             setItem(key, serialize(val));
  661.             window.dispatchEvent(new CustomEvent(eventName, { detail: { key, value: val } }));
  662.             setValue(val);
  663.           }
  664.         },
  665.         [key]
  666.       );
  667.       const removeStorageValue = React.useCallback(() => {
  668.         removeItem(key);
  669.         window.dispatchEvent(new CustomEvent(eventName, { detail: { key, value: defaultValue } }));
  670.       }, []);
  671.       useWindowEvent("storage", (event) => {
  672.         if (event.storageArea === window[type] && event.key === key) {
  673.           setValue(deserialize(event.newValue ?? void 0));
  674.         }
  675.       });
  676.       useWindowEvent(eventName, (event) => {
  677.         if (event.detail.key === key) {
  678.           setValue(event.detail.value);
  679.         }
  680.       });
  681.       React.useEffect(() => {
  682.         if (defaultValue !== void 0 && value === void 0) {
  683.           setStorageValue(defaultValue);
  684.         }
  685.       }, [defaultValue, value, setStorageValue]);
  686.       React.useEffect(() => {
  687.         const val = readStorageValue();
  688.         val !== void 0 && setStorageValue(val);
  689.       }, [key]);
  690.       return [value === void 0 ? defaultValue : value, setStorageValue, removeStorageValue];
  691.     };
  692.   }
  693.   function readValue(type) {
  694.     const { getItem } = createStorageHandler(type);
  695.     return function read({
  696.       key,
  697.       defaultValue,
  698.       deserialize = deserializeJSON
  699.     }) {
  700.       let storageBlockedOrSkipped;
  701.       try {
  702.         storageBlockedOrSkipped = typeof window === "undefined" || !(type in window) || window[type] === null;
  703.       } catch (_e) {
  704.         storageBlockedOrSkipped = true;
  705.       }
  706.       if (storageBlockedOrSkipped) {
  707.         return defaultValue;
  708.       }
  709.       const storageValue = getItem(key);
  710.       return storageValue !== null ? deserialize(storageValue) : defaultValue;
  711.     };
  712.   }
  713.   function useLocalStorage(props) {
  714.     return createStorage("localStorage", "use-local-storage")(props);
  715.   }
  716.   var readLocalStorageValue = readValue("localStorage");
  717.   function useSessionStorage(props) {
  718.     return createStorage("sessionStorage", "use-session-storage")(props);
  719.   }
  720.   var readSessionStorageValue = readValue("sessionStorage");
  721.   function assignRef(ref, value) {
  722.     if (typeof ref === "function") {
  723.       ref(value);
  724.     } else if (typeof ref === "object" && ref !== null && "current" in ref) {
  725.       ref.current = value;
  726.     }
  727.   }
  728.   function mergeRefs(...refs) {
  729.     return (node) => {
  730.       refs.forEach((ref) => assignRef(ref, node));
  731.     };
  732.   }
  733.   function useMergedRef(...refs) {
  734.     return React.useCallback(mergeRefs(...refs), refs);
  735.   }
  736.   function useMouse(options = { resetOnExit: false }) {
  737.     const [position, setPosition] = React.useState({ x: 0, y: 0 });
  738.     const ref = React.useRef(null);
  739.     const setMousePosition = (event) => {
  740.       if (ref.current) {
  741.         const rect = event.currentTarget.getBoundingClientRect();
  742.         const x = Math.max(
  743.           0,
  744.           Math.round(event.pageX - rect.left - (window.pageXOffset || window.scrollX))
  745.         );
  746.         const y = Math.max(
  747.           0,
  748.           Math.round(event.pageY - rect.top - (window.pageYOffset || window.scrollY))
  749.         );
  750.         setPosition({ x, y });
  751.       } else {
  752.         setPosition({ x: event.clientX, y: event.clientY });
  753.       }
  754.     };
  755.     const resetMousePosition = () => setPosition({ x: 0, y: 0 });
  756.     React.useEffect(() => {
  757.       const element = ref?.current ? ref.current : document;
  758.       element.addEventListener("mousemove", setMousePosition);
  759.       if (options.resetOnExit) {
  760.         element.addEventListener("mouseleave", resetMousePosition);
  761.       }
  762.       return () => {
  763.         element.removeEventListener("mousemove", setMousePosition);
  764.         if (options.resetOnExit) {
  765.           element.removeEventListener("mouseleave", resetMousePosition);
  766.         }
  767.       };
  768.     }, [ref.current]);
  769.     return { ref, ...position };
  770.   }
  771.   function clampUseMovePosition(position) {
  772.     return {
  773.       x: clamp(position.x, 0, 1),
  774.       y: clamp(position.y, 0, 1)
  775.     };
  776.   }
  777.   function useMove(onChange, handlers, dir = "ltr") {
  778.     const ref = React.useRef(null);
  779.     const mounted = React.useRef(false);
  780.     const isSliding = React.useRef(false);
  781.     const frame = React.useRef(0);
  782.     const [active, setActive] = React.useState(false);
  783.     React.useEffect(() => {
  784.       mounted.current = true;
  785.     }, []);
  786.     React.useEffect(() => {
  787.       const onScrub = ({ x, y }) => {
  788.         cancelAnimationFrame(frame.current);
  789.         frame.current = requestAnimationFrame(() => {
  790.           if (mounted.current && ref.current) {
  791.             ref.current.style.userSelect = "none";
  792.             const rect = ref.current.getBoundingClientRect();
  793.             if (rect.width && rect.height) {
  794.               const _x = clamp((x - rect.left) / rect.width, 0, 1);
  795.               onChange({
  796.                 x: dir === "ltr" ? _x : 1 - _x,
  797.                 y: clamp((y - rect.top) / rect.height, 0, 1)
  798.               });
  799.             }
  800.           }
  801.         });
  802.       };
  803.       const bindEvents = () => {
  804.         document.addEventListener("mousemove", onMouseMove);
  805.         document.addEventListener("mouseup", stopScrubbing);
  806.         document.addEventListener("touchmove", onTouchMove);
  807.         document.addEventListener("touchend", stopScrubbing);
  808.       };
  809.       const unbindEvents = () => {
  810.         document.removeEventListener("mousemove", onMouseMove);
  811.         document.removeEventListener("mouseup", stopScrubbing);
  812.         document.removeEventListener("touchmove", onTouchMove);
  813.         document.removeEventListener("touchend", stopScrubbing);
  814.       };
  815.       const startScrubbing = () => {
  816.         if (!isSliding.current && mounted.current) {
  817.           isSliding.current = true;
  818.           typeof handlers?.onScrubStart === "function" && handlers.onScrubStart();
  819.           setActive(true);
  820.           bindEvents();
  821.         }
  822.       };
  823.       const stopScrubbing = () => {
  824.         if (isSliding.current && mounted.current) {
  825.           isSliding.current = false;
  826.           setActive(false);
  827.           unbindEvents();
  828.           setTimeout(() => {
  829.             typeof handlers?.onScrubEnd === "function" && handlers.onScrubEnd();
  830.           }, 0);
  831.         }
  832.       };
  833.       const onMouseDown = (event) => {
  834.         startScrubbing();
  835.         event.preventDefault();
  836.         onMouseMove(event);
  837.       };
  838.       const onMouseMove = (event) => onScrub({ x: event.clientX, y: event.clientY });
  839.       const onTouchStart = (event) => {
  840.         if (event.cancelable) {
  841.           event.preventDefault();
  842.         }
  843.         startScrubbing();
  844.         onTouchMove(event);
  845.       };
  846.       const onTouchMove = (event) => {
  847.         if (event.cancelable) {
  848.           event.preventDefault();
  849.         }
  850.         onScrub({ x: event.changedTouches[0].clientX, y: event.changedTouches[0].clientY });
  851.       };
  852.       ref.current?.addEventListener("mousedown", onMouseDown);
  853.       ref.current?.addEventListener("touchstart", onTouchStart, { passive: false });
  854.       return () => {
  855.         if (ref.current) {
  856.           ref.current.removeEventListener("mousedown", onMouseDown);
  857.           ref.current.removeEventListener("touchstart", onTouchStart);
  858.         }
  859.       };
  860.     }, [dir, onChange]);
  861.     return { ref, active };
  862.   }
  863.   function useUncontrolled({
  864.     value,
  865.     defaultValue,
  866.     finalValue,
  867.     onChange = () => {
  868.     }
  869.   }) {
  870.     const [uncontrolledValue, setUncontrolledValue] = React.useState(
  871.       defaultValue !== void 0 ? defaultValue : finalValue
  872.     );
  873.     const handleUncontrolledChange = (val, ...payload) => {
  874.       setUncontrolledValue(val);
  875.       onChange?.(val, ...payload);
  876.     };
  877.     if (value !== void 0) {
  878.       return [value, onChange, true];
  879.     }
  880.     return [uncontrolledValue, handleUncontrolledChange, false];
  881.   }
  882.   function range2(start, end) {
  883.     const length = end - start + 1;
  884.     return Array.from({ length }, (_, index) => index + start);
  885.   }
  886.   var DOTS = "dots";
  887.   function usePagination({
  888.     total,
  889.     siblings = 1,
  890.     boundaries = 1,
  891.     page,
  892.     initialPage = 1,
  893.     onChange
  894.   }) {
  895.     const _total = Math.max(Math.trunc(total), 0);
  896.     const [activePage, setActivePage] = useUncontrolled({
  897.       value: page,
  898.       onChange,
  899.       defaultValue: initialPage,
  900.       finalValue: initialPage
  901.     });
  902.     const setPage = (pageNumber) => {
  903.       if (pageNumber <= 0) {
  904.         setActivePage(1);
  905.       } else if (pageNumber > _total) {
  906.         setActivePage(_total);
  907.       } else {
  908.         setActivePage(pageNumber);
  909.       }
  910.     };
  911.     const next = () => setPage(activePage + 1);
  912.     const previous = () => setPage(activePage - 1);
  913.     const first = () => setPage(1);
  914.     const last = () => setPage(_total);
  915.     const paginationRange = React.useMemo(() => {
  916.       const totalPageNumbers = siblings * 2 + 3 + boundaries * 2;
  917.       if (totalPageNumbers >= _total) {
  918.         return range2(1, _total);
  919.       }
  920.       const leftSiblingIndex = Math.max(activePage - siblings, boundaries);
  921.       const rightSiblingIndex = Math.min(activePage + siblings, _total - boundaries);
  922.       const shouldShowLeftDots = leftSiblingIndex > boundaries + 2;
  923.       const shouldShowRightDots = rightSiblingIndex < _total - (boundaries + 1);
  924.       if (!shouldShowLeftDots && shouldShowRightDots) {
  925.         const leftItemCount = siblings * 2 + boundaries + 2;
  926.         return [...range2(1, leftItemCount), DOTS, ...range2(_total - (boundaries - 1), _total)];
  927.       }
  928.       if (shouldShowLeftDots && !shouldShowRightDots) {
  929.         const rightItemCount = boundaries + 1 + 2 * siblings;
  930.         return [...range2(1, boundaries), DOTS, ...range2(_total - rightItemCount, _total)];
  931.       }
  932.       return [
  933.         ...range2(1, boundaries),
  934.         DOTS,
  935.         ...range2(leftSiblingIndex, rightSiblingIndex),
  936.         DOTS,
  937.         ...range2(_total - boundaries + 1, _total)
  938.       ];
  939.     }, [_total, siblings, activePage]);
  940.     return {
  941.       range: paginationRange,
  942.       active: activePage,
  943.       setPage,
  944.       next,
  945.       previous,
  946.       first,
  947.       last
  948.     };
  949.   }
  950.   function useQueue({ initialValues = [], limit }) {
  951.     const [state, setState] = React.useState({
  952.       state: initialValues.slice(0, limit),
  953.       queue: initialValues.slice(limit)
  954.     });
  955.     const add = (...items) => setState((current) => {
  956.       const results = [...current.state, ...current.queue, ...items];
  957.       return {
  958.         state: results.slice(0, limit),
  959.         queue: results.slice(limit)
  960.       };
  961.     });
  962.     const update = (fn) => setState((current) => {
  963.       const results = fn([...current.state, ...current.queue]);
  964.       return {
  965.         state: results.slice(0, limit),
  966.         queue: results.slice(limit)
  967.       };
  968.     });
  969.     const cleanQueue = () => setState((current) => ({ state: current.state, queue: [] }));
  970.     return {
  971.       state: state.state,
  972.       queue: state.queue,
  973.       add,
  974.       update,
  975.       cleanQueue
  976.     };
  977.   }
  978.   function usePageLeave(onPageLeave) {
  979.     React.useEffect(() => {
  980.       document.documentElement.addEventListener("mouseleave", onPageLeave);
  981.       return () => document.documentElement.removeEventListener("mouseleave", onPageLeave);
  982.     }, []);
  983.   }
  984.   function useReducedMotion(initialValue, options) {
  985.     return useMediaQuery("(prefers-reduced-motion: reduce)", initialValue, options);
  986.   }
  987.   var easeInOutQuad = (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
  988.   var getRelativePosition = ({
  989.     axis,
  990.     target,
  991.     parent,
  992.     alignment,
  993.     offset,
  994.     isList
  995.   }) => {
  996.     if (!target || !parent && typeof document === "undefined") {
  997.       return 0;
  998.     }
  999.     const isCustomParent = !!parent;
  1000.     const parentElement = parent || document.body;
  1001.     const parentPosition = parentElement.getBoundingClientRect();
  1002.     const targetPosition = target.getBoundingClientRect();
  1003.     const getDiff = (property) => targetPosition[property] - parentPosition[property];
  1004.     if (axis === "y") {
  1005.       const diff = getDiff("top");
  1006.       if (diff === 0) {
  1007.         return 0;
  1008.       }
  1009.       if (alignment === "start") {
  1010.         const distance = diff - offset;
  1011.         const shouldScroll = distance <= targetPosition.height * (isList ? 0 : 1) || !isList;
  1012.         return shouldScroll ? distance : 0;
  1013.       }
  1014.       const parentHeight = isCustomParent ? parentPosition.height : window.innerHeight;
  1015.       if (alignment === "end") {
  1016.         const distance = diff + offset - parentHeight + targetPosition.height;
  1017.         const shouldScroll = distance >= -targetPosition.height * (isList ? 0 : 1) || !isList;
  1018.         return shouldScroll ? distance : 0;
  1019.       }
  1020.       if (alignment === "center") {
  1021.         return diff - parentHeight / 2 + targetPosition.height / 2;
  1022.       }
  1023.       return 0;
  1024.     }
  1025.     if (axis === "x") {
  1026.       const diff = getDiff("left");
  1027.       if (diff === 0) {
  1028.         return 0;
  1029.       }
  1030.       if (alignment === "start") {
  1031.         const distance = diff - offset;
  1032.         const shouldScroll = distance <= targetPosition.width || !isList;
  1033.         return shouldScroll ? distance : 0;
  1034.       }
  1035.       const parentWidth = isCustomParent ? parentPosition.width : window.innerWidth;
  1036.       if (alignment === "end") {
  1037.         const distance = diff + offset - parentWidth + targetPosition.width;
  1038.         const shouldScroll = distance >= -targetPosition.width || !isList;
  1039.         return shouldScroll ? distance : 0;
  1040.       }
  1041.       if (alignment === "center") {
  1042.         return diff - parentWidth / 2 + targetPosition.width / 2;
  1043.       }
  1044.       return 0;
  1045.     }
  1046.     return 0;
  1047.   };
  1048.   var getScrollStart = ({ axis, parent }) => {
  1049.     if (!parent && typeof document === "undefined") {
  1050.       return 0;
  1051.     }
  1052.     const method = axis === "y" ? "scrollTop" : "scrollLeft";
  1053.     if (parent) {
  1054.       return parent[method];
  1055.     }
  1056.     const { body, documentElement } = document;
  1057.     return body[method] + documentElement[method];
  1058.   };
  1059.   var setScrollParam = ({ axis, parent, distance }) => {
  1060.     if (!parent && typeof document === "undefined") {
  1061.       return;
  1062.     }
  1063.     const method = axis === "y" ? "scrollTop" : "scrollLeft";
  1064.     if (parent) {
  1065.       parent[method] = distance;
  1066.     } else {
  1067.       const { body, documentElement } = document;
  1068.       body[method] = distance;
  1069.       documentElement[method] = distance;
  1070.     }
  1071.   };
  1072.   function useScrollIntoView({
  1073.     duration = 1250,
  1074.     axis = "y",
  1075.     onScrollFinish,
  1076.     easing = easeInOutQuad,
  1077.     offset = 0,
  1078.     cancelable = true,
  1079.     isList = false
  1080.   } = {}) {
  1081.     const frameID = React.useRef(0);
  1082.     const startTime = React.useRef(0);
  1083.     const shouldStop = React.useRef(false);
  1084.     const scrollableRef = React.useRef(null);
  1085.     const targetRef = React.useRef(null);
  1086.     const reducedMotion = useReducedMotion();
  1087.     const cancel = () => {
  1088.       if (frameID.current) {
  1089.         cancelAnimationFrame(frameID.current);
  1090.       }
  1091.     };
  1092.     const scrollIntoView = React.useCallback(
  1093.       ({ alignment = "start" } = {}) => {
  1094.         shouldStop.current = false;
  1095.         if (frameID.current) {
  1096.           cancel();
  1097.         }
  1098.         const start = getScrollStart({ parent: scrollableRef.current, axis }) ?? 0;
  1099.         const change = getRelativePosition({
  1100.           parent: scrollableRef.current,
  1101.           target: targetRef.current,
  1102.           axis,
  1103.           alignment,
  1104.           offset,
  1105.           isList
  1106.         }) - (scrollableRef.current ? 0 : start);
  1107.         function animateScroll() {
  1108.           if (startTime.current === 0) {
  1109.             startTime.current = performance.now();
  1110.           }
  1111.           const now = performance.now();
  1112.           const elapsed = now - startTime.current;
  1113.           const t = reducedMotion || duration === 0 ? 1 : elapsed / duration;
  1114.           const distance = start + change * easing(t);
  1115.           setScrollParam({
  1116.             parent: scrollableRef.current,
  1117.             axis,
  1118.             distance
  1119.           });
  1120.           if (!shouldStop.current && t < 1) {
  1121.             frameID.current = requestAnimationFrame(animateScroll);
  1122.           } else {
  1123.             typeof onScrollFinish === "function" && onScrollFinish();
  1124.             startTime.current = 0;
  1125.             frameID.current = 0;
  1126.             cancel();
  1127.           }
  1128.         }
  1129.         animateScroll();
  1130.       },
  1131.       [axis, duration, easing, isList, offset, onScrollFinish, reducedMotion]
  1132.     );
  1133.     const handleStop = () => {
  1134.       if (cancelable) {
  1135.         shouldStop.current = true;
  1136.       }
  1137.     };
  1138.     useWindowEvent("wheel", handleStop, {
  1139.       passive: true
  1140.     });
  1141.     useWindowEvent("touchmove", handleStop, {
  1142.       passive: true
  1143.     });
  1144.     React.useEffect(() => cancel, []);
  1145.     return {
  1146.       scrollableRef,
  1147.       targetRef,
  1148.       scrollIntoView,
  1149.       cancel
  1150.     };
  1151.   }
  1152.   var defaultState = {
  1153.     x: 0,
  1154.     y: 0,
  1155.     width: 0,
  1156.     height: 0,
  1157.     top: 0,
  1158.     left: 0,
  1159.     bottom: 0,
  1160.     right: 0
  1161.   };
  1162.   function useResizeObserver(options) {
  1163.     const frameID = React.useRef(0);
  1164.     const ref = React.useRef(null);
  1165.     const [rect, setRect] = React.useState(defaultState);
  1166.     const observer = React.useMemo(
  1167.       () => typeof window !== "undefined" ? new ResizeObserver((entries) => {
  1168.         const entry = entries[0];
  1169.         if (entry) {
  1170.           cancelAnimationFrame(frameID.current);
  1171.           frameID.current = requestAnimationFrame(() => {
  1172.             if (ref.current) {
  1173.               setRect(entry.contentRect);
  1174.             }
  1175.           });
  1176.         }
  1177.       }) : null,
  1178.       []
  1179.     );
  1180.     React.useEffect(() => {
  1181.       if (ref.current) {
  1182.         observer?.observe(ref.current, options);
  1183.       }
  1184.       return () => {
  1185.         observer?.disconnect();
  1186.         if (frameID.current) {
  1187.           cancelAnimationFrame(frameID.current);
  1188.         }
  1189.       };
  1190.     }, [ref.current]);
  1191.     return [ref, rect];
  1192.   }
  1193.   function useElementSize(options) {
  1194.     const [ref, { width, height }] = useResizeObserver(options);
  1195.     return { ref, width, height };
  1196.   }
  1197.   function shallowCompare(prevValue, currValue) {
  1198.     if (!prevValue || !currValue) {
  1199.       return false;
  1200.     }
  1201.     if (prevValue === currValue) {
  1202.       return true;
  1203.     }
  1204.     if (prevValue.length !== currValue.length) {
  1205.       return false;
  1206.     }
  1207.     for (let i = 0; i < prevValue.length; i += 1) {
  1208.       if (!shallowEqual(prevValue[i], currValue[i])) {
  1209.         return false;
  1210.       }
  1211.     }
  1212.     return true;
  1213.   }
  1214.   function useShallowCompare(dependencies) {
  1215.     const ref = React.useRef([]);
  1216.     const updateRef = React.useRef(0);
  1217.     if (!shallowCompare(ref.current, dependencies)) {
  1218.       ref.current = dependencies;
  1219.       updateRef.current += 1;
  1220.     }
  1221.     return [updateRef.current];
  1222.   }
  1223.   function useShallowEffect(cb, dependencies) {
  1224.     React.useEffect(cb, useShallowCompare(dependencies));
  1225.   }
  1226.   function useToggle(options = [false, true]) {
  1227.     const [[option], toggle] = React.useReducer((state, action) => {
  1228.       const value = action instanceof Function ? action(state[0]) : action;
  1229.       const index = Math.abs(state.indexOf(value));
  1230.       return state.slice(index).concat(state.slice(0, index));
  1231.     }, options);
  1232.     return [option, toggle];
  1233.   }
  1234.   var eventListerOptions = {
  1235.     passive: true
  1236.   };
  1237.   function useViewportSize() {
  1238.     const [windowSize, setWindowSize] = React.useState({
  1239.       width: 0,
  1240.       height: 0
  1241.     });
  1242.     const setSize = React.useCallback(() => {
  1243.       setWindowSize({ width: window.innerWidth || 0, height: window.innerHeight || 0 });
  1244.     }, []);
  1245.     useWindowEvent("resize", setSize, eventListerOptions);
  1246.     useWindowEvent("orientationchange", setSize, eventListerOptions);
  1247.     React.useEffect(setSize, []);
  1248.     return windowSize;
  1249.   }
  1250.   function getScrollPosition() {
  1251.     return typeof window !== "undefined" ? { x: window.pageXOffset, y: window.pageYOffset } : { x: 0, y: 0 };
  1252.   }
  1253.   function scrollTo({ x, y }) {
  1254.     if (typeof window !== "undefined") {
  1255.       const scrollOptions = { behavior: "smooth" };
  1256.       if (typeof x === "number") {
  1257.         scrollOptions.left = x;
  1258.       }
  1259.       if (typeof y === "number") {
  1260.         scrollOptions.top = y;
  1261.       }
  1262.       window.scrollTo(scrollOptions);
  1263.     }
  1264.   }
  1265.   function useWindowScroll() {
  1266.     const [position, setPosition] = React.useState({ x: 0, y: 0 });
  1267.     useWindowEvent("scroll", () => setPosition(getScrollPosition()));
  1268.     useWindowEvent("resize", () => setPosition(getScrollPosition()));
  1269.     React.useEffect(() => {
  1270.       setPosition(getScrollPosition());
  1271.     }, []);
  1272.     return [position, scrollTo];
  1273.   }
  1274.   function useIntersection(options) {
  1275.     const [entry, setEntry] = React.useState(null);
  1276.     const observer = React.useRef(null);
  1277.     const ref = React.useCallback(
  1278.       (element) => {
  1279.         if (observer.current) {
  1280.           observer.current.disconnect();
  1281.           observer.current = null;
  1282.         }
  1283.         if (element === null) {
  1284.           setEntry(null);
  1285.           return;
  1286.         }
  1287.         observer.current = new IntersectionObserver(([_entry]) => {
  1288.           setEntry(_entry);
  1289.         }, options);
  1290.         observer.current.observe(element);
  1291.       },
  1292.       [options?.rootMargin, options?.root, options?.threshold]
  1293.     );
  1294.     return { ref, entry };
  1295.   }
  1296.   function useHash({ getInitialValueInEffect = true } = {}) {
  1297.     const [hash, setHash] = React.useState(
  1298.       getInitialValueInEffect ? "" : window.location.hash || ""
  1299.     );
  1300.     const setHashHandler = (value) => {
  1301.       const valueWithHash = value.startsWith("#") ? value : `#${value}`;
  1302.       window.location.hash = valueWithHash;
  1303.       setHash(valueWithHash);
  1304.     };
  1305.     useWindowEvent("hashchange", () => {
  1306.       const newHash = window.location.hash;
  1307.       if (hash !== newHash) {
  1308.         setHash(newHash);
  1309.       }
  1310.     });
  1311.     React.useEffect(() => {
  1312.       if (getInitialValueInEffect) {
  1313.         setHash(window.location.hash);
  1314.       }
  1315.     }, []);
  1316.     return [hash, setHashHandler];
  1317.   }
  1318.   function parseHotkey(hotkey) {
  1319.     const keys = hotkey.toLowerCase().split("+").map((part) => part.trim());
  1320.     const modifiers = {
  1321.       alt: keys.includes("alt"),
  1322.       ctrl: keys.includes("ctrl"),
  1323.       meta: keys.includes("meta"),
  1324.       mod: keys.includes("mod"),
  1325.       shift: keys.includes("shift"),
  1326.       plus: keys.includes("[plus]")
  1327.     };
  1328.     const reservedKeys = ["alt", "ctrl", "meta", "shift", "mod"];
  1329.     const freeKey = keys.find((key) => !reservedKeys.includes(key));
  1330.     return {
  1331.       ...modifiers,
  1332.       key: freeKey === "[plus]" ? "+" : freeKey
  1333.     };
  1334.   }
  1335.   function isExactHotkey(hotkey, event) {
  1336.     const { alt, ctrl, meta, mod, shift, key } = hotkey;
  1337.     const { altKey, ctrlKey, metaKey, shiftKey, key: pressedKey } = event;
  1338.     if (alt !== altKey) {
  1339.       return false;
  1340.     }
  1341.     if (mod) {
  1342.       if (!ctrlKey && !metaKey) {
  1343.         return false;
  1344.       }
  1345.     } else {
  1346.       if (ctrl !== ctrlKey) {
  1347.         return false;
  1348.       }
  1349.       if (meta !== metaKey) {
  1350.         return false;
  1351.       }
  1352.     }
  1353.     if (shift !== shiftKey) {
  1354.       return false;
  1355.     }
  1356.     if (key && (pressedKey.toLowerCase() === key.toLowerCase() || event.code.replace("Key", "").toLowerCase() === key.toLowerCase())) {
  1357.       return true;
  1358.     }
  1359.     return false;
  1360.   }
  1361.   function getHotkeyMatcher(hotkey) {
  1362.     return (event) => isExactHotkey(parseHotkey(hotkey), event);
  1363.   }
  1364.   function getHotkeyHandler(hotkeys) {
  1365.     return (event) => {
  1366.       const _event = "nativeEvent" in event ? event.nativeEvent : event;
  1367.       hotkeys.forEach(([hotkey, handler, options = { preventDefault: true }]) => {
  1368.         if (getHotkeyMatcher(hotkey)(_event)) {
  1369.           if (options.preventDefault) {
  1370.             event.preventDefault();
  1371.           }
  1372.           handler(_event);
  1373.         }
  1374.       });
  1375.     };
  1376.   }
  1377.   function shouldFireEvent(event, tagsToIgnore, triggerOnContentEditable = false) {
  1378.     if (event.target instanceof HTMLElement) {
  1379.       if (triggerOnContentEditable) {
  1380.         return !tagsToIgnore.includes(event.target.tagName);
  1381.       }
  1382.       return !event.target.isContentEditable && !tagsToIgnore.includes(event.target.tagName);
  1383.     }
  1384.     return true;
  1385.   }
  1386.   function useHotkeys(hotkeys, tagsToIgnore = ["INPUT", "TEXTAREA", "SELECT"], triggerOnContentEditable = false) {
  1387.     React.useEffect(() => {
  1388.       const keydownListener = (event) => {
  1389.         hotkeys.forEach(([hotkey, handler, options = { preventDefault: true }]) => {
  1390.           if (getHotkeyMatcher(hotkey)(event) && shouldFireEvent(event, tagsToIgnore, triggerOnContentEditable)) {
  1391.             if (options.preventDefault) {
  1392.               event.preventDefault();
  1393.             }
  1394.             handler(event);
  1395.           }
  1396.         });
  1397.       };
  1398.       document.documentElement.addEventListener("keydown", keydownListener);
  1399.       return () => document.documentElement.removeEventListener("keydown", keydownListener);
  1400.     }, [hotkeys]);
  1401.   }
  1402.   function getFullscreenElement() {
  1403.     const _document = window.document;
  1404.     const fullscreenElement = _document.fullscreenElement || _document.webkitFullscreenElement || _document.mozFullScreenElement || _document.msFullscreenElement;
  1405.     return fullscreenElement;
  1406.   }
  1407.   function exitFullscreen() {
  1408.     const _document = window.document;
  1409.     if (typeof _document.exitFullscreen === "function") {
  1410.       return _document.exitFullscreen();
  1411.     }
  1412.     if (typeof _document.msExitFullscreen === "function") {
  1413.       return _document.msExitFullscreen();
  1414.     }
  1415.     if (typeof _document.webkitExitFullscreen === "function") {
  1416.       return _document.webkitExitFullscreen();
  1417.     }
  1418.     if (typeof _document.mozCancelFullScreen === "function") {
  1419.       return _document.mozCancelFullScreen();
  1420.     }
  1421.     return null;
  1422.   }
  1423.   function enterFullScreen(element) {
  1424.     const _element = element;
  1425.     return _element.requestFullscreen?.() || _element.msRequestFullscreen?.() || _element.webkitEnterFullscreen?.() || _element.webkitRequestFullscreen?.() || _element.mozRequestFullscreen?.();
  1426.   }
  1427.   var prefixes = ["", "webkit", "moz", "ms"];
  1428.   function addEvents(element, {
  1429.     onFullScreen,
  1430.     onError
  1431.   }) {
  1432.     prefixes.forEach((prefix) => {
  1433.       element.addEventListener(`${prefix}fullscreenchange`, onFullScreen);
  1434.       element.addEventListener(`${prefix}fullscreenerror`, onError);
  1435.     });
  1436.     return () => {
  1437.       prefixes.forEach((prefix) => {
  1438.         element.removeEventListener(`${prefix}fullscreenchange`, onFullScreen);
  1439.         element.removeEventListener(`${prefix}fullscreenerror`, onError);
  1440.       });
  1441.     };
  1442.   }
  1443.   function useFullscreen() {
  1444.     const [fullscreen, setFullscreen] = React.useState(false);
  1445.     const _ref = React.useRef(null);
  1446.     const handleFullscreenChange = React.useCallback(
  1447.       (event) => {
  1448.         setFullscreen(event.target === getFullscreenElement());
  1449.       },
  1450.       [setFullscreen]
  1451.     );
  1452.     const handleFullscreenError = React.useCallback(
  1453.       (event) => {
  1454.         setFullscreen(false);
  1455.         console.error(
  1456.           `[@mantine/hooks] use-fullscreen: Error attempting full-screen mode method: ${event} (${event.target})`
  1457.         );
  1458.       },
  1459.       [setFullscreen]
  1460.     );
  1461.     const toggle = React.useCallback(async () => {
  1462.       if (!getFullscreenElement()) {
  1463.         await enterFullScreen(_ref.current);
  1464.       } else {
  1465.         await exitFullscreen();
  1466.       }
  1467.     }, []);
  1468.     const ref = React.useCallback((element) => {
  1469.       if (element === null) {
  1470.         _ref.current = window.document.documentElement;
  1471.       } else {
  1472.         _ref.current = element;
  1473.       }
  1474.     }, []);
  1475.     React.useEffect(() => {
  1476.       if (!_ref.current && window.document) {
  1477.         _ref.current = window.document.documentElement;
  1478.         return addEvents(_ref.current, {
  1479.           onFullScreen: handleFullscreenChange,
  1480.           onError: handleFullscreenError
  1481.         });
  1482.       }
  1483.       if (_ref.current) {
  1484.         return addEvents(_ref.current, {
  1485.           onFullScreen: handleFullscreenChange,
  1486.           onError: handleFullscreenError
  1487.         });
  1488.       }
  1489.       return void 0;
  1490.     }, [_ref.current]);
  1491.     return { ref, toggle, fullscreen };
  1492.   }
  1493.   function useLogger(componentName, props) {
  1494.     React.useEffect(() => {
  1495.       console.log(`${componentName} mounted`, ...props);
  1496.       return () => console.log(`${componentName} unmounted`);
  1497.     }, []);
  1498.     useDidUpdate(() => {
  1499.       console.log(`${componentName} updated`, ...props);
  1500.     }, props);
  1501.     return null;
  1502.   }
  1503.   function useHover() {
  1504.     const [hovered, setHovered] = React.useState(false);
  1505.     const ref = React.useRef(null);
  1506.     const onMouseEnter = React.useCallback(() => setHovered(true), []);
  1507.     const onMouseLeave = React.useCallback(() => setHovered(false), []);
  1508.     React.useEffect(() => {
  1509.       if (ref.current) {
  1510.         ref.current.addEventListener("mouseenter", onMouseEnter);
  1511.         ref.current.addEventListener("mouseleave", onMouseLeave);
  1512.         return () => {
  1513.           ref.current?.removeEventListener("mouseenter", onMouseEnter);
  1514.           ref.current?.removeEventListener("mouseleave", onMouseLeave);
  1515.         };
  1516.       }
  1517.       return void 0;
  1518.     }, [ref.current]);
  1519.     return { ref, hovered };
  1520.   }
  1521.   function useValidatedState(initialValue, validation, initialValidationState) {
  1522.     const [value, setValue] = React.useState(initialValue);
  1523.     const [lastValidValue, setLastValidValue] = React.useState(
  1524.       validation(initialValue) ? initialValue : void 0
  1525.     );
  1526.     const [valid, setValid] = React.useState(
  1527.       typeof initialValidationState === "boolean" ? initialValidationState : validation(initialValue)
  1528.     );
  1529.     const onChange = (val) => {
  1530.       if (validation(val)) {
  1531.         setLastValidValue(val);
  1532.         setValid(true);
  1533.       } else {
  1534.         setValid(false);
  1535.       }
  1536.       setValue(val);
  1537.     };
  1538.     return [{ value, lastValidValue, valid }, onChange];
  1539.   }
  1540.   function isMacOS(userAgent) {
  1541.     const macosPattern = /(Macintosh)|(MacIntel)|(MacPPC)|(Mac68K)/i;
  1542.     return macosPattern.test(userAgent);
  1543.   }
  1544.   function isIOS(userAgent) {
  1545.     const iosPattern = /(iPhone)|(iPad)|(iPod)/i;
  1546.     return iosPattern.test(userAgent);
  1547.   }
  1548.   function isWindows(userAgent) {
  1549.     const windowsPattern = /(Win32)|(Win64)|(Windows)|(WinCE)/i;
  1550.     return windowsPattern.test(userAgent);
  1551.   }
  1552.   function isAndroid(userAgent) {
  1553.     const androidPattern = /Android/i;
  1554.     return androidPattern.test(userAgent);
  1555.   }
  1556.   function isLinux(userAgent) {
  1557.     const linuxPattern = /Linux/i;
  1558.     return linuxPattern.test(userAgent);
  1559.   }
  1560.   function getOS() {
  1561.     if (typeof window === "undefined") {
  1562.       return "undetermined";
  1563.     }
  1564.     const { userAgent } = window.navigator;
  1565.     if (isIOS(userAgent) || isMacOS(userAgent) && "ontouchend" in document) {
  1566.       return "ios";
  1567.     }
  1568.     if (isMacOS(userAgent)) {
  1569.       return "macos";
  1570.     }
  1571.     if (isWindows(userAgent)) {
  1572.       return "windows";
  1573.     }
  1574.     if (isAndroid(userAgent)) {
  1575.       return "android";
  1576.     }
  1577.     if (isLinux(userAgent)) {
  1578.       return "linux";
  1579.     }
  1580.     return "undetermined";
  1581.   }
  1582.   function useOs(options = { getValueInEffect: true }) {
  1583.     const [value, setValue] = React.useState(options.getValueInEffect ? "undetermined" : getOS());
  1584.     useIsomorphicEffect(() => {
  1585.       if (options.getValueInEffect) {
  1586.         setValue(getOS);
  1587.       }
  1588.     }, []);
  1589.     return value;
  1590.   }
  1591.   function useSetState(initialState) {
  1592.     const [state, setState] = React.useState(initialState);
  1593.     const _setState = React.useCallback(
  1594.       (statePartial) => setState((current) => ({
  1595.         ...current,
  1596.         ...typeof statePartial === "function" ? statePartial(current) : statePartial
  1597.       })),
  1598.       []
  1599.     );
  1600.     return [state, _setState];
  1601.   }
  1602.   function getInputOnChange(setValue) {
  1603.     return (val) => {
  1604.       if (!val) {
  1605.         setValue(val);
  1606.       } else if (typeof val === "function") {
  1607.         setValue(val);
  1608.       } else if (typeof val === "object" && "nativeEvent" in val) {
  1609.         const { currentTarget } = val;
  1610.         if (currentTarget.type === "checkbox") {
  1611.           setValue(currentTarget.checked);
  1612.         } else {
  1613.           setValue(currentTarget.value);
  1614.         }
  1615.       } else {
  1616.         setValue(val);
  1617.       }
  1618.     };
  1619.   }
  1620.   function useInputState(initialState) {
  1621.     const [value, setValue] = React.useState(initialState);
  1622.     return [value, getInputOnChange(setValue)];
  1623.   }
  1624.   function useEventListener(type, listener, options) {
  1625.     const ref = React.useRef(null);
  1626.     React.useEffect(() => {
  1627.       if (ref.current) {
  1628.         ref.current.addEventListener(type, listener, options);
  1629.         return () => ref.current?.removeEventListener(type, listener, options);
  1630.       }
  1631.       return void 0;
  1632.     }, [listener, options]);
  1633.     return ref;
  1634.   }
  1635.   function useDisclosure(initialState = false, callbacks) {
  1636.     const { onOpen, onClose } = callbacks || {};
  1637.     const [opened, setOpened] = React.useState(initialState);
  1638.     const open = React.useCallback(() => {
  1639.       setOpened((isOpened) => {
  1640.         if (!isOpened) {
  1641.           onOpen?.();
  1642.           return true;
  1643.         }
  1644.         return isOpened;
  1645.       });
  1646.     }, [onOpen]);
  1647.     const close = React.useCallback(() => {
  1648.       setOpened((isOpened) => {
  1649.         if (isOpened) {
  1650.           onClose?.();
  1651.           return false;
  1652.         }
  1653.         return isOpened;
  1654.       });
  1655.     }, [onClose]);
  1656.     const toggle = React.useCallback(() => {
  1657.       opened ? close() : open();
  1658.     }, [close, open, opened]);
  1659.     return [opened, { open, close, toggle }];
  1660.   }
  1661.   function containsRelatedTarget(event) {
  1662.     if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) {
  1663.       return event.currentTarget.contains(event.relatedTarget);
  1664.     }
  1665.     return false;
  1666.   }
  1667.   function useFocusWithin({
  1668.     onBlur,
  1669.     onFocus
  1670.   } = {}) {
  1671.     const ref = React.useRef(null);
  1672.     const [focused, setFocused] = React.useState(false);
  1673.     const focusedRef = React.useRef(false);
  1674.     const _setFocused = (value) => {
  1675.       setFocused(value);
  1676.       focusedRef.current = value;
  1677.     };
  1678.     const handleFocusIn = (event) => {
  1679.       if (!focusedRef.current) {
  1680.         _setFocused(true);
  1681.         onFocus?.(event);
  1682.       }
  1683.     };
  1684.     const handleFocusOut = (event) => {
  1685.       if (focusedRef.current && !containsRelatedTarget(event)) {
  1686.         _setFocused(false);
  1687.         onBlur?.(event);
  1688.       }
  1689.     };
  1690.     React.useEffect(() => {
  1691.       if (ref.current) {
  1692.         ref.current.addEventListener("focusin", handleFocusIn);
  1693.         ref.current.addEventListener("focusout", handleFocusOut);
  1694.         return () => {
  1695.           ref.current?.removeEventListener("focusin", handleFocusIn);
  1696.           ref.current?.removeEventListener("focusout", handleFocusOut);
  1697.         };
  1698.       }
  1699.       return void 0;
  1700.     }, [handleFocusIn, handleFocusOut]);
  1701.     return { ref, focused };
  1702.   }
  1703.   function getConnection() {
  1704.     if (typeof navigator === "undefined") {
  1705.       return {};
  1706.     }
  1707.     const _navigator = navigator;
  1708.     const connection = _navigator.connection || _navigator.mozConnection || _navigator.webkitConnection;
  1709.     if (!connection) {
  1710.       return {};
  1711.     }
  1712.     return {
  1713.       downlink: connection?.downlink,
  1714.       downlinkMax: connection?.downlinkMax,
  1715.       effectiveType: connection?.effectiveType,
  1716.       rtt: connection?.rtt,
  1717.       saveData: connection?.saveData,
  1718.       type: connection?.type
  1719.     };
  1720.   }
  1721.   function useNetwork() {
  1722.     const [status, setStatus] = React.useState({
  1723.       online: true
  1724.     });
  1725.     const handleConnectionChange = React.useCallback(
  1726.       () => setStatus((current) => ({ ...current, ...getConnection() })),
  1727.       []
  1728.     );
  1729.     useWindowEvent("online", () => setStatus({ online: true, ...getConnection() }));
  1730.     useWindowEvent("offline", () => setStatus({ online: false, ...getConnection() }));
  1731.     React.useEffect(() => {
  1732.       const _navigator = navigator;
  1733.       if (_navigator.connection) {
  1734.         setStatus({ online: _navigator.onLine, ...getConnection() });
  1735.         _navigator.connection.addEventListener("change", handleConnectionChange);
  1736.         return () => _navigator.connection.removeEventListener("change", handleConnectionChange);
  1737.       }
  1738.       if (typeof _navigator.onLine === "boolean") {
  1739.         setStatus((current) => ({ ...current, online: _navigator.onLine }));
  1740.       }
  1741.       return void 0;
  1742.     }, []);
  1743.     return status;
  1744.   }
  1745.   function useTimeout(callback, delay, options = { autoInvoke: false }) {
  1746.     const timeoutRef = React.useRef(null);
  1747.     const start = React.useCallback(
  1748.       (...callbackParams) => {
  1749.         if (!timeoutRef.current) {
  1750.           timeoutRef.current = window.setTimeout(() => {
  1751.             callback(callbackParams);
  1752.             timeoutRef.current = null;
  1753.           }, delay);
  1754.         }
  1755.       },
  1756.       [delay]
  1757.     );
  1758.     const clear = React.useCallback(() => {
  1759.       if (timeoutRef.current) {
  1760.         window.clearTimeout(timeoutRef.current);
  1761.         timeoutRef.current = null;
  1762.       }
  1763.     }, []);
  1764.     React.useEffect(() => {
  1765.       if (options.autoInvoke) {
  1766.         start();
  1767.       }
  1768.       return clear;
  1769.     }, [clear, start]);
  1770.     return { start, clear };
  1771.   }
  1772.   function useTextSelection() {
  1773.     const forceUpdate = useForceUpdate();
  1774.     const [selection, setSelection] = React.useState(null);
  1775.     const handleSelectionChange = () => {
  1776.       setSelection(document.getSelection());
  1777.       forceUpdate();
  1778.     };
  1779.     React.useEffect(() => {
  1780.       setSelection(document.getSelection());
  1781.       document.addEventListener("selectionchange", handleSelectionChange);
  1782.       return () => document.removeEventListener("selectionchange", handleSelectionChange);
  1783.     }, []);
  1784.     return selection;
  1785.   }
  1786.   function usePrevious(value) {
  1787.     const ref = React.useRef(void 0);
  1788.     React.useEffect(() => {
  1789.       ref.current = value;
  1790.     }, [value]);
  1791.     return ref.current;
  1792.   }
  1793.   var MIME_TYPES = {
  1794.     ico: "image/x-icon",
  1795.     png: "image/png",
  1796.     svg: "image/svg+xml",
  1797.     gif: "image/gif"
  1798.   };
  1799.   function useFavicon(url) {
  1800.     const link = React.useRef(null);
  1801.     useIsomorphicEffect(() => {
  1802.       if (!url) {
  1803.         return;
  1804.       }
  1805.       if (!link.current) {
  1806.         const existingElements = document.querySelectorAll('link[rel*="icon"]');
  1807.         existingElements.forEach((element2) => document.head.removeChild(element2));
  1808.         const element = document.createElement("link");
  1809.         element.rel = "shortcut icon";
  1810.         link.current = element;
  1811.         document.querySelector("head").appendChild(element);
  1812.       }
  1813.       const splittedUrl = url.split(".");
  1814.       link.current.setAttribute(
  1815.         "type",
  1816.         MIME_TYPES[splittedUrl[splittedUrl.length - 1].toLowerCase()]
  1817.       );
  1818.       link.current.setAttribute("href", url);
  1819.     }, [url]);
  1820.   }
  1821.   var isFixed = (current, fixedAt) => current <= fixedAt;
  1822.   var isPinnedOrReleased = (current, fixedAt, isCurrentlyPinnedRef, isScrollingUp, onPin, onRelease) => {
  1823.     const isInFixedPosition = isFixed(current, fixedAt);
  1824.     if (isInFixedPosition && !isCurrentlyPinnedRef.current) {
  1825.       isCurrentlyPinnedRef.current = true;
  1826.       onPin?.();
  1827.     } else if (!isInFixedPosition && isScrollingUp && !isCurrentlyPinnedRef.current) {
  1828.       isCurrentlyPinnedRef.current = true;
  1829.       onPin?.();
  1830.     } else if (!isInFixedPosition && isCurrentlyPinnedRef.current) {
  1831.       isCurrentlyPinnedRef.current = false;
  1832.       onRelease?.();
  1833.     }
  1834.   };
  1835.   var useScrollDirection = () => {
  1836.     const [lastScrollTop, setLastScrollTop] = React.useState(0);
  1837.     const [isScrollingUp, setIsScrollingUp] = React.useState(false);
  1838.     const [isResizing, setIsResizing] = React.useState(false);
  1839.     React.useEffect(() => {
  1840.       let resizeTimer;
  1841.       const onResize = () => {
  1842.         setIsResizing(true);
  1843.         clearTimeout(resizeTimer);
  1844.         resizeTimer = setTimeout(() => {
  1845.           setIsResizing(false);
  1846.         }, 300);
  1847.       };
  1848.       const onScroll = () => {
  1849.         if (isResizing) {
  1850.           return;
  1851.         }
  1852.         const currentScrollTop = window.pageYOffset || document.documentElement.scrollTop;
  1853.         setIsScrollingUp(currentScrollTop < lastScrollTop);
  1854.         setLastScrollTop(currentScrollTop);
  1855.       };
  1856.       window.addEventListener("scroll", onScroll);
  1857.       window.addEventListener("resize", onResize);
  1858.       return () => {
  1859.         window.removeEventListener("scroll", onScroll);
  1860.         window.removeEventListener("resize", onResize);
  1861.       };
  1862.     }, [lastScrollTop, isResizing]);
  1863.     return isScrollingUp;
  1864.   };
  1865.   function useHeadroom({ fixedAt = 0, onPin, onFix, onRelease } = {}) {
  1866.     const isCurrentlyPinnedRef = React.useRef(false);
  1867.     const isScrollingUp = useScrollDirection();
  1868.     const [{ y: scrollPosition }] = useWindowScroll();
  1869.     useIsomorphicEffect(() => {
  1870.       isPinnedOrReleased(
  1871.         scrollPosition,
  1872.         fixedAt,
  1873.         isCurrentlyPinnedRef,
  1874.         isScrollingUp,
  1875.         onPin,
  1876.         onRelease
  1877.       );
  1878.     }, [scrollPosition]);
  1879.     useIsomorphicEffect(() => {
  1880.       if (isFixed(scrollPosition, fixedAt)) {
  1881.         onFix?.();
  1882.       }
  1883.     }, [scrollPosition, fixedAt, onFix]);
  1884.     if (isFixed(scrollPosition, fixedAt) || isScrollingUp) {
  1885.       return true;
  1886.     }
  1887.     return false;
  1888.   }
  1889.   function isOpera() {
  1890.     return navigator.userAgent.includes("OPR");
  1891.   }
  1892.   function useEyeDropper() {
  1893.     const [supported, setSupported] = React.useState(false);
  1894.     useIsomorphicEffect(() => {
  1895.       setSupported(typeof window !== "undefined" && !isOpera() && "EyeDropper" in window);
  1896.     }, []);
  1897.     const open = React.useCallback(
  1898.       (options = {}) => {
  1899.         if (supported) {
  1900.           const eyeDropper = new window.EyeDropper();
  1901.           return eyeDropper.open(options);
  1902.         }
  1903.         return Promise.resolve(void 0);
  1904.       },
  1905.       [supported]
  1906.     );
  1907.     return { supported, open };
  1908.   }
  1909.   function useInViewport() {
  1910.     const observer = React.useRef(null);
  1911.     const [inViewport, setInViewport] = React.useState(false);
  1912.     const ref = React.useCallback((node) => {
  1913.       if (typeof IntersectionObserver !== "undefined") {
  1914.         if (node && !observer.current) {
  1915.           observer.current = new IntersectionObserver(
  1916.             ([entry]) => setInViewport(entry.isIntersecting)
  1917.           );
  1918.         } else {
  1919.           observer.current?.disconnect();
  1920.         }
  1921.         if (node) {
  1922.           observer.current?.observe(node);
  1923.         } else {
  1924.           setInViewport(false);
  1925.         }
  1926.       }
  1927.     }, []);
  1928.     return { ref, inViewport };
  1929.   }
  1930.   function useMutationObserver(callback, options, target) {
  1931.     const observer = React.useRef(null);
  1932.     const ref = React.useRef(null);
  1933.     React.useEffect(() => {
  1934.       const targetElement = typeof target === "function" ? target() : target;
  1935.       if (targetElement || ref.current) {
  1936.         observer.current = new MutationObserver(callback);
  1937.         observer.current.observe(targetElement || ref.current, options);
  1938.       }
  1939.       return () => {
  1940.         observer.current?.disconnect();
  1941.       };
  1942.     }, [callback, options]);
  1943.     return ref;
  1944.   }
  1945.   function useMounted() {
  1946.     const [mounted, setMounted] = React.useState(false);
  1947.     React.useEffect(() => setMounted(true), []);
  1948.     return mounted;
  1949.   }
  1950.   function useStateHistory(initialValue) {
  1951.     const [state, setState] = React.useState({
  1952.       history: [initialValue],
  1953.       current: 0
  1954.     });
  1955.     const set = React.useCallback(
  1956.       (val) => setState((currentState) => {
  1957.         const nextState = [...currentState.history.slice(0, currentState.current + 1), val];
  1958.         return {
  1959.           history: nextState,
  1960.           current: nextState.length - 1
  1961.         };
  1962.       }),
  1963.       []
  1964.     );
  1965.     const back = React.useCallback(
  1966.       (steps = 1) => setState((currentState) => ({
  1967.         history: currentState.history,
  1968.         current: Math.max(0, currentState.current - steps)
  1969.       })),
  1970.       []
  1971.     );
  1972.     const forward = React.useCallback(
  1973.       (steps = 1) => setState((currentState) => ({
  1974.         history: currentState.history,
  1975.         current: Math.min(currentState.history.length - 1, currentState.current + steps)
  1976.       })),
  1977.       []
  1978.     );
  1979.     const reset = React.useCallback(() => {
  1980.       setState({ history: [initialValue], current: 0 });
  1981.     }, [initialValue]);
  1982.     const handlers = React.useMemo(() => ({ back, forward, reset, set }), [back, forward, reset, set]);
  1983.     return [state.history[state.current], handlers, state];
  1984.   }
  1985.   function useMap(initialState) {
  1986.     const mapRef = React.useRef(new Map(initialState));
  1987.     const forceUpdate = useForceUpdate();
  1988.     mapRef.current.set = (...args) => {
  1989.       Map.prototype.set.apply(mapRef.current, args);
  1990.       forceUpdate();
  1991.       return mapRef.current;
  1992.     };
  1993.     mapRef.current.clear = (...args) => {
  1994.       Map.prototype.clear.apply(mapRef.current, args);
  1995.       forceUpdate();
  1996.     };
  1997.     mapRef.current.delete = (...args) => {
  1998.       const res = Map.prototype.delete.apply(mapRef.current, args);
  1999.       forceUpdate();
  2000.       return res;
  2001.     };
  2002.     return mapRef.current;
  2003.   }
  2004.   function useSet(values) {
  2005.     const setRef = React.useRef(new Set(values));
  2006.     const forceUpdate = useForceUpdate();
  2007.     setRef.current.add = (...args) => {
  2008.       const res = Set.prototype.add.apply(setRef.current, args);
  2009.       forceUpdate();
  2010.       return res;
  2011.     };
  2012.     setRef.current.clear = (...args) => {
  2013.       Set.prototype.clear.apply(setRef.current, args);
  2014.       forceUpdate();
  2015.     };
  2016.     setRef.current.delete = (...args) => {
  2017.       const res = Set.prototype.delete.apply(setRef.current, args);
  2018.       forceUpdate();
  2019.       return res;
  2020.     };
  2021.     return setRef.current;
  2022.   }
  2023.   function useThrottledCallbackWithClearTimeout(callback, wait) {
  2024.     const handleCallback = useCallbackRef(callback);
  2025.     const latestInArgsRef = React.useRef(null);
  2026.     const latestOutArgsRef = React.useRef(null);
  2027.     const active = React.useRef(true);
  2028.     const waitRef = React.useRef(wait);
  2029.     const timeoutRef = React.useRef(-1);
  2030.     const clearTimeout2 = () => window.clearTimeout(timeoutRef.current);
  2031.     const callThrottledCallback = React.useCallback(
  2032.       (...args) => {
  2033.         handleCallback(...args);
  2034.         latestInArgsRef.current = args;
  2035.         latestOutArgsRef.current = args;
  2036.         active.current = false;
  2037.       },
  2038.       [handleCallback]
  2039.     );
  2040.     const timerCallback = React.useCallback(() => {
  2041.       if (latestInArgsRef.current && latestInArgsRef.current !== latestOutArgsRef.current) {
  2042.         callThrottledCallback(...latestInArgsRef.current);
  2043.         timeoutRef.current = window.setTimeout(timerCallback, waitRef.current);
  2044.       } else {
  2045.         active.current = true;
  2046.       }
  2047.     }, [callThrottledCallback]);
  2048.     const throttled = React.useCallback(
  2049.       (...args) => {
  2050.         if (active.current) {
  2051.           callThrottledCallback(...args);
  2052.           timeoutRef.current = window.setTimeout(timerCallback, waitRef.current);
  2053.         } else {
  2054.           latestInArgsRef.current = args;
  2055.         }
  2056.       },
  2057.       [callThrottledCallback, timerCallback]
  2058.     );
  2059.     React.useEffect(() => {
  2060.       waitRef.current = wait;
  2061.     }, [wait]);
  2062.     return [throttled, clearTimeout2];
  2063.   }
  2064.   function useThrottledCallback(callback, wait) {
  2065.     return useThrottledCallbackWithClearTimeout(callback, wait)[0];
  2066.   }
  2067.   function useThrottledState(defaultValue, wait) {
  2068.     const [value, setValue] = React.useState(defaultValue);
  2069.     const [setThrottledValue, clearTimeout2] = useThrottledCallbackWithClearTimeout(setValue, wait);
  2070.     React.useEffect(() => clearTimeout2, []);
  2071.     return [value, setThrottledValue];
  2072.   }
  2073.   function useThrottledValue(value, wait) {
  2074.     const [throttledValue, setThrottledValue] = React.useState(value);
  2075.     const valueRef = React.useRef(value);
  2076.     const [throttledSetValue, clearTimeout2] = useThrottledCallbackWithClearTimeout(
  2077.       setThrottledValue,
  2078.       wait
  2079.     );
  2080.     React.useEffect(() => {
  2081.       if (value !== valueRef.current) {
  2082.         valueRef.current = value;
  2083.         throttledSetValue(value);
  2084.       }
  2085.     }, [throttledSetValue, value]);
  2086.     React.useEffect(() => clearTimeout2, []);
  2087.     return throttledValue;
  2088.   }
  2089.   function useIsFirstRender() {
  2090.     const renderRef = React.useRef(true);
  2091.     if (renderRef.current === true) {
  2092.       renderRef.current = false;
  2093.       return true;
  2094.     }
  2095.     return renderRef.current;
  2096.   }
  2097.   function useOrientation() {
  2098.     const [orientation, setOrientation] = React.useState({ angle: 0, type: "landscape-primary" });
  2099.     const handleOrientationChange = (event) => {
  2100.       const target = event.currentTarget;
  2101.       setOrientation({ angle: target?.angle || 0, type: target?.type || "landscape-primary" });
  2102.     };
  2103.     useIsomorphicEffect(() => {
  2104.       window.screen.orientation?.addEventListener("change", handleOrientationChange);
  2105.       return () => window.screen.orientation?.removeEventListener("change", handleOrientationChange);
  2106.     }, []);
  2107.     return orientation;
  2108.   }
  2109.   function useFetch(url, { autoInvoke = true, ...options } = {}) {
  2110.     const [data, setData] = React.useState(null);
  2111.     const [loading, setLoading] = React.useState(false);
  2112.     const [error, setError] = React.useState(null);
  2113.     const controller = React.useRef(null);
  2114.     const refetch = React.useCallback(() => {
  2115.       if (!url) {
  2116.         return;
  2117.       }
  2118.       if (controller.current) {
  2119.         controller.current.abort();
  2120.       }
  2121.       controller.current = new AbortController();
  2122.       setLoading(true);
  2123.       return fetch(url, { signal: controller.current.signal, ...options }).then((res) => res.json()).then((res) => {
  2124.         setData(res);
  2125.         setLoading(false);
  2126.         return res;
  2127.       }).catch((err) => {
  2128.         setLoading(false);
  2129.         if (err.name !== "AbortError") {
  2130.           setError(err);
  2131.         }
  2132.         return err;
  2133.       });
  2134.     }, [url]);
  2135.     const abort = React.useCallback(() => {
  2136.       if (controller.current) {
  2137.         controller.current?.abort("");
  2138.       }
  2139.     }, []);
  2140.     React.useEffect(() => {
  2141.       if (autoInvoke) {
  2142.         refetch();
  2143.       }
  2144.       return () => {
  2145.         if (controller.current) {
  2146.           controller.current.abort("");
  2147.         }
  2148.       };
  2149.     }, [refetch, autoInvoke]);
  2150.     return { data, loading, error, refetch, abort };
  2151.   }
  2152.   function radiansToDegrees(radians) {
  2153.     return radians * (180 / Math.PI);
  2154.   }
  2155.   function getElementCenter(element) {
  2156.     const rect = element.getBoundingClientRect();
  2157.     return [rect.left + rect.width / 2, rect.top + rect.height / 2];
  2158.   }
  2159.   function getAngle(coordinates, element) {
  2160.     const center = getElementCenter(element);
  2161.     const x = coordinates[0] - center[0];
  2162.     const y = coordinates[1] - center[1];
  2163.     const deg = radiansToDegrees(Math.atan2(x, y)) + 180;
  2164.     return 360 - deg;
  2165.   }
  2166.   function toFixed(value, digits) {
  2167.     return parseFloat(value.toFixed(digits));
  2168.   }
  2169.   function getDigitsAfterDot(value) {
  2170.     return value.toString().split(".")[1]?.length || 0;
  2171.   }
  2172.   function normalizeRadialValue(degree, step) {
  2173.     const clamped = clamp(degree, 0, 360);
  2174.     const high = Math.ceil(clamped / step);
  2175.     const low = Math.round(clamped / step);
  2176.     return toFixed(
  2177.       high >= clamped / step ? high * step === 360 ? 0 : high * step : low * step,
  2178.       getDigitsAfterDot(step)
  2179.     );
  2180.   }
  2181.   function useRadialMove(onChange, { step = 0.01, onChangeEnd, onScrubStart, onScrubEnd } = {}) {
  2182.     const ref = React.useRef(null);
  2183.     const mounted = React.useRef(false);
  2184.     const [active, setActive] = React.useState(false);
  2185.     React.useEffect(() => {
  2186.       mounted.current = true;
  2187.     }, []);
  2188.     React.useEffect(() => {
  2189.       const update = (event, done = false) => {
  2190.         if (ref.current) {
  2191.           ref.current.style.userSelect = "none";
  2192.           const deg = getAngle([event.clientX, event.clientY], ref.current);
  2193.           const newValue = normalizeRadialValue(deg, step || 1);
  2194.           onChange(newValue);
  2195.           done && onChangeEnd?.(newValue);
  2196.         }
  2197.       };
  2198.       const beginTracking = () => {
  2199.         onScrubStart?.();
  2200.         setActive(true);
  2201.         document.addEventListener("mousemove", handleMouseMove, false);
  2202.         document.addEventListener("mouseup", handleMouseUp, false);
  2203.         document.addEventListener("touchmove", handleTouchMove, { passive: false });
  2204.         document.addEventListener("touchend", handleTouchEnd, false);
  2205.       };
  2206.       const endTracking = () => {
  2207.         onScrubEnd?.();
  2208.         setActive(false);
  2209.         document.removeEventListener("mousemove", handleMouseMove, false);
  2210.         document.removeEventListener("mouseup", handleMouseUp, false);
  2211.         document.removeEventListener("touchmove", handleTouchMove, false);
  2212.         document.removeEventListener("touchend", handleTouchEnd, false);
  2213.       };
  2214.       const onMouseDown = (event) => {
  2215.         beginTracking();
  2216.         update(event);
  2217.       };
  2218.       const handleMouseMove = (event) => {
  2219.         update(event);
  2220.       };
  2221.       const handleMouseUp = (event) => {
  2222.         update(event, true);
  2223.         endTracking();
  2224.       };
  2225.       const handleTouchMove = (event) => {
  2226.         event.preventDefault();
  2227.         update(event.touches[0]);
  2228.       };
  2229.       const handleTouchEnd = (event) => {
  2230.         update(event.changedTouches[0], true);
  2231.         endTracking();
  2232.       };
  2233.       const handleTouchStart = (event) => {
  2234.         event.preventDefault();
  2235.         beginTracking();
  2236.         update(event.touches[0]);
  2237.       };
  2238.       ref.current?.addEventListener("mousedown", onMouseDown);
  2239.       ref.current?.addEventListener("touchstart", handleTouchStart, { passive: false });
  2240.       return () => {
  2241.         if (ref.current) {
  2242.           ref.current.removeEventListener("mousedown", onMouseDown);
  2243.           ref.current.removeEventListener("touchstart", handleTouchStart);
  2244.         }
  2245.       };
  2246.     }, [onChange]);
  2247.     return { ref, active };
  2248.   }
  2249.   exports.assignRef = assignRef;
  2250.   exports.clamp = clamp;
  2251.   exports.clampUseMovePosition = clampUseMovePosition;
  2252.   exports.getHotkeyHandler = getHotkeyHandler;
  2253.   exports.lowerFirst = lowerFirst;
  2254.   exports.mergeRefs = mergeRefs;
  2255.   exports.normalizeRadialValue = normalizeRadialValue;
  2256.   exports.randomId = randomId;
  2257.   exports.range = range;
  2258.   exports.readLocalStorageValue = readLocalStorageValue;
  2259.   exports.readSessionStorageValue = readSessionStorageValue;
  2260.   exports.shallowEqual = shallowEqual;
  2261.   exports.upperFirst = upperFirst;
  2262.   exports.useCallbackRef = useCallbackRef;
  2263.   exports.useClickOutside = useClickOutside;
  2264.   exports.useClipboard = useClipboard;
  2265.   exports.useColorScheme = useColorScheme;
  2266.   exports.useCounter = useCounter;
  2267.   exports.useDebouncedCallback = useDebouncedCallback;
  2268.   exports.useDebouncedState = useDebouncedState;
  2269.   exports.useDebouncedValue = useDebouncedValue;
  2270.   exports.useDidUpdate = useDidUpdate;
  2271.   exports.useDisclosure = useDisclosure;
  2272.   exports.useDocumentTitle = useDocumentTitle;
  2273.   exports.useDocumentVisibility = useDocumentVisibility;
  2274.   exports.useElementSize = useElementSize;
  2275.   exports.useEventListener = useEventListener;
  2276.   exports.useEyeDropper = useEyeDropper;
  2277.   exports.useFavicon = useFavicon;
  2278.   exports.useFetch = useFetch;
  2279.   exports.useFocusReturn = useFocusReturn;
  2280.   exports.useFocusTrap = useFocusTrap;
  2281.   exports.useFocusWithin = useFocusWithin;
  2282.   exports.useForceUpdate = useForceUpdate;
  2283.   exports.useFullscreen = useFullscreen;
  2284.   exports.useHash = useHash;
  2285.   exports.useHeadroom = useHeadroom;
  2286.   exports.useHotkeys = useHotkeys;
  2287.   exports.useHover = useHover;
  2288.   exports.useId = useId;
  2289.   exports.useIdle = useIdle;
  2290.   exports.useInViewport = useInViewport;
  2291.   exports.useInputState = useInputState;
  2292.   exports.useIntersection = useIntersection;
  2293.   exports.useInterval = useInterval;
  2294.   exports.useIsFirstRender = useIsFirstRender;
  2295.   exports.useIsomorphicEffect = useIsomorphicEffect;
  2296.   exports.useListState = useListState;
  2297.   exports.useLocalStorage = useLocalStorage;
  2298.   exports.useLogger = useLogger;
  2299.   exports.useMap = useMap;
  2300.   exports.useMediaQuery = useMediaQuery;
  2301.   exports.useMergedRef = useMergedRef;
  2302.   exports.useMounted = useMounted;
  2303.   exports.useMouse = useMouse;
  2304.   exports.useMove = useMove;
  2305.   exports.useMutationObserver = useMutationObserver;
  2306.   exports.useNetwork = useNetwork;
  2307.   exports.useOrientation = useOrientation;
  2308.   exports.useOs = useOs;
  2309.   exports.usePageLeave = usePageLeave;
  2310.   exports.usePagination = usePagination;
  2311.   exports.usePrevious = usePrevious;
  2312.   exports.useQueue = useQueue;
  2313.   exports.useRadialMove = useRadialMove;
  2314.   exports.useReducedMotion = useReducedMotion;
  2315.   exports.useResizeObserver = useResizeObserver;
  2316.   exports.useScrollIntoView = useScrollIntoView;
  2317.   exports.useSessionStorage = useSessionStorage;
  2318.   exports.useSet = useSet;
  2319.   exports.useSetState = useSetState;
  2320.   exports.useShallowEffect = useShallowEffect;
  2321.   exports.useStateHistory = useStateHistory;
  2322.   exports.useTextSelection = useTextSelection;
  2323.   exports.useThrottledCallback = useThrottledCallback;
  2324.   exports.useThrottledState = useThrottledState;
  2325.   exports.useThrottledValue = useThrottledValue;
  2326.   exports.useTimeout = useTimeout;
  2327.   exports.useToggle = useToggle;
  2328.   exports.useUncontrolled = useUncontrolled;
  2329.   exports.useValidatedState = useValidatedState;
  2330.   exports.useViewportSize = useViewportSize;
  2331.   exports.useWindowEvent = useWindowEvent;
  2332.   exports.useWindowScroll = useWindowScroll;
  2333. }));

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址